RustGIS vs QGIS: We Tested Start-Up Speed, Buffers, and Raster Performance
#GeoDev #News

RustGIS vs QGIS: We Tested Start-Up Speed, Buffers, and Raster Performance

Open-source GIS · October 2026

A new open-source GIS written in Rust runs natively and in the browser, starts in a fraction of a second, and treats every button as a scriptable command. Four releases appeared in thirteen days. We read the code, tested RustGIS 0.4 against QGIS and plain Python, and found a young tool with an unusually solid core and some clear rough edges.

0.15 s
Cold start
RustGIS, against 3.16 s for PyQGIS
16 MB
Start-up memory
PyQGIS needs 169 MB
×26
Buffer slowdown
RustGIS time for 10× more points (10k → 100k)

Most open-source desktop GIS share the same foundations: GDAL for reading data, PROJ for coordinates, Qt or a web view for the interface. RustGIS replaces almost all of that with code written in Rust. It reads GeoPackage, GeoParquet, FlatGeobuf, Shapefile, GeoTIFF and COG with its own readers, draws maps on the GPU through wgpu, and compiles the whole application to WebAssembly, so the same program runs at web.rustgis.app with nothing to install. GDAL and DuckDB become optional extras on the desktop rather than requirements.

The project comes from opengeos, the organisation of Qiusheng Wu, best known for the Python packages geemap and leafmap. Version 0.1.0 appeared on 12 October 2026, three more releases followed by 25 October, and the repository passed roughly 2,000 stars and 280 forks within its first two weeks.

How it is built. The project README states that RustGIS is “primarily built with Claude Opus 5.5, an AI model by Anthropic, working under human direction and review”, and asks users to check results for their own use. That explains part of the release pace, and it is one more reason to test outputs rather than take them on trust, which is what the benchmark below does.

Four releases in thirteen days

v0.1.0 12 Oct 2026
First release: desktop GIS for Windows, macOS and Linux plus a WebAssembly build; vector, raster and tile data; layouts and PDF export; 1,000+ GeoLibre and Whitebox tools; AI Assistant; sandboxed plugins; rustgis-cli.
v0.2.0 13 Oct 2026
GeoPackage, GeoParquet and FlatGeobuf read in place; export to GeoPackage, GeoParquet, Shapefile and KMZ; SQL through DuckDB Spatial; an MCP server for AI agents; installs through winget, Homebrew, the AUR and Fedora COPR.
v0.3.0 16 Oct 2026
STAC, Overture Maps and OpenStreetMap built in; cloud-native files read over HTTP range requests; live PostGIS; GPU rendering (beta); the rustgis Python package on PyPI.
v0.4.0 25 Oct 2026
3D view with terrain; File Geodatabases without GDAL; live MySQL, MariaDB and SQL Server; time slider; vertex editing, spatial join and kriging; SQL label classes; publication sheets in one command.

Everything is a command

The design decision that matters most for professional users is not the language. Every action in RustGIS, every ribbon button and menu item, is an engine command with an id and JSON parameters. Version 0.4.0 exposes 497 of them. The ribbon, the command line, the Python package, the AI assistant and external AI agents all call the same commands, so a workflow clicked together in the desktop app can be repeated from a script without translation.

The code is split into layered crates, each depending only on the layers below it. That is what lets the same engine run headless on a server, inside a Jupyter kernel, as a desktop app and in a browser tab.

Inside RustGIS: the crate stack

Highlighted: the engine layer that the command line and Python package expose.

apps
rustgis · rustgis-cli · rustgis-web · rustgis-python desktop app, command line, browser build and Python package
L6
rustgis-ui-egui the ribbon interface (swappable)
L5
rustgis-assistant the AI Assistant, acting only through engine commands
L4
rustgis-engine session, undo history and the command registry
L3
rustgis-render · plugins · geolibre rendering, sandboxed WebAssembly plugins, the GeoLibre tool suite
L2
rustgis-map · analysis · tiles layers and symbology, geoprocessing, web tiles and PMTiles
L1
rustgis-data readers and writers for vector and raster formats, databases
L0
rustgis-geom coordinates, extents, geodesic distance and area

From the architecture table in the RustGIS README (v0.4.0).

Same terrain, two interfaces

RustGIS borrows its layout from ArcGIS Pro rather than QGIS: a ribbon with tabs ordered by workflow (Home, Data, Style, Edit, Analyze, View, Publish), a Layers pane on the left and context panes on the right. Here is the same Copernicus GLO-30 elevation tile over the Karkonosze mountains (Poland, Czech Republic) in both programs.

RustGIS showing the Karkonosze DEM with a tinted shaded-relief style
RustGIS 0.4: tinted shaded relief and the Symbology pane
QGIS showing the same DEM with a single-band pseudocolour style
QGIS 3.34: single-band pseudocolour and the layer properties dialog

Copernicus DEM GLO-30, tile N50 E015 (© DLR e.V. 2010–2014 and © Airbus Defence and Space GmbH 2014–2018, provided under COPERNICUS by the European Union and ESA).

How it compares on paper

The RustGIS documentation includes its own comparison with QGIS and ArcGIS Pro. It is the developer’s description of their software, so read the RustGIS column as a claim.

  RustGIS 0.4 QGIS ArcGIS Pro
Platform
Licence Apache-2.0, free GPL-2.0+, free Proprietary
Runs on Windows, macOS, Linux, browser Windows, macOS, Linux Windows only
Interface Ribbon, tabs by workflow Toolbars and panels Ribbon
Data
Formats Broad, own readers; GDAL optional Widest (GDAL/OGR) Very wide, Esri formats
Cloud-native GeoParquet, FlatGeobuf, PMTiles, COG over HTTP; Zarr GeoParquet, FlatGeobuf, PMTiles, COG, Zarr GeoParquet, COG, Zarr
Projections Rasters in any EPSG; vectors in lon/lat, no full PROJ Full PROJ Full support
Databases PostGIS, MySQL, SQL Server read-only (desktop) PostGIS, SpatiaLite, Oracle, SQL Server Enterprise geodatabases
Analysis and maps
Tools Built-in plus 1,000+ GeoLibre/Whitebox 1,000+ (GDAL, GRASS, SAGA) Most complete, paid extensions
Print layout Presets, legends, map series; PDF, PNG, SVG Full composer with atlas Full layout view
Web export Single-file HTML web map, OGC API Features Via qgis2web None
Automation
Scripting Every action is a command: CLI and Python package PyQGIS, qgis_process arcpy
Plugins Sandboxed WebAssembly plugins, new registry Thousands of Python plugins .NET add-ins, Python toolboxes
AI Assistant with undo; MCP server for agents Via plugins Copilot features

The same page is unusually candid about where RustGIS falls short:

  • Vector data is held in longitude/latitude; there is no full PROJ.
  • PostGIS, MySQL and SQL Server are read-only and desktop-only.
  • No versioned or multi-user editing; edits are not written back to databases.
  • DWG, JPEG 2000, NetCDF and HDF need GDAL; the web app cannot write GeoPackages.
  • Network datasets and advanced spatial statistics need the external tool suite or another GIS.
  • Many features are first versions; there is no Python console inside the app.

What we measured

Claims of speed are easy to make, so we wrote a benchmark notebook that runs the same jobs on three engines: RustGIS 0.4.0 through its Python package, QGIS 3.34.11-Prizren through a persistent PyQGIS process (so QGIS starts once, as it does in the desktop app), and plain Python with GeoPandas, Shapely, NumPy and rasterio. Every engine reads the same files and writes the same outputs. Each case runs at least three times and we report the median. Shorter bars are faster; a tick marks the fastest engine.

Cold start: time to a ready engine

A fresh process starts and loads its GIS engine; median of five starts.

Python alone
 
0.15 s
RustGIS
 
0.15 s
qgis_process, no Python
 
1.20 s
GeoPandas + rasterio
 
1.88 s
PyQGIS
 
3.16 s
qgis_process
 
11.2 s

Memory at start-up

Peak resident memory while starting.

Python alone
 
13 MB
RustGIS
 
16 MB
qgis_process, no Python
 
120 MB
GeoPandas + rasterio
 
122 MB
PyQGIS
 
169 MB
qgis_process
 
315 MB
RustGIS
QGIS
Python

Buffer 100,000 points by 5 km

Read a GeoPackage, buffer every point, write a GeoPackage.

RustGIS
 
11.9 s
QGIS
 
6.98 s
Python
 
3.92 s ✓

Slope of a 30 m DEM (8.9 million cells)

Same DEM and Horn method in every engine. GeoLibre is the tool suite RustGIS ships.

RustGIS built-in
 
4.03 s
QGIS
 
0.82 s ✓
Python
 
1.41 s

IDW, 100,000 points

On a 0.01° grid RustGIS refuses this job as “too much work”; on 0.02° it finishes. Python reproduces each engine’s distance method.

RustGIS
 
7.08 s ✓
QGIS
 
9.30 s
Python, geodesic
 
20.7 s
Python, planar
 
10.2 s

Draw 100,000 buildings, zoomed to 4 × 3 km

Almost every footprint is off-screen. QGIS and Python only read what is visible.

RustGIS
 
0.89 s
QGIS
 
0.26 s ✓
Python
 
0.47 s

Export an A4 map at 300 dpi

Hillshade, AOI, title, legend, scale bar and north arrow.

RustGIS
 
0.84 s ✓
QGIS
 
1.96 s
Python
 
2.72 s

Read and write 100,000 polygons as GeoParquet

This QGIS build had no Parquet driver, so QGIS is missing here.

RustGIS
 
0.32 s ✓
QGIS
 
1.54 s
Python
 
0.52 s

Run the same small job 100 times from a script

A loop over QGIS’s command-line tool pays QGIS start-up on every call.

RustGIS
 
5.77 s ✓
QGIS, one script
 
17.9 s
QGIS, CLI loop
 
124.1 s
Python
 
10.2 s

Reference run on Windows, 16 logical cores, 33.6 GB RAM, RustGIS 0.4.0, QGIS 3.34.11-Prizren. DEM: Copernicus DEM GLO-30, tile N50 E015 (Karkonosze), 2,389 x 3,722 cells in UTM 33N. Absolute times depend on hardware; the ratios between engines carry over better.

What the numbers say

Starting RustGIS costs almost nothing. Loading the engine and creating an empty project took 0.15 s and 16 MB of memory, against 3.16 s and 169 MB for PyQGIS and 1.88 s and 122 MB just to import the Python GIS stack. It is the clearest confirmation of the project’s “fast and small” pitch, and it matters for scripts, notebooks and servers that start many short jobs.

Buffering slows down sharply at scale. Up to 10,000 features RustGIS keeps pace with QGIS and GeoPandas. From 10,000 to 100,000 its buffer time grows about 26 times (an exponent of 1.42, where 1 means proportional), against roughly ten times for the other two. The cause sits in the buffer step itself, not in reading or writing files, which suggests an algorithmic issue the developers can fix.

RustGIS chooses geodesic methods, and they are measurably different. Its buffers are built on the ellipsoid and its IDW uses great-circle distance, where QGIS works in map units. Interpolating 100,000 DEM-sampled points, the geodesic IDW was closer to the real terrain (RMSE 51.6 m against 55.0 m for QGIS, a gain of 6.1 %; small, but consistent). Measured against a true 5 km circle, its buffers are 0.29 % too small, against 0.57 % for QGIS’s planar buffers in UTM.

QGIS is hard to beat on raster work. With QGIS already running, its GDAL-based slope, hillshade and GRASS flow accumulation were the fastest in our tests. RustGIS’s slope time grows in step with raster size, so its raster engine has no scaling problem, but it ran five to seven times slower than GDAL at every size we tried. Its built-in slope matches QGIS on 99.9 % of cells; the differences sit only on the first cell next to nodata.

Drawing is fast, but RustGIS draws what you cannot see. RustGIS rendered 1,000 and 10,000 building footprints faster than QGIS. Zoomed into a 4 × 3 km window of 100,000 buildings, though, it took as long as for the whole area, while QGIS and Python only read the footprints in view. Rendering the DEM from a cloud-optimised GeoTIFF instead of a plain one made QGIS about 1.6 times faster and RustGIS only about 1.1 times, which suggests RustGIS is not yet taking full advantage of COG overviews.

Input, output and scripting are where it shines. RustGIS was the fastest of the three at writing an A4 map at 300 dpi, at reading and writing 100,000 polygons as GeoJSON and as GeoParquet, and at running the same small job 100 times from a script. A loop over QGIS’s command-line tool pays QGIS start-up on every call and took more than fifteen times as long.

The core is fast where Rust is expected to be fast: start-up, file input and output, scripting. The algorithms behind buffering, raster processing and rendering are still catching up.

Our reading of the benchmark

Try it in a minute

The quickest route needs no install at all: the web app at web.rustgis.app is the full program compiled to WebAssembly. On the desktop, winget install OpenGeos.RustGIS (Windows) or brew install --cask opengeos/rustgis/rustgis (macOS) installs the app and its command line. In Python 3.12 or later:

pip install rustgis
import rustgis
s = rustgis.Session(sample=True)
s.run("gp.run", tool="buffer", params={"input": "Cities", "distance": 100})
s.to_png("map.png")

The command line renders maps headless, and registers RustGIS as an MCP server so agents such as Claude Code, Cursor and VS Code can run GIS commands:

rustgis-cli render dem.tif dem.png
claude mcp add rustgis -- rustgis-cli mcp --sample

Where RustGIS stands

Three weeks after its first release, RustGIS is not a QGIS replacement and does not claim to be. It is a credible second architecture for open-source GIS, with a different set of trade-offs.

Already useful for

  • Quick looks at data. Opens GeoParquet, COG and GeoPackage in place, in the browser if needed.
  • Teaching and workshops. The web app runs on any laptop with no install and no admin rights.
  • Scripted maps. One command builds a layout with legend, scale bar and locator; the CLI renders maps headless.
  • Agent workflows. An MCP server lets AI agents run GIS commands with undo.

Not ready for

  • Projection-heavy work. Vector data is held in lon/lat without full PROJ.
  • Large vector processing. Buffering 100,000 features took 1.7 times as long as QGIS in our tests.
  • Shared editing. No multi-user or versioned database editing.
  • Plugin-dependent workflows. QGIS has thousands of plugins; RustGIS has a new registry.

Worth watching

  • Release pace. Four feature releases in thirteen days; we will track whether that holds and whether quality keeps up.
  • The renderer. The GPU backend was still marked beta in v0.3.0, and it does not yet skip off-screen features or lean on COG overviews.
  • Sandboxed plugins. WebAssembly plugins run with explicit permissions on the desktop, the CLI and the web.
  • Contributors. The citation lists five authors; a wider maintainer base would reduce the bus factor.

For the geospatial community, the more interesting question may not be whether RustGIS overtakes QGIS, but what it shows is now possible: a full desktop GIS, with layouts, 3D, cloud-native data and a scripting interface, built in weeks on a modern stack that runs equally on a laptop and in a browser tab. If its algorithms catch up with its architecture, RustGIS will be a serious option for lightweight and web-first GIS work.

Sources

  1. RustGIS repository and README
  2. RustGIS releases
  3. rustgis on PyPI (release dates)
  4. RustGIS comparison with GeoLibre, QGIS and ArcGIS
  5. RustGIS Python documentation
  6. It’s FOSS: RustGIS is a desktop GIS tool that also runs in a browser
  7. Copernicus DEM GLO-30

Benchmark: eleven tests on identical, seeded inputs (buffering, IDW, slope, hillshade, flow accumulation, raster clipping, rendering, map export, batch scripting, file formats).


Did you like this post? Read more and subscribe to our monthly newsletter!

Say thanks for this article (0)
Our community is supported by:
Become a sponsor
#GeoDev
#Fun #GeoDev #Ideas #Insights
What Facebook Friendships Reveal About Europe’s Hidden Borders
Sebastian Walczak 07.5.2026
AWESOME 2
#GeoAI #GeoDev #Ideas
Field-Ready GeoAI: How Compressed Models are Enabling On-Device Intelligence
Aravindh Subramanian 05.13.2026
AWESOME 0
#GeoAI #GeoDev #Ideas #Science
Geospatial Reasoning: Why Learning Alone Is Not Enough
Aravindh Subramanian 02.9.2026
AWESOME 1
Next article
Digitising Historical Maps: Testing AI-Assisted Contour Tracing in QGIS
#Fun #GeoAI #GeoDev #Ideas #Insights

Digitising Historical Maps: Testing AI-Assisted Contour Tracing in QGIS

Case Study | AI-Assisted Tools | QGIS | ArchaeoTrace | Plugin

Can an AI-assisted QGIS plugin actually speed up contour digitising, or does it just move the work around? We tested it on a small sand mine in Poland, comparing the present-day land surface with a survey from the first half of the 20th century of the same ground.

Digitising historical topographic maps is a familiar task for many GIS analysts. Tracing contour lines by hand from a scanned map can be slow, repetitive, and easy to get subtly wrong. A QGIS plugin promises to automate the tracing step using computer vision and, increasingly, AI assistance. ArchaeoTrace is one of them, and we used it to rebuild the terrain history of a small sand-mining site in Poland across roughly a century.

Scanned maps were used to describe the land surface
Oldest source: WIG 1:25 000 survey sheet
Three stages of sand extraction
Pre-mining, mid-century, and present day
Manual review
Manual review remains essential

What ArchaeoTrace actually does

ArchaeoTrace is a QGIS plugin built for pulling vector lines out of scanned topographic maps, designed primarily for archaeological and historical cartography. It bundles several tracing methods rather than a single algorithm. Having several tracing methods matters because different scans respond better to different approaches.

  • Ink Centerline, run at three scales (9, 15 and 31 pixels), follows a drawn line and stays on its centre.
  • Live-Wire, a bounded, direction-aware path tool (320px reach) that snaps to the strongest nearby edge as you sketch.
  • A cursor-to-path blend slider (0-100%) lets the operator decide how much to trust the automated trace versus their own hand movement, rather than accepting an all-or-nothing result.
  • An optional Smart Recovery mode calls a lightweight segmentation model (EfficientSAM-Ti) to help bridge gaps where a contour line is faint or interrupted on the scan.
  • Freehand drawing and a set of legacy and advanced methods (LSD, HED, MobileSAM, SAM ViT-B, Canny) are available for maps where none of the above behave well.
  • Traced lines can carry elevation attributes and spot heights, and the plugin can generate an experimental linear-TIN DEM plus hillshade directly from the digitised contours.

ArchaeoTrace window

All of this runs locally, with no data sent to a remote server for inference. The plugin’s baseline install targets QGIS 3.22 and Python 3.8 with no additional pip packages; the optional AI-assisted methods need a Python 3.10+ environment with extra dependencies installed, which is worth checking.


The case study: a sand mine in Poland, three time periods

To see what the plugin is actually good for, we picked a small sand-mining site. We reconstructed its surface at three stages – before mining, during extraction, and today – across roughly a century.

Before mining: the 1929-39 baseline. The earliest source is sheet P42 S32 H (also catalogued as 4232 H), part of the WIG (Wojskowy Instytut Geograficzny) 1:25 000 series, Mapa Szczegółowa Polski, surveyed in the interwar period. Sheets in this series were compiled from a mix of fresh Polish fieldwork and older base survey data in less-mapped areas, which is why some of the underlying linework on this sheet still carries Cyrillic place names from an earlier Imperial Russian survey.

Running ArchaeoTrace over this scan produced a set of digitised contours, which we then used to build a linear-TIN DEM of the ground before mining began.

Before mining: the 1929-39 baseline. Digitising Historical Maps: Testing AI-Assisted Contour Tracing in QGIS

Mid-century: when mining began. A Polish Geoportal topographic map from the 1960s-80s shows the same area once sand extraction was underway. Digitising this sheet and rebuilding a DEM from it gives a second surface, roughly midway through the site’s working life.

Today: satellite imagery and a modern LiDAR DEM. For the present-day surface, we didn’t need to digitise anything by hand. A Google satellite orthophoto shows the pit and surrounding land directly, while a 1-metre LiDAR-derived DEM provides an independent elevation model for checking the historical reconstructions.

Drag the slider: pick any two time slices

The interactive tool below holds all three DEMs on the same colour ramp: pre-mining (1929-39), mid-century (1960s-80s, once extraction was under way), and today. Use the dropdowns to choose which two to compare, then drag the divider. The depression left by extraction is unmistakable once any two surfaces sit side by side.

Period Source Elevation model
1929-39 WIG 1:25 000 sheet P42 S32 H (4232 H) Linear-TIN DEM from digitised contours
1960s-80s Geoportal topographic map Linear-TIN DEM from digitised contours
Present day Google satellite orthophoto; Geoportal 1 m LiDAR LiDAR-derived DEM

Where it struggles

None of the tracing methods worked equally well on both historical sheets straight out of the box. The oldest scan, with its finer, more irregular hand-drawn contour lines, needed a different combination of scale and blend settings than the cleaner, more mechanically-drawn mid-century Geoportal sheet. There is no single setting that suits every map, and the plugin does not pretend otherwise.

  • New users have to experiment across the available algorithms (and the multi-scale settings within Ink Centerline) to find what works for their specific map; there is no shortcut to that trial-and-error step.
  • The optional AI-assisted methods bring real dependency weight: a Python 3.10+ environment and extra packages beyond QGIS’s own baseline, which is friction for anyone trying to reproduce results on a locked-down institutional machine.
  • The plugin’s own documentation is candid about this: as it puts it, “terrain outputs are reviewable hypotheses rather than archaeological ground truth.” That line is worth taking at face value rather than as boilerplate caution.

The automated traces we reviewed still required correction, whether that meant nudging a vertex back onto a contour it had slid off, or closing a gap the software had left where the historical ink had faded.


The verdict

ArchaeoTrace is a useful tool for speeding up the slow part of digitising old maps. It reduced the time needed to produce a first-pass set of contour vectors. For anyone rebuilding terrain history from archival maps as a recurring task rather than a one-off, that time saving adds up fast.

Manual review and correction are essential before relying on the resulting DEM for anything consequential. Automated tracing shaves hours off the first draft. It does not replace the second pair of eyes.


Sources


Did you like this post? Read more and subscribe to our monthly newsletter!

Read on
Search