Thomas labyrinth (slightly twisted) computed by Runge

Runge main window

Runge

Runge is an interactive desktop solver for systems of ordinary differential equations. Define a system and its initial conditions, compute a solution with adaptive step sizes, and explore its trajectories in 2D or 3D. The application uses a Qt 6 interface, a C++ numerical core built on CVM, and Fortran solvers backed by BLAS and LAPACK. It supports macOS, Linux, and Windows.

Features

• Enter equations as mathematical expressions, with analytic differentiation for solvers that require Jacobians or time derivatives.
• Solve autonomous and non-autonomous systems, including systems with a separate linear part.
• Choose England, Lawson, or Rosenbrock methods and set the integration interval, error tolerance, and step-size limits.
• Compare multiple solutions in interactive 2D and 3D viewers; start a new trajectory from a point selected in the 2D viewer.
• Save and reopen .runge files, export numerical results as CSV or MATLAB scripts, and export plots as images.
• Add custom solver libraries through an XML configuration.

Using Runge

1. Define the variables and system expressions, then select a compatible solver.
2. Set the initial values, integration interval, tolerance, and step-size limits.
3. Start the calculation and inspect the solution in a 2D or 3D viewer.
4. Save the session or export a selected solution for further analysis.

The user manual covers expressions, solver selection, graphics, and export. It is also available through the application's Help menu, and as a PDF.

Included solvers

Method	Supported system forms	Library
England	x' = F(t, x)	des_engl
Lawson	x' = F(t, x), x' = A(t)x + fi(t), x' = Bx + f(t, x)	des_lou
Rosenbrock	x' = F(x), x' = F(t, x)	des_ros

The built-in platform configurations are embedded in the application. Custom configurations can be loaded from disk; their solver library paths resolve relative to the executable. See the solver configuration notes.

Build requirements

For the desktop application and regression tests:

• CMake 3.22 or newer; 3.24 or newer when building CVM from source.
• A C++20 compiler and standard library supporting CVM's headers, including std::format.
• Qt 6 with Widgets, Help, OpenGL, OpenGLWidgets, Xml, and PrintSupport; Qt Test is also required when building the GUI regression test.
• OpenGL development support.
• CVM headers (cvm.h and cfun.h) and a compatible library, or the CVM source tree.
• A Fortran compiler and compatible BLAS/LAPACK libraries.

Runge, CVM, the Fortran solvers, and BLAS/LAPACK must agree on architecture and integer ABI. The default is ILP64, with 64-bit numerical-library integers. On Apple Silicon, the solver build searches Arm Performance Libraries under /opt/arm. On Windows, source builds of CVM with MSVC on x64 use Intel MKL.

Build the desktop application

Run the following commands from the repository root, replacing the dependency paths with your installations:

cmake -S runge -B build \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_PREFIX_PATH=/path/to/Qt/kit \
  -DCVM_ROOT=/path/to/cvm \
  -DRUNGE_BUILD_TESTS=OFF
cmake --build build --config Release --parallel

CVM_ROOT can point to a CVM source or installation tree. If automatic discovery does not find the installed files, specify CVM_INCLUDE_DIR and CVM_LIBRARY explicitly; the include directory must contain both required headers. Use CVM_EXTRA_LIBRARIES for additional link dependencies when needed.

To build CVM with Runge's compiler and SDK, add -DRUNGE_BUILD_CVM=ON to the configure command and point CVM_ROOT to its source tree. CVM is built under build/cvm-dependency, without replacing the libraries in its source tree. This avoids a C++ ABI mismatch when an installed CVM was built with a different standard library, such as GCC's libstdc++ versus Apple Clang's libc++.

Launch the application from the build directory:

Platform	Application
macOS	open build/Runge.app
Linux	./build/Runge
Windows, multi-configuration generator	build/Release/Runge.exe

Windows builds deploy the required runtime DLLs and Qt plugins beside the application by default. macOS builds copy the solver libraries and English help collection into the app bundle; use the DMG target below to bundle its external dependencies for distribution.

Changing compilers or architectures requires a separate build directory. CMake caches dependency paths and options between builds.

Build a Debian/Ubuntu installer

Build a Release binary package on the Debian/Ubuntu release and architecture you intend to support, using the distribution's Qt 6 packages:

./Runge/scripts/build-linux-deb.sh --cvm-root "$HOME/cvmlib"

The default output is Runge/dist/Runge.deb. The installer script selects shared Intel MKL for CVM and the solvers, even if an older build cached another BLAS vendor. When --cvm-root contains a source tree, CVM is built with Runge's compiler inside the package build directory.

The package includes Qt 6 libraries and plugins, CVM, Intel MKL and its CPU backends, the solver libraries, English help, license notices, and a desktop launcher. These libraries are private to Runge under /usr/lib/runge; Qt and MKL do not need to be installed separately on the destination machine. Remaining system dependencies, such as libc and graphics/font libraries, are detected automatically by dpkg-shlibdeps.

Install the package with sudo apt install ./Runge/dist/Runge.deb, then launch runge or use the application menu. Standalone Qt SDKs are unsupported for this package; build separately for each target distribution release and architecture. See the Linux installer guide for prerequisites and options, or run the script with --help.

Build a macOS installer

With a CVM source tree, build an app and compressed disk image using:

./runge/scripts/build-macos-dmg.sh \
  --qt-prefix "$HOME/Qt/6.11.1/macos" \
  --cvm-root "$HOME/cvmlib" \
  --build-cvm

The default output is runge/dist/Runge.dmg. Open the image and drag Runge.app to Applications. The package includes Qt frameworks and plugins, CVM, the three solver libraries, their runtime dependencies, and the English help collection. The packaging target checks that non-system dependencies resolve inside the bundle and verifies its code signature.

Omit --build-cvm to use a compatible installed CVM library in a build directory where RUNGE_BUILD_CVM is off. The default signature is ad-hoc; use --sign-identity "Developer ID Application: …" to select a distribution identity. The script does not notarize the image.

Run ./runge/scripts/build-macos-dmg.sh --help for options, or see the installer guide for custom paths, deployment targets, and direct CMake packaging commands.

Run the tests

Build the solver tests without the desktop application:

cmake -S runge -B build-tests \
  -DCMAKE_BUILD_TYPE=Release \
  -DCVM_ROOT=/path/to/cvm \
  -DRUNGE_BUILD_GUI=OFF \
  -DRUNGE_BUILD_TESTS=ON \
  -DBUILD_TESTING=ON
cmake --build build-tests --config Release --parallel
ctest --test-dir build-tests -C Release --output-on-failure

Add -DRUNGE_BUILD_CVM=ON to build CVM from source. Qt-dependent tests are added when the corresponding Qt components are available; supply CMAKE_PREFIX_PATH to select a Qt installation. Enable RUNGE_BUILD_GUI to include the main-window and viewer regression test, which uses Qt Test and the offscreen platform plugin.

Configuration options

CMake option	Default	Purpose
RUNGE_BUILD_GUI	ON	Build the Qt desktop application.
RUNGE_BUILD_SOLVER	ON	Build the C++ solver library; required by the GUI and tests.
RUNGE_BUILD_TESTS	ON	Build regression test executables.
BUILD_TESTING	ON	Register tests with CTest.
RUNGE_BUILD_CVM	OFF	Build CVM from CVM_ROOT using Runge's toolchain.
RUNGE_USE_MKL	OFF (ON in the Linux installer script)	Use shared sequential MKL for source-built CVM and the Fortran solvers.
RUNGE_DEB_BUNDLE_QT	ON	Include Qt libraries and application plugins in the Debian package.
RUNGE_DEB_BUNDLE_MKL	ON	Include linked MKL libraries and dynamically loaded CPU backends in the Debian package.
RUNGE_CVM_ILP64	ON	Use 64-bit integers in CVM and the Fortran solvers.
RUNGE_CVM_EM64T	ON on 64-bit targets	Enable CVM's 64-bit definition and library-name search.
RUNGE_DEPLOY_WINDOWS_RUNTIME	ON	Deploy Windows runtime DLLs and Qt plugins.

On macOS, an unspecified CMAKE_OSX_DEPLOYMENT_TARGET defaults to the selected SDK version for both C++ and Fortran. Set an explicit version to target an older macOS release supported by all dependencies.

Repository layout

Directory	Contents
runge/	CMake project, C++ solver core, and application sources.
runge/Runge/	Qt interface, graphics, resources, and user manual.
runge/test/	Solver, configuration, help, and GUI regression tests.
runge/cmake/	CVM integration and platform runtime packaging.
runge/scripts/	macOS and Debian/Ubuntu installer scripts and instructions.
des/	England, Lawson, and Rosenbrock Fortran solvers.
mex/	MATLAB MEX gateways and supporting sources.
makes/	Shared configuration for the legacy make-based builds.

License

Runge is distributed under the Boost Software License 1.0.