To build wxMaxima from sources you need to have a C++ compiler (C++20 is required), wxWidgets >= 3.0 (>= 3.2 recommended) (including development headers) and CMake >= 3.16 installed.

Compiling wxMaxima on Linux / Unix systems and Linux-like systems (Cygwin, WSL, MacPorts, Fink, Homebrew,...)

wxMaxima is built using the CMake build system.

The following steps will build and install wxMaxima using CMake. Download and extract wxMaxima (the latest release or a git clone or zip snapshot of the latest development version) and change in the wxMaxima tree. Then:

mkdir -p build          # create a build directory (may even be outside the wxmaxima code)
cd build                # change to the build directory
cmake ..                # configure the build.
                        # .. is the path to the extracted wxMaxima code - if you use another build directory, adjust.
cmake --build .         # build wxMaxima
                        # You can speed up the build, if you have multiple CPU cores, using
                        # cmake --build . -- -j 4
                        # (-j 4 means: Use 4 CPU cores). Adjust the number for your CPU.

Now you can test your wxMaxima build (or just use it without installation) by calling:

./wxmaxima-local

If everything is okay install wxMaxima with:

sudo cmake --build . -- install

If you want to install into a special prefix (not /usr/local), add -DCMAKE_INSTALL_PREFIX=/your/installation/prefix to the first cmake invocation. E.g.

cmake -DCMAKE_INSTALL_PREFIX=/opt/wxmaxima ..

By default a "Debug" build will be made (less optimization, debug symbols) - and this build shows the wxMaxima log window (may contain helpful log messages) when started; if you want to create a "Release" build (more optimization, the log window is not shown by default, it can be toggled on and off using "View->Toggle log window") set the build type (CMake supports other build types too) using:

cmake -DCMAKE_BUILD_TYPE=Release ..

Of course you can use the CMake GUI (cmake-gui) or curses based CMake (ccmake) for the configure step and change some CMake variables.

If you want to create binary packages (tar.gz, tar.bz2, DEB & RPM, on macOS also .dmg), the following command will create them:

cmake --build . -- package

To update the locale files (po and pot) in the source code:

cmake --build . -- update-locale

Testing wxMaxima

You can use (or test) a fresh compiled wxMaxima (without installation) by calling ./wxmaxima-local from the build-directory.

wxMaxima comes with several tests, which can be run using

ctest

from the build directory. If you want to run a single test, you can use the option -R <name-of-the-test> when calling ctest. The tests (and their names) can be seen in the file test/CMakeLists.txt of the source code.

On Linux/Unix the tests usually require a X Server; if you start the tests without an X server (e.g. automatic tests using cron, when doing tests using a continuous integration system, etc.) you can use xvfb-run to create a virtual X Server environment, e.g. just run: xvfb-run ctest

macOS: Creating a portable .apk and .dmg installer

This requires wxWidgets to be installed, e.G. using MacPorts. If you are in the extracted wxMaxima directory, call e.g.

mkdir ../build-wxm
cmake -S . -B ../build-wxm -DCMAKE_INSTALL_PREFIX=.
cmake --build ../build-wxm
cmake --build ../build-wxm --install

Ubuntu or Debian build prerequisites

sudo apt-get install build-essential libwxgtk3.2-dev libwxgtk-webview3.2-dev wx3.2-i18n ibus-gtk ibus-gtk3 checkinstall gettext cmake pandoc po4a libfribidi-dev

(libfribidi-dev is optional – see "New optional dependency: libfribidi" under "Additional information for packagers" below. po4a needs to be version 0.70 or newer – an older one (e.g. Ubuntu 24.04's own po4a 0.69 package) is detected and silently not used, with a CMake warning explaining why, rather than risk it corrupting the translated manual; see CheckPo4aVersion.cmake.)

beforehand or (if apt-get is configured to load the source package repositories and not only the binary packages) by the simpler

sudo apt-get build-dep wxmaxima

You must use the apt-get install command when the version you are building has dependencies which are not listed as dependencies in your distro's repository version of wxmaxima.

macOS X prerequisites

On macOS X you most probably need the command-line compiler one can tell Xcode to install. Additionally wxWidgets needs to be installed, which can be done using Homebrew, Fink or MacPorts and should be named wxWidgets or wxMac there. XCode versions older than version 13.0 have problems compiling wxMaxima. Optionally, brew install fribidi – see "New optional dependency: libfribidi" under "Additional information for packagers" below.

Additional information about building on macOS:

Compiling on Windows

You can use the MinGW-w64 (https://www.mingw-w64.org/) compilers.

You can also build using MS Visual Studio 2019 or newer. Since MSVS provides adequate versions of both cmake and ninja, there's no need to install those. The build has to start from within the x64 Native Tools Command Prompt, and you have to first build wxWidgets before you build wxmaxima. You can get some inspiration about how to do both of these steps by examining the MSVC build steps in .github/workflows/compile_windows.yml.

Note for the Mingw-w64 compiler and crosscompiler

These compilers come with two forms of thread support - win32 and posix. The win32 thread version does not support std::thread, which wxMaxima uses for multithreading, so be sure to install or reconfigure the posix version.

On Ubuntu Linux the crosscompiler x86_64-w64-mingw32-g++ can be reconfigured using:

update-alternatives --config x86_64-w64-mingw32-g++

(For 32 bit the same works for the 32 bit crosscompiler i686-w64-mingw32-g++.)

Compiling for Android 9

Some information how to build for Android 9 can be found in the wxMaxima discussion forum: https://github.com/wxMaxima-developers/wxmaxima/discussions/1594

Documentation of the source

An HTML version of wxMaxima's source code documentation can be found at https://wxmaxima-developers.github.io/wxmaxima/Doxygen-documentation/

A local version of the documentation of wxMaxima's source can be generated using doxygen and the doxygen target:

cmake --build ../build-wxm -- doxygen

wxWidgets isn't found

CMake has currently (Feb 2022) problems finding a wxWidgets that was compiled using CMake. If that is the reason maybe wxWidgets was compiled without wxWebView. In that case

cmake -S . -B ../build-wxm -DWXM_DISABLE_WEBVIEW=on

might allow cmake to find wxWidgets at the cost of losing the integrated dockable help browser.

wxWidgets without QA component

One can use the option -DWXM_DISABLE_QA=on to disable that library, if necessary. Reported in issue #2064.

Additional information for packagers

New optional dependency: libfribidi

wxMaxima can optionally link libfribidi for correct caret placement, mouse clicks, arrow-key movement and selection highlighting on a worksheet line that mixes left-to-right and right-to-left text (e.g. a Farsi word next to a German one). It is detected automatically via pkg-config at configure time (WXM_USE_FRIBIDI, a CMake option, defaults to ON) and needs no other configuration; without it (or with -DWXM_USE_FRIBIDI=off) wxMaxima builds and runs exactly as before, just with the older, single-direction-only approximation on a mixed-direction line. Packages that don't need right-to-left support, or that target a system libfribidi doesn't cover, can skip the -dev package entirely.

The package is called libfribidi-dev on Debian/Ubuntu, fribidi-devel on Fedora/RHEL, fribidi on Homebrew/MacPorts/Arch, and mingw-w64-x86_64-fribidi under MSYS2.

Creating a standalone wxMaxima

wxMaxima, if linked statically, is pretty standalone and therefore fit for creating a portable app:

It only depends on one single required library: wxWidgets, that can be linked statically (libfribidi, above, is optional),
And besides a working maxima installation it only attempts to use two sets of external files: The manual and the translation files.

If a wxMaxima install should come without manual or translation files that might not be the end of the world, neither:

If the translation files are not found, the program will still work, but will be using english.
And if there are no manual files wxMaxima will redirect the system's web browser to an online version of the manual, instead.

Troubleshooting

If you have problems when compiling wxMaxima, maybe a look in the configurations for various CI-Systems (the files in .github/workflows/) may be helpful to see, how wxMaxima is compiled on these systems.

If something is not clear / should be improved in that document, please open an issue. This document should help YOU to compile wxMaxima.