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!

Last updated: 2026-07-10 — describes the build settings as they are for GeoDMS 20.7.0. The pinned compiler toolset, vcpkg baseline and Qt version below are specific to this release; earlier or later versions may differ.

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.

GeoDMS pins the C++ toolset in Directory.Build.props (and in the CMake presets) so that every developer and CI machine builds with an identical compiler:

The pin to 14.50 is deliberate: MSVC 14.51.x miscompiles GEOS (it elides a null-check in KdTree::queryNodePoint, causing access violations and silently wrong results in polygon buffer / snap-rounding). Until Microsoft fixes this, the build must not pick up 14.51.

Because the version is pinned, you must have the matching MSVC v145 (14.50.35717) toolset installed. In the Visual Studio Installer, under Individual components, make sure the MSVC v145 - VS 2026 C++ x64/x86 build tools (14.50) component is selected (alongside whatever latest version VS installs by default). Both the VS solution and the CMake presets request this exact version automatically, so there are no per-machine project changes to make — but the toolset has to be present.

Clone GeoDMS from the GitHub repository using:

git clone --recurse-submodules https://github.com/ObjectVision/GeoDMS.git

GeoDMS includes vcpkg as a git submodule (see below); --recurse-submodules fetches it during the clone. If you already cloned without it, the build scripts will initialise the submodule for you on first build, or you can run git submodule update --init vcpkg yourself.

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 built automatically the first time you compile — no manual package installation is required.

GeoDMS uses its own in-repo copy of vcpkg, included as a git submodule at ./vcpkg and pinned to the exact baseline commit the ports were tested against (see vcpkg-configuration.json). This is intentional: the vcpkg bundled with Visual Studio is read-only and lags the baseline, which breaks some ports (e.g. libffi/mpfr autotools builds). The in-repo vcpkg is provisioned for you automatically — there is nothing to install or integrate by hand:

• For MSBuild / the Visual Studio solution, tools/ensure-vcpkg.ps1 (run from the build) checks out and bootstraps the submodule, and Directory.Build.props / Directory.Build.targets import vcpkg's MSBuild integration directly from ./vcpkg (via $(VcpkgRoot)).
• For CMake, tools/vcpkg-toolchain.cmake (referenced by every preset in CMakePresets.json) performs the same checkout/bootstrap before chaining to vcpkg's real toolchain.

So the only thing a developer needs to do is open all22.sln or run a CMake configure — vcpkg then builds all dependencies into the shared vcpkg_installed/ folder at the repo root on first run (this takes a while the first time).

Do NOT:

• run vcpkg integrate install. The integration is project-local on purpose. A machine-wide integration records one absolute vcpkg path in %LOCALAPPDATA%\vcpkg\vcpkg.path.txt, and uninstalling the Visual Studio it pointed at silently breaks every build (Cannot open boost/format.hpp, unresolved boost_locale, …). If you hit such errors, check the two imports in Directory.Build.props/.targets and that ./vcpkg/vcpkg.exe is bootstrapped — do not "fix" it with integrate install.
• clone or bootstrap a separate vcpkg, or point VCPKG_ROOT at one. That bypasses the pinned submodule and its baseline. The in-repo ./vcpkg is the only supported copy.
• run vcpkg install <pkg> by hand. Every package is declared in vcpkg.json and resolved from there.

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 Qt 6.11.1 (the version the GeoDMS solution is currently pinned to) using the Qt installer. You can deselect all components except MSVC 2022 64-bit in the Qt/Qt 6.11.1 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.11.1\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 GeoDmsGuiQt in the Solution Explorer and click "Set as Startup Project". To build GeoDmsGuiQt, 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 order below (each layer builds only on the layers above it):

Reduced in 20.7.0: the former Sym (Symbolic) and Tic (Tree Item Classes) DLLs were merged into Rtc, cutting the DLL count from 8 to 6. Their sources now live under rtc\dll\src\sym and rtc\dll\src\tic, and the separate DmSym / DmTic projects are gone — documentation or scripts that still reference them are out of date.

Finally, build the executables: GeoDmsRun.exe (command line) and GeoDmsGuiQt.exe (Qt GUI).

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:

.\GeoDmsVersion.cmd

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:

cmake --preset windows-x64-release ^
      -DCMAKE_PREFIX_PATH="C:/Qt/6.11.1/msvc2022_64"
cmake --build --preset windows-x64-release --parallel 4

You do not need to set VCPKG_ROOT: the preset's toolchain file (tools/vcpkg-toolchain.cmake) provisions and points at the in-repo ./vcpkg submodule automatically. The preset also pins the generator (Visual Studio 18 2026), the toolset (version=14.50.35717,host=x64) and the triplet (x64-windows-v145).

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=20.6.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=20.6.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.

pybind11 is declared in vcpkg.json and built automatically with the other dependencies — do not vcpkg install it by hand (see the vcpkg section above).

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())