docs(comparison): present RustGIS and GeoLibre as complements (#951)

GEOLIBRE_PARITY.md

@@ -14,6 +14,12 @@ section; RustGIS [ROADMAP.md](ROADMAP.md), [docs/](docs/) and the command regist
 (`crates/engine/src/cmd`). Some items may be out of scope for a pure-Rust GIS (noted inline);
 strike those through with a reason rather than leaving them open.
 
+This list is a reference, not a plan: not every GeoLibre feature suits RustGIS. Some are left
+to GeoLibre by decision ([#951](https://github.com/opengeos/RustGIS/discussions/951)): mobile
+apps and field work, real-time collaboration and sharing, and AI segmentation are struck through
+below with their reasons, and the Spatial SQL item notes that an SQL engine in the browser is
+GeoLibre's too.
+
 ## Data formats & sources
 _GeoLibre: docs/data-formats.md, docs/features.md › Adding data, SQL and databases_
 
@@ -59,7 +65,8 @@ _GeoLibre: docs/data-formats.md, docs/features.md › Adding data, SQL and datab
   Iceberg. Partial: PostGIS ([#125](https://github.com/opengeos/RustGIS/issues/125)), MySQL, MariaDB and SQL Server tables read live on the desktop.
   Missing: write-back (_Roadmap: data at the source_) and Iceberg.
 - [x] **Spatial SQL workspace** ([#131](https://github.com/opengeos/RustGIS/issues/131)): an SQL pane over DuckDB Spatial on the desktop. The web app
-  has no in-browser engine yet (_Exploratory_).
+  has no in-browser engine: SQL in the browser is left to GeoLibre, which runs DuckDB, PGlite and
+  Sedona there.
 - [ ] **Private S3 buckets**: partial. `s3://` addresses, SigV4-signed connections, saved
   connections without their secrets and an S3 browser, desktop and web ([#150](https://github.com/opengeos/RustGIS/issues/150)). Missing: SSO, IAM
   roles and secrets kept in the keychain (_Roadmap: solid ground_).
@@ -172,8 +179,9 @@ model-builder.md, segmentation.md, obia.md_
   Partial: Suitability Modeler (_Roadmap: analysis_ for hot spots).
 - [ ] **H3 and DGGS grids**: H3, A5, DGGRID, DGGAL. Partial: A5 grids (_Roadmap: any time_ for
   H3).
-- [ ] **AI segmentation and detection**: SAM/SamGeo, ONNX/YOLO detection, OBIA with eCognition
-  import. Partial: pixel classification (_Exploratory_).
+- [ ] ~~AI segmentation and detection~~ (SAM/SamGeo, ONNX/YOLO detection, OBIA with eCognition
+  import): left to GeoLibre, which has SAM and ONNX models built in and an OBIA workbench with
+  eCognition import. RustGIS has pixel classification.
 - [ ] **Visual Model Builder canvas**: a node graph with validation and export to code. Partial:
   ModelBuilder with a node canvas and models from history.
 - [ ] **Re-run or copy history as code; batch runs over a folder**. Partial: history copied as
@@ -202,18 +210,19 @@ _GeoLibre: docs/features.md › Map tools, printing, and media; docs/user-guide/
 _GeoLibre: docs/collaboration.md, docs/server-api.md, docs/user-guide/embedding.md, projects.md,
 storymaps.md_
 
-- [ ] **Real-time multi-user collaboration**: live sessions, permissions, roster, chat. Missing
-  (_Exploratory_).
-- [ ] **Review comments**: anchored, threaded, resolvable. Missing (_Exploratory_).
-- [ ] **Share links, project gallery, accounts**: roles, expiry, passwords, a server API. Missing;
-  Share As writes static files (_Exploratory_).
+- [ ] ~~Real-time multi-user collaboration~~ (live sessions, permissions, roster, chat):
+  left to GeoLibre, the shared, web-first app.
+- [ ] ~~Review comments~~ (anchored, threaded, resolvable): left to GeoLibre, the shared,
+  web-first app.
+- [ ] ~~Share links, project gallery, accounts~~ (roles, expiry, passwords, a server API):
+  left to GeoLibre, the shared, web-first app. Share As writes static files.
 - [ ] **Story maps**: chapters that fly the live map, a presenter view, HTML export. Partial:
   Presentations.
 - [ ] **Embed API**: a `postMessage` protocol, an npm client, viewer-only and map-only modes, deep
   links. Partial: the web app embeddable with `?embed`, exchanging the project through
   `postMessage` (`apps/rustgis-web/src/embed.rs`); no npm client.
-- [ ] **Import QGIS (`.qgs/.qgz`) and ArcGIS Pro (`.aprx/.mapx`) projects**. Missing
-  (_Exploratory_).
+- [ ] **Import QGIS (`.qgs/.qgz`) and ArcGIS Pro (`.aprx/.mapx`) projects**. Partial: supported
+  QGIS projects open as maps (`project.importQgis`). Missing: ArcGIS Pro (_Exploratory_).
 - [ ] **Autosave, project history, crash recovery, snapshot compare**. Partial: undo, per-layer
   archive restore, and autosave with crash recovery in the desktop app
   ([#873](https://github.com/opengeos/RustGIS/issues/873)); the browser has neither yet.
@@ -247,13 +256,15 @@ docs/agent-skill.md_
 _GeoLibre: docs/android.md, ios.md, mac-app-store.md, downloads.md, self-hosting.md,
 deployment-capabilities.md, ui-profiles.md_
 
-- [ ] **Android app**. Missing (_Exploratory_).
-- [ ] **iOS/iPadOS app**. Missing (_Exploratory_).
-- [ ] **Touch and responsive layout**. Missing (_Exploratory_).
-- [ ] **Field data collection**: forms, photos, GPS or tap placement. Missing (_Exploratory_,
-  [#665](https://github.com/opengeos/RustGIS/issues/665)).
-- [ ] **GPS**: live position, track logs, digitizing from GPS, NMEA receivers. Missing
-  (_Exploratory_).
+- [ ] ~~Android app~~: left to GeoLibre, which has the mobile apps.
+- [ ] ~~iOS/iPadOS app~~: left to GeoLibre, which has the mobile apps.
+- [ ] ~~Touch and responsive layout~~: left to GeoLibre, which has the mobile apps. RustGIS's
+  layout is built for desktop screens, though the web app installs on phones and tablets.
+- [ ] ~~Field data collection~~ (forms, photos, GPS or tap placement): left to GeoLibre, which
+  has the mobile apps. A QFieldCloud connection, requested in
+  [#665](https://github.com/opengeos/RustGIS/issues/665), is not on the roadmap either.
+- [ ] ~~GPS~~ (live position, track logs, digitizing from GPS, NMEA receivers): left to
+  GeoLibre, which covers field work on phones.
 - [ ] **PWA and offline basemap tile pre-caching**. Partial: the web app is installable with
   offline start; offline data areas with sync. Tile pre-caching unverified.
 - [ ] **Docker self-hosting image with runtime config**. Partial: the static web build (_Roadmap:

ROADMAP.md

@@ -4,8 +4,11 @@ _Last reviewed: 2026-10-24 (v0.4.0). Reviewed weekly; if this date is old, trust
 over this page._
 
 This page says where RustGIS is heading and where help is most useful. Details live in the linked
-issues; feature-by-feature comparison with GeoLibre is tracked in
-[GEOLIBRE_PARITY.md](GEOLIBRE_PARITY.md).
+issues. RustGIS and GeoLibre complement each other
+([#951](https://github.com/opengeos/RustGIS/discussions/951)): GeoLibre is web and mobile first,
+RustGIS desktop first and built for automation and AI agents.
+[GEOLIBRE_PARITY.md](GEOLIBRE_PARITY.md) compares the two feature by feature as a reference, not a
+plan: not every GeoLibre feature suits RustGIS.
 
 ## Goals
 - **What exists works.** A feature that crashes, misreads data or is undocumented costs more
@@ -96,6 +99,9 @@ And alongside it:
 ### Data at the source
 - Write edits back to GeoPackage and PostGIS (edits stay in the project today). _Coordinate
   first._
+- Open GeoLibre `.geolibre` projects as maps, the way supported QGIS projects open
+  ([#962](https://github.com/opengeos/RustGIS/issues/962)). GeoLibre opening
+  `.rgis` projects comes later, once RustGIS's project format and supported data types settle.
 - A date and date-time field type, read and written as dates (they are text today)
   ([#853](https://github.com/opengeos/RustGIS/issues/853)). _Coordinate first_ (it changes
   `FieldType`).
@@ -159,16 +165,11 @@ Open questions rather than plans; discuss before building.
   and point cloud I/O library: which of its drivers, coordinate transformations and GDAL-style
   operations could back or replace RustGIS's own readers, or stand in for the GDAL program, and
   which of them build for the web app.
-- Collaboration: shared projects, review comments, accounts and a server.
-- Mobile and field work: touch layout, GPS, data collection, QFieldCloud
-  ([#665](https://github.com/opengeos/RustGIS/issues/665)).
 - Native NetCDF-4/HDF5 without GDAL ([#396](https://github.com/opengeos/RustGIS/issues/396)),
   kerchunk and Icechunk.
-- An SQL engine in the web app.
 - Broader QGIS project compatibility and opening ArcGIS Pro projects (supported QGIS projects
   already open as maps).
 - An in-app Python console; an R package.
-- AI segmentation and detection (SAM, ONNX models).
 
 ## Done
 - Projects that survive a move: local data paths relative to the project and undoable Repair

docs/comparison/geolibre.md

@@ -15,26 +15,38 @@ For RustGIS beside QGIS, ArcGIS Pro and ArcGIS Online as well, see the
 
 ## The short answer
 
-**GeoLibre is the broader, web-first GIS.** It is built with web technology (Tauri, React,
+GeoLibre and RustGIS serve similar purposes, but take different approaches and suit different
+workflows. Neither is meant to replace the other
+([discussion #951](https://github.com/opengeos/RustGIS/discussions/951)).
+
+**GeoLibre is web and mobile first.** It is built with web technology (Tauri, React,
 MapLibre GL JS, DuckDB-WASM, deck.gl) and runs in a browser tab with nothing installed, as a
-desktop app, and as native Android and iOS apps. It reaches further into data (databases,
-cloud catalogs, dozens of open-data portals), 3D (Cesium, 3D Tiles, I3S, Gaussian splats), AI
-(SAM segmentation, ONNX object detection), sharing (share links, review comments, real-time
-collaboration) and the Python and R ecosystems (a Jupyter widget and an R package).
+desktop app, and as native Android and iOS apps. Its strengths are access from anywhere,
+cloud-native data, interactive visualization and sharing. GeoLibre is mature, with a broad
+set of features; as its maintainer put it in
+[discussion #951](https://github.com/opengeos/RustGIS/discussions/951), its development now
+centres on stability, performance and usability.
+
+**RustGIS is desktop first, built for automation and AI agents.** It is a single program written
+entirely in Rust that draws its own interface on the GPU, with no browser engine or JavaScript
+runtime inside; the same program, compiled to WebAssembly, also runs in the browser. Its
+interface is a ribbon laid out in the order of the work, and almost everything in it is a
+command that scripts, the command line, Python and AI agents can run. It goes deeper in the
+classic desktop GIS jobs of data design, reports and print layouts. RustGIS is young and
+changing quickly: expect frequent releases, new capabilities and some significant changes.
 
-**RustGIS is the narrower, native one.** It is a single program written entirely in Rust that
-draws its own interface on the GPU, with no browser engine or JavaScript runtime inside, and the
-same program compiled to WebAssembly for the browser. Its interface is a ribbon laid out in the
-order of the work, its engine commands run from the command line, Python or an AI
-agent, and its WebAssembly plugins run sandboxed. It also supports native process plugins
-and goes further in the classic desktop GIS jobs of data design, reports and print layouts.
+The two complement each other. Both can run the 1,000+ GeoLibre/Whitebox geoprocessing suite,
+both read and write common open formats, and the plan is for RustGIS to open `.geolibre`
+projects first and for GeoLibre to open `.rgis` projects later (see
+[Using them together](#using-them-together)). Choose GeoLibre for web-first work, phones and
+notebooks, choose RustGIS for a scriptable desktop GIS, or use both.
 
-They are complementary rather than competing. Both can run the 1,000+ GeoLibre/Whitebox
-geoprocessing suite; RustGIS loads it through an optional desktop runner or WebAssembly.
-Both read and write common open formats. Choose GeoLibre for reach, choose RustGIS for a
-compact, scriptable desktop GIS, or use both.
+## Where each is stronger today
 
-## Where GeoLibre is stronger
+These lists compare features as of **October 2026**, and RustGIS's features change quickly. The
+differences in the short answer, in platform, technology and focus, are the ones that last.
+
+### Where GeoLibre is stronger
 
 - **More platforms.** GeoLibre runs as a web app, an installable PWA, a desktop app on Windows,
   macOS and Linux, native [Android and iOS apps](https://geolibre.app), a Docker image, a Chrome
@@ -49,7 +61,7 @@ compact, scriptable desktop GIS, or use both.
   SQL Server/Azure SQL connections. Other formats and File Geodatabase tables the native
   reader cannot read need GDAL (see [Data formats](../user-guide/data-formats.md)).
 - **SQL in the browser.** GeoLibre runs DuckDB Spatial, PGlite/PostGIS and Apache Sedona inside
-  the browser. RustGIS's SQL pane uses DuckDB on the desktop; its web app has no SQL engine yet.
+  the browser. RustGIS's SQL pane uses DuckDB on the desktop; its web app has no SQL engine.
 - **Cartography depth.** GeoLibre has rule-based and expression renderers, heat maps,
   clustering, diagrams, blend modes, layer groups, a data-defined label engine, and style
   interchange with SLD, QGIS QML and Mapbox GL JSON. RustGIS covers the common renderers and
@@ -71,22 +83,23 @@ compact, scriptable desktop GIS, or use both.
   that runs commands headlessly and built-in notebooks of command cells, but no Python console
   in the app and no R package.
 - **Opening other projects.** GeoLibre imports QGIS (`.qgs`/`.qgz`) and ArcGIS Pro
-  (`.aprx`/`.mapx`) projects. RustGIS opens neither.
+  (`.aprx`/`.mapx`) projects. RustGIS opens supported QGIS projects as maps (see
+  [QGIS projects](../user-guide/workspace.md#qgis-projects-and-styles)) but not ArcGIS Pro ones.
 - **Editing.** GeoLibre edits vertices and writes edits back to their sources (GeoPackage,
   PostGIS, ArcGIS feature services). RustGIS moves, inserts and deletes vertices, but
   edits stay in the project until exported rather than being written back to those sources.
 - **Languages.** GeoLibre's interface comes in 21 languages, including right-to-left Arabic,
   Hebrew and Persian. RustGIS has [17](../i18n.md), including Persian text support;
   its widget layout is not right-to-left.
 
-## Where RustGIS is stronger
+### Where RustGIS is stronger
 
 - **A native program, not a web view.** RustGIS is memory-safe Rust compiled to one native
   program with no browser engine, JavaScript or Python inside the core app. Large
   GeoPackage, GeoParquet, FlatGeobuf and Shapefile files are read a view at a time rather
   than loaded whole; the cloud-native readers also work in the browser.
-- **A shared command engine.** Ribbon actions dispatch commands with ids and JSON parameters.
-  Engine commands run from [`rustgis-cli`](../cli.md), the
+- **Commands for scripts and AI agents.** Ribbon actions dispatch commands with ids and JSON
+  parameters. Engine commands run from [`rustgis-cli`](../cli.md), the
   [`rustgis` Python package](../python.md), notebooks, models, the Script pane, the
   [MCP server](../mcp.md) and the AI Assistant. UI-only pane/dialog commands stay in the app.
   A batch of maps can be rendered in CI with one
@@ -146,8 +159,13 @@ compact, scriptable desktop GIS, or use both.
 
 The two read and write the same open formats, so data moves between them without conversion:
 GeoPackage, GeoParquet, FlatGeobuf, Shapefile, GeoJSON, KML/KMZ, GPX, CSV and cloud-optimised
-GeoTIFF (GeoPackage export is desktop only in RustGIS). Neither opens the other's project
-file yet; move the data across and restyle it.
+GeoTIFF (GeoPackage export is desktop only in RustGIS).
+
+Neither opens the other's project file yet; for now, move the data across and restyle it. The
+plan is for RustGIS to open `.geolibre` projects first
+([#962](https://github.com/opengeos/RustGIS/issues/962)). GeoLibre opening `.rgis` projects
+comes later, once RustGIS's project format and the data types it supports settle: RustGIS is
+still changing quickly, and GeoLibre would otherwise be reading a moving target.
 
 They also share their geoprocessing. RustGIS's **Analyze › Tools** offers the GeoLibre and
 Whitebox suite through the optional `geolibre` program on desktop and an on-demand WebAssembly
@@ -162,9 +180,11 @@ or reports and map series printed to PDF.
 ## Common questions
 
 **Why are there two?**
-They are built on different foundations for different jobs. GeoLibre uses the web platform to
-reach as many places and data sources as possible. RustGIS explores what a desktop GIS looks like
-as one native Rust program with a shared command engine. Each project borrows ideas from the other.
+To explore different ways of making geospatial tools accessible and powerful. GeoLibre uses the
+web platform to reach as many places and data sources as possible. RustGIS explores what a
+desktop GIS looks like as one native Rust program that scripts and AI agents can drive. Each
+project borrows ideas from the other, and they are meant to be used together, not chosen
+between.
 
 **Which one should I start with?**
 If you want to open a dataset in a browser tab or on a phone right now, or work in Jupyter or R,
@@ -182,7 +202,9 @@ No. GeoLibre plugins are TypeScript modules for its web interface. RustGIS has i
 WebAssembly and native process-plugin interfaces, including Python process plugins.
 
 **Can I open a GeoLibre project in RustGIS?**
-Not yet. Export the layers (GeoPackage or GeoParquet keep the most) and add them to RustGIS.
+Not yet; it is planned
+([#962](https://github.com/opengeos/RustGIS/issues/962)). Until then, export
+the layers (GeoPackage or GeoParquet keep the most) and add them to RustGIS.
 
 ## See also
 

docs/comparison/index.md

@@ -5,8 +5,8 @@ platforms people most often ask about: **QGIS**, **ArcGIS Pro** and **ArcGIS Onl
 
 RustGIS is not trying to replace any of these. It fills a narrower spot: a **free and
 open-source desktop GIS compiled to a single native program**, with a ribbon interface familiar
-from desktop GIS, every action available as a scriptable command, and the same app running in a
-browser tab through WebAssembly.
+from desktop GIS, almost every action available as a scriptable command, and the same app running
+in a browser tab through WebAssembly.
 
 !!! note "How to read this"
     Comparisons like this age quickly and are written by an interested party. The RustGIS
@@ -38,10 +38,11 @@ They differ in how they are built and who they suit:
   out in the order of the work, and an engine whose commands run the
   same way from the ribbon, `rustgis-cli`, Python, notebooks, models and the AI Assistant.
 
-If you want the widest data access and the most platforms, choose GeoLibre. If you want a
-compact native desktop GIS with a classic ribbon workflow and a scriptable command
-engine, choose RustGIS. Both work on local files on your machine; remote features, such as web
-data and AI providers, send requests over the network. See
+They complement each other rather than compete: GeoLibre is web and mobile first, RustGIS
+desktop first and built for automation and AI agents. If you want the widest data access and the
+most platforms, choose GeoLibre. If you want a compact native desktop GIS with a classic ribbon
+workflow and a scriptable command engine, choose RustGIS. Both work on local files on your
+machine; remote features, such as web data and AI providers, send requests over the network. See
 [RustGIS and GeoLibre](geolibre.md) for a closer look.
 
 ## At a glance