This page describes how to compile GeoDms from source on Windows 11 and up. The process is bound to change through an ongoing effort to make the source code more accessible to the open-source community. This document is written as a chronological guide. Are you stuck or encounter incomplete information? Feel free to open an issue!

Our recommended compilation platform is Microsoft Visual Studio 2026 Community edition, which can be downloaded here. Make sure the "Desktop development with C++" workload is installed:

Note: the exact layout of the Visual Studio Installer may differ from the screenshot above depending on your version.

Clone GeoDMS from the GitHub repository using:

git clone https://github.com/ObjectVision/GeoDMS.git

Then check out the main branch:

git checkout main

All C++ dependencies (Boost, CGAL, GDAL, GEOS, PROJ, fftw3, OpenSSL, pybind11, and others) are declared in vcpkg.json at the root of the repository and are downloaded and built automatically when you first compile — no manual package installation is required.

vcpkg is bundled with Visual Studio 2026 at C:\Program Files\Microsoft Visual Studio\2026\Community\VC\vcpkg. Run the following once to make it available system-wide:

"C:\Program Files\Microsoft Visual Studio\2026\Community\VC\vcpkg\vcpkg.exe" integrate install

After that, opening the solution or running a CMake configure will trigger vcpkg to install all missing dependencies automatically.

Note: if your Windows username contains spaces, vcpkg may fail to build the Python bindings. See this guide for how to change it.

• Make sure you have created a Qt account here, as this is required during the installation process.
• Download and install the latest stable release of Qt using the Qt installer. You can deselect all components except MSVC 2022 64-bit in the Qt/Qt x.x.x folder. No additional Build Tools under the Build Tools tab are required.

• In Visual Studio, install the Qt Visual Studio Tools extension via Extensions > Manage Extensions and search for Qt Visual Studio Tools. Click Install and close Visual Studio to start the extension installation.

• Restart Visual Studio. Then add the installed Qt version via Tools > Options > Qt > Qt Versions. Click Add and navigate to qmake.exe, e.g. C:\Qt\6.x.x\msvc2022_64\bin\qmake.exe:

• Open the GeoDMS solution file all22.sln in Visual Studio.
• In the Solution Explorer, right-click GeoDmsGuiQt > Properties > Qt Project Settings, and set the Qt Installation field to the Qt version added in the previous step.

• Open the solution file all22.sln in Visual Studio. The Solution Explorer shows the various projects that make up GeoDMS, from which .dll files will be created.
• We recommend using Release mode and x64 for an initial build, which can be configured in the toolbar below the Build / Debug / Test menu:

• Right-click GeoDmsRun in the Solution Explorer and click "Set as Startup Project". To build GeoDmsRun, go to Build > Build Solution or use the hotkey Ctrl+Shift+B.

• Alternatively, you can build each component individually by right-clicking it in the Solution Explorer and selecting Build, in the following order:

1. Rtc (Runtime Core Library)
2. Sym (configuration syntax parser and producer of an internal representation of a model and its calculation rules)
3. Tic (Tree Item Classes, Data Items, Units and related services)
4. Stx (configuration syntax parser and producer of an internal representation of a model and its calculation rules)
5. Stg (Storage Managers, providing a generic interface to GDAL, Proj, and native Storage Implementations, including .shp and .dbf, the TIFF lib, and ODBC connections)
6. Clc (implementation of common operators)
7. Geo (implementation of geometric and network operators, such as Dijkstra functions, raster convolution, polygon and arc operations)
8. Shv (Viewer Components including TableViewer, MapViewer, and related Carets and Graphic Components)
9. GeoDmsRun.exe and GeoDmsGuiQt.exe

Depending on the chosen build configuration, all build products will be placed in the bin folder, for instance geodms/bin/Release/x64.

When first compiling, you'll probably get an error about version numbers. If so:

In Visual Studio, go to View > Terminal and type:

.\BuildSignAndCreateSetup.bat

Here you'll be prompted with a question to "write the latest version number and date to the header". Pres Y

Then break the process by pressing Ctrl-C, and confirming by entering Y with an enter. Then the error should be fixed when restarting the build process.

As an alternative to the solution file, GeoDMS can be built with CMake using the presets defined in CMakePresets.json. This produces the same binaries and is required for the Linux build.

Prerequisites (in addition to Visual Studio and Qt described above):

• CMake 3.25 or later — use the one bundled with Visual Studio 2026 at C:\Program Files\Microsoft Visual Studio\2026\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe, or add it to your PATH

Configure and build:

set VCPKG_ROOT=C:\Program Files\Microsoft Visual Studio\2026\Community\VC\vcpkg
cmake --preset windows-x64-release ^
      -DCMAKE_PREFIX_PATH="C:/Qt/6.9.0/msvc2022_64"
cmake --build --preset windows-x64-release --parallel 4

Output is placed in build\windows-x64-release\bin\. The Python binding geodms.pyd, Qt plugins, and all vcpkg DLLs are deployed there automatically.

For a debug build replace windows-x64-release with windows-x64-debug in both commands.

Creating the Windows installer after a successful release build:

set GeoDmsVersion=19.5.0
"C:\Program Files (x86)\NSIS\makensis.exe" nsi\DmsSetupScriptX64-cmake.nsi

The unsigned installer is written to distr\GeoDms<ver>-Setup-x64-cmake.exe. Sign it with signtool.exe as described in BuildSignAndCreateSetup.bat.

GeoDMS can be compiled natively on Linux (tested on Ubuntu 24.04) or inside WSL2 on Windows. The CMake build is the only supported method on Linux.

sudo apt update
sudo apt install -y \
    build-essential ninja-build cmake git curl zip unzip tar pkg-config \
    libgl1-mesa-dev libglu1-mesa-dev \
    qt6-base-dev qt6-tools-dev libqt6svg6-dev \
    libxcb-xinerama0-dev libxcb-icccm4-dev libxcb-image0-dev \
    libxcb-keysyms1-dev libxcb-randr0-dev libxcb-render-util0-dev \
    libxcb-xkb-dev libxkbcommon-x11-dev

vcpkg is used to build the remaining C++ dependencies (Boost, GDAL, GEOS, PROJ, etc.):

git clone https://github.com/microsoft/vcpkg.git ~/vcpkg
~/vcpkg/bootstrap-vcpkg.sh -disableMetrics
export VCPKG_ROOT=~/vcpkg          # add to ~/.bashrc to make permanent

Note: build DmClc sequentially or with limited parallelism — it is memory-intensive and parallel builds may be killed by the OOM killer.

# Release build
cmake --preset linux-x64-release
cmake --build --preset linux-x64-release -j4

# Debug build (optional, run after release — not in parallel)
cmake --build --preset linux-x64-debug -j4

Both commands need to be run from the repository root. The first cmake invocation also downloads and builds all vcpkg dependencies, which takes some time on first run.

Output is placed in build/linux-x64-release/bin/ (or linux-x64-debug).

Once the release build is complete, use the packaging script to produce a tarball, SHA-256 checksum, CMS signature, and optional .deb:

export GeoDmsVersion=19.5.0
bash nsi/CreateLinuxSetup.sh

Output goes to distr/. Signing requires a hardware token to be present on the build machine (the script prompts for the token PIN via a Windows dialog when run from WSL2; signing is skipped gracefully when the token is unavailable).

The Python binding (geodms.pyd) allows GeoDMS to be used as a Python module. It is built automatically as part of the CMake build or the Visual Studio solution — no separate configuration is required as long as Python 3.10 or later is installed and python.exe is on your PATH.

When using the Visual Studio solution (all22.sln), ensure pybind11 is available via vcpkg:

vcpkg install pybind11 --triplet x64-windows

Open a terminal in the build folder where geodms.pyd is located and start Python in command-line mode by typing python. To test the geodms module, import and evaluate the version function:

python
from geodms import version
version()

This should return a version string depending on the build time and type:

Additionally, you can run LoadConfigFromPython.py, located in the LoadConfigFromPython project folder.

The folder structure should look as follows:

├── geodms/
│   ├── gdaldata
│   ├── proj4data
│   ├── geodms.pyd
│   ├── geos.dll
│   ├── ...
│   ├── zstd.dll
├── MANIFEST.in
├── setup.py

With MANIFEST.in containing:

recursive-include . *

And setup.py containing:

from setuptools import setup, Extension
import os
from setuptools.command.install import install

class CustomInstall(install):
    def run(self):
        install.run(self)

setup(
    name="geodms",
    version="x.x.x",
    packages=["geodms"],
    include_package_data=True,
    install_requires=[],
    cmdclass={'install': CustomInstall},
)

Make sure the setuptools and wheel modules are installed:

pip install wheel
pip install setuptools

Build the wheel:

python setup.py bdist_wheel

Test wheel installation:

pip install ./dist/geodms-x.x.x-py3-none-any.whl

Test code:

from geodms import geodms
print(geodms.version())