As of February 2005 (starting with Tux Paint 0.9.15), the "Makefile" includes support for building on a Windows system using MinGW/MSYS (https://sourceforge.net/projects/msys2/).

Many tools and libraries are required to build Tux Paint. The package management system "pacman" helps you install them automatically solving complicated dependencies.

ImageMagick is a compilation of command line tools to create, edit, compose, or convert bitmap images supporting quite a large number of image formats. Tux Paint uses two functions ("convert" and "composite") in it to generate thumbnails for startar images and templates during the build process.

Using official binary release available from "Windows Binary Release" is recommended, due to the commands installed with "pacman" on MinGW/MSYS not working as expected!

Do not forget to enable "Install legacy utilities (e.g. convert)" while installing it, because Tux Paint's build process uses them.

Add the path to the directory in which ImageMagick is installed at the top of your "PATH" environment variable. For example:

$ export PATH=/c/Program\ Files/ImageMagick-7.0.10-Q16-HDRI:$PATH

You can make this permanent by adding the above to your the BASH shell configuration file, "~/.bash_profile".

You can compile 64-bit binaries using "MSYS2 64bit" shell, and 32-bit binaries using "MSYS2 32bit" shell, respectively.

• Select "MSYS2 64bit" → "MSYS2 MinGW 64-bit" from the "Start Menu" to open the 64bit shell.
• Select "MSYS2 64bit" → "MSYS2 MinGW 32-bit" from the "Start Menu" to open the 32bit shell.

All the files needed for starting Tux Paint (and Tux Paint Config.) are collected in the directory for binary distribution "bdist" directory under "win32". You can start them by double-clicking their executable (.exe) files in the "bdist" directory.

Inno Setup is used to build executable installer for Tux Paint. Therefore you have to install it in the first place.

Inno Setup officially supports translations for only about 20 languages. However, one of the great points of Tux Paint is it supports so many languages. Therefore, the set up script "tuxpaint.iss" to build the installer is written to use much more translations including unofficial one which are available on "Inno Setup Translations". You have to download translation files (.isl) required and put them in "Languages" directory under the directory in which Inno Setup is installed.

Before building an installer, edit the "tuxpaint.iss" file and enable one of the lines starting with "#define BuildTarget=", depending on the architecture of the installer you want to create.

Then, you can easily build an executable installer by right-clicking on the "tuxpaint.iss" icon in the "win32" directory and selecting "Compile" on the list. It will run for a while, and eventually you will find a "tuxpaint-X.Y.Z-windows-<arch>-installer.exe" file in the same directory.

Double-click the Tux Paint installer executable (.EXE file) and follow the instructions.

First, you will be asked to read the license. (It is the GNU General Public License (GPL), which is also available as "COPYING.txt".)

You will then be asked whether you want to install shortcuts to Tux Paint in your Windows Start Menu and on your Windows Desktop. (Both options are set by default.)

Then you will be asked where you wish to install Tux Paint. The default should be suitable, as long as there is space available. Otherwise, pick a different location.

At this point, you can click 'Install' to install Tux Paint!

To change program settings, right-click on the TuxPaint shortcut and select 'Properties' (at the bottom).

Make sure the 'Shortcut' tab is selected in the window that appears, and examine the 'Target:' field. You should see something like this:

"C:\Program Files\TuxPaint\TuxPaint.exe"

You can now add command-line options which will be enabled when you double-click the icon.

For example, to make the game run in fullscreen mode, with simple shapes (no rotation option) and in French, add the options (after 'TuxPaint.exe'), like so:

"C:\Program Files\TuxPaint\TuxPaint.exe" -f -s --lang french

(See the main documentation for a full list of available command-line options.)

If you make a mistake or it all disappears use [Control] + [Z] to undo or just hit the [Esc] key and the box will close with no changes made (unless you pushed the "Apply" button!).

When you have finished, click "OK."

If, when you double-click on the shortcut to run Tux Paint, nothing happens, it is probably because some of these command-line options are wrong. Open an Explorer, and look for a file called "stderr.txt" in your personal saving folder for TuxPaint which is normaly "C:\Users\username\AppData\Roaming\TuxPaint".

It will contain a description of what was wrong. Usually it will just be due to incorrect character-case (capital 'Z' instead of lowercase 'z') or a missing (or extra) '-' (dash).

💡 Note: Tux Paint does not use autoconf/automake, so there is no "./configure" script to run. Compiling should be straight-forward though, assuming everything Tux Paint needs is installed.

To compile the program from source, simply run the following command from a shell prompt (e.g., "$"):

$ make

To disable SVG support (e.g., if your system is not currently supported by the Cairo library or other SVG-related dependencies), you can run "make" with "SVG_LIB= SVG_CFLAGS= NOSVGFLAG=NOSVG" added:

$ make SVG_LIB= SVG_CFLAGS=

If you don't have a sound card, or would prefer to build the program with no sound support (and therefore without a the SDL_mixer dependency), you can run "make" with "SDL_MIXER_LIB=" added:

$ make SDL_MIXER_LIB=

Various other options (e.g., installation paths) may be overridden; see them in "Makefile" for further details.

If you receive any errors during compile-time, make sure you have the appropriate libraries installed (see above). If using packaged versions of the libraries (e.g., RPMs under RedHat or DEBs under Debian), be sure to get the corresponding "-dev" or "-devel" packages as well, otherwise you won't be able to compile Tux Paint (and other programs) from source!

Assuming no fatal errors occured, you can now install the program so that it can be run by users on the system. By default, this must be done by the "root" user ('superuser'). Switch to "root" by typing the command:

$ su

Enter "root"'s password at the prompt. You should now be "root" (with a prompt like "#"). To install the program and its data files, type:

# make install

Finally, you can switch back to your regular user by exiting superuser mode:

# exit

Alternatively, you may be able to simply use the "sudo" command (e.g., on Ubuntu Linux):

$ sudo make install

💡 Note: By default, "tuxpaint", the executable program, is placed in "/usr/local/bin/". The data files (images, sounds, etc.) are placed in "/usr/local/share/tuxpaint/".

Although Tux Paint is built without the Xcode IDE, Xcode itself is still required to build Tux Paint. Download it from the App Store, and launch it once to accept its license agreements. You may also need to install the Xcode command line tools using the command:

$ xcode-select --install

Building Tux Paint also requires various libraries. We install them from MacPorts where possible, source code otherwise. Install MacPorts to the default /opt/local path according to the instructions found on their website: https://www.macports.org/

• ImageMagick
• cairo
• fribidi
• lbzip2
• libimagequant^*
• libpaper
• libpng
• librsvg
• libsdl2
• libsdl2_image
• libsdl2_mixer
• libsdl2_pango^*
• libsdl2_ttf
• libsdl2_gfx
• pkgconfig
• zlib

WARNING: Having any UNIX-like toolset installed on your Mac besides MacPorts and Xcode, such as Fink or Brew, will prevent your app bundle from being portable. Be sure Fink and Brew are not accessible from your build environment.

Simply, run:

% make
% make install

Additional steps are required when building a Unviersal Binary. See "Building a Universal Binary" below.

• A macOS binary built on a specific version of macOS only runs on that version of macOS or later. To ensure Tux Paint can run on the oldest version of macOS possible, build it on the oldest version of macOS available. As of this writing we know Tux Paint cannot be built to run on macOS 10.7 or earlier.
  
  See "Old Versions of macOS" below for best-effort instructions on how to obtain, install, and build Tux Paint on an old version of macOS.
  
  Alternatively, Tux Paint and all of its library dependencies may be compiled with appropriate options to be runnable on older versions of macOS. These options are already set on Tux Paint, so only its dependencies (from MacPorts) need to be recompiled. See "Recompiling MacPorts" below for the instructions.

Some old versions of macOS can be downloaded from Apple's support page: https://support.apple.com/en-us/HT211683

macOS for Intel CPU does allow dual booting of multiple versions of the OS, but it's safer and easier to install the old macOS onto a flash drive. Wherever you're installing it, the target drive's partitioniong scheme and partition type must match what the old macOS expects, so use the Disk Utility to partition and format the flash drive accordingly.

Dual booting multiple versions of macOS for Apple Silicon has been so far unsuccessful. Instead of installing an older version of macOS for Apple Silicon to build Tux Paint to run on the old version of macOS for Apple Silicon, use the instructions found in the "Recompiling MacPorts" section to build Tux Paint to run on older versions of macOS for Apple Silicon.

As of this writing, the oldest version of macOS available on Apple's support site is Yosemite 10.10, which expects "GPT (GUID Partition Table)" partitioning scheme instead of the older MBR scheme, and "Mac OS Extended (Journaled)" as the partition type instead of the newer APFS partition type.

Upon launching the installer, if you get a popup about macOS being too old or new to be installed, a bootable installer can be created using the instructions found here: https://support.apple.com/en-mide/HT201372

Once the old macOS is installed, you may find the Xcode on the App Store is too new to run on the version of the old macOS. Old versions of Xcode can be downloaded from Apple's Developer site in an area accessible with free registration: https://developer.apple.com/download/more/

The list of macOS versions and the last version of Xcode compatible with them are laid out nicely on the Wikipedia page on Xcode: https://en.wikipedia.org/wiki/Xcode#Version_comparison_table

And because Xcode is being installed manually, you can skip the step to install the Xcode command line tools (do not run "xcode-select --install") but otherwise build Tux Paint using the same steps described in the earlier part of this document.

To recompile MacPorts to be usable on older versions of macOS, set the following options in /opt/local/etc/macports/macports.conf:

buildfromsource always
macosx_deployment_target 10.10

Then uninstall all MacPorts packages:

$ sudo port -fp uninstall installed

Then reinstall all MacPorts packages needed by Tux Paint. Also rebuild libimagequant using the updated Cargo package from MacPorts.

As of this writing, all libraries Tux Paint requires from MacPorts can be recompiled in this manner to run on macOS 10.10 Yosemite and later on Intel CPUs, and macOS 11.0 Big Sur and later on Apple Silicon. Unfortunately, although MacPorts has the option to enable the building of universal libraries, several libraries Tux Paint require cannot be built as universal libraries so they can only be built to run natively on the hardware on which they were built. See "Building a Universal Binary" below for instructions on how to build Tux Paint as a Universal Binary.

To build Tux Paint as a Universal Binary, compile Tux Paint for the Intel CPU and the Apple Silicon separately first. Then rename the app bundle for the Intel CPU to TuxPaint-x86_64.app, and the bundle for the Apple Silicon to TuxPaint-arm64.app, copy the app bundle from the Intel machine to the Apple Silicon machine, then use the provided build-universal.sh script to combine the two application bundles as below. The DMG file can be built afterwards:

$ macos/build-universal.sh
$ make TuxPaint.dmg

You will need recent versions of:

• Gradle — build automation tool
• Android Studio (Software Development Kit (SDK)) — to support Android app development (Java)
• Android Native Development Kit (NDK) — to support native development in C/C++

To compile the latest Tux Paint, one has to sync the main SourceForge project's tuxpaint Git repository with the GitHub project's TuxPaint-Android Git repository. (Pere uses a shell script that backs up the app/src/main/jni/tuxpaint directory in the Tuxpaint-Android GitHub repo and makes a build of SourceForge's tuxpaint to generate translations and other things that are not autogenerated in the Android builds, and then copies the SourceForge tuxpaint back to Tuxpaint-Android.) (FIXME: It should be checked-in somewhere. For now, see https://sourceforge.net/p/tuxpaint/feature-requests/224/)

For it to run you need the tuxpaint and Tuxpaint-Android sources one next to one another, and the script in the directory containing both.

Fill the app/src/main/assets directory by running cd app/src/main/jni/tuxpaint && ./mkzip_assets.sh

The Gradle build generates some variants: PlayStore, debugPlayStore, offPlayStore and debugoffPlayStore. You must sign the non-debug ones to be able to install them. (FIXME: Link to info on how to sign.) (Note: "playStore" ones are intended to be uploaded to Google Play; this is currently managed by Terrence Sheflin —March 2023. "offPlayStore" is the flavor that we distribute as APK files on the Tux Paint website and SourceForge file hosting, and is the variant built by the F-Droid app. repository.)

To trigger a build from F-droid, it suffices to tag a commit and push it to GitHub. That doesn't guarantee the build will succeed though, so Pere usually runs a local F-droid server to test the build and eventually adapt the F-droid's build receipt before pushing the tag to GitHub.

The builds Pere distributes are all made with that local F-droid server. It has the advantage of packing the sources and logs, and signing the APK. Most importantly, it uses the same tools F-Droid will use to build Tux Paint, so you can detect problems beforehand.

The receipt Pere uses for F-Droid builds is in the metadata dir of https://gitlab.com/fdroid/fdroiddata. The F-Droid server code is at https://gitlab.com/fdroid/fdroidserver. To generate the server you will need 1GB free on disk. Run the makebuildserver tool they provide, then, from the root of fdroiddata, run ../fdroidserver/fdroid build --server org.tuxpaint:NNNN (NNNN = version, e.g. 9288)

Install the required develop packages in Terminal:

32-bit:

pkgman install xcairo_x86_devel fribidi_x86_devel gdk_pixbuf_x86_devel libiconv_x86_devel libimagequant_x86_devel gettext_x86_libintl libpaper_x86_devel pango_x86_devel libpng16_x86_devel librsvg_x86_devel libsdl2_x86_devel sdl2_image_x86_devel sdl2_gfx_x86_devel sdl2_mixer_x86_devel sdl2_pango_x86_devel sdl2_ttf_x86_devel zlib_x86_devel

64-bit:

pkgman install xcairo_devel fribidi_devel gdk_pixbuf_devel libiconv_devel libimagequant_devel gettext_libintl libpaper_devel pango_devel libpng16_devel librsvg_devel libsdl2_devel sdl2_image_devel sdl2_gfx_devel sdl2_mixer_devel sdl2_pango_devel sdl2_ttf_devel zlib_devel

For 32-bit you need to switch to the new compiler (currently gcc 11.2.0) with setarch x86

make PREFIX=/boot/home/config/non-packaged

make install-all DATA_PREFIX=/boot/home/config/non-packaged/share/tuxpaint/

If you installed the Start Menu shortcuts (the default), then go to the TuxPaint folder and select "Uninstall". A box will be displayed that will confirm that you are about to uninstall Tux Paint and, if you are certain that you want to permanently remove Tux Paint, click on the 'Uninstall' button.

When it has finished, click on the close button.

It is also possible to use the entry "TuxPaint (remove only)" in the Control Panel Add/Remove programs section.