GeoLibre - Cloud-Native GIS in the Browser, Desktop, Docker, and Jupyter

GeoLibre is the kind of open-source GIS project that is easy to underestimate from the first sentence.

It is not just a map viewer. It is trying to be a portable GIS workspace that can run in the browser, on the desktop, on Android, inside Docker, and inside Jupyter notebooks.

That combination matters if you want geospatial work without turning every map task into a heavyweight desktop-GIS setup.

GeoLibre is a free, open-source, cloud-native GIS workspace for visualizing, exploring, styling, and analyzing geospatial data while keeping local data local.

GeoLibre GitHub Source Code GeoLibre Website Launch GeoLibre Web License: MIT

What is GeoLibre?

GeoLibre is a GIS application built around modern web geospatial tooling.

The project uses:

• Tauri v2 for the desktop and mobile shells
• React and TypeScript for the app UI
• MapLibre GL JS for map rendering
• DuckDB-WASM Spatial for in-browser data handling and spatial SQL
• deck.gl for advanced overlays
• FastAPI for the optional Python processing sidecar
• anywidget for the Jupyter integration

The same workspace can load local vector files, drag GeoTIFF/COG rasters onto the map, connect to web map services, style layers, run spatial SQL, use processing tools, save .geolibre.json projects, and embed the app in notebooks.

The practical split is simple:

Why It Is Interesting

GeoLibre sits in a useful middle ground.

QGIS is still the obvious answer for deep desktop GIS. But not every map workflow needs a full desktop application, plugins, profiles, and a local project folder.

Browser GIS tools are convenient, but many of them are either hosted SaaS products or narrow viewers. GeoLibre is different because it treats the browser as a serious geospatial runtime:

• DuckDB-WASM can read and query geospatial data in the browser.
• MapLibre renders modern vector and raster map layers.
• The app can work with local files without uploading them to someone else’s backend.
• The Docker image gives you a self-hostable web version.
• The desktop build adds the filesystem affordances that browsers cannot provide.
• The Python package lets notebooks drive the same map state.

That makes it especially relevant for data people, researchers, educators, and home-lab users who want a practical GIS workspace without accepting a closed hosted platform.

Repository Snapshot

I cloned the repo into:

tmp/foss-post/geolibre

The checkout I inspected:

project version: 2.1.0
package manager: npm workspaces
required Node.js: 22+
license: MIT
local Docker smoke image: ghcr.io/opengeos/geolibre:latest
smoke-tested digest: sha256:e0c30a4191dcfec48eee4ed7d2839311ddde353f87afce21f2639358ea2c623a

The top-level layout is a real product monorepo:

Self-Hosting GeoLibre with Docker

The quickest upstream container test is:

docker run --rm -p 8080:80 ghcr.io/opengeos/geolibre:latest

Then open:

http://127.0.0.1:8080

The container serves the production browser app with nginx and reverse-proxies the optional Python sidecar at /sidecar.

For a more useful local run, mount a data folder so the sidecar can read and write conversion inputs under /data:

mkdir -p data
docker run --rm \
  --name geolibre \
  -p 8097:80 \
  -v "$PWD/data:/data" \
  ghcr.io/opengeos/geolibre:latest

With Basic Auth enabled:

mkdir -p data
docker run --rm \
  --name geolibre \
  -p 8097:80 \
  -v "$PWD/data:/data" \
  -e GEOLIBRE_AUTH_USER=admin \
  -e GEOLIBRE_AUTH_PASSWORD='use-a-real-password' \
  ghcr.io/opengeos/geolibre:latest

I added a reusable Home-Lab Compose snippet here:

The site includes the config directly:

Create the .env file:

cp .env.sample .env

Start it:

docker compose up -d
docker compose logs -f

Then open:

http://127.0.0.1:8097

The compose file binds to localhost by default, mounts ./data into /data, keeps the sidecar enabled, and pins the image to the digest I smoked locally.

Optional Basic Auth

GeoLibre’s container can protect the app and sidecar with HTTP Basic Auth.

Set both variables together:

GEOLIBRE_AUTH_USER=admin
GEOLIBRE_AUTH_PASSWORD=use-a-real-password

For anything outside a trusted LAN, put HTTPS in front of it with Caddy, Traefik, nginx, Cloudflare Tunnel, or another reverse proxy.

The upstream Dockerfile also warns that the browser image allows localhost connections in its Content Security Policy for local development data sources. If you publish GeoLibre on a shared or internet-facing host, review that CSP first.

Desktop App

For local GIS work, the desktop app is probably the better daily driver.

The desktop build adds things the browser cannot do cleanly:

• local filesystem dialogs
• local MBTiles
• local raster file reads
• project save/open
• desktop-managed sidecar workflows

GeoLibre publishes desktop installers through GitHub Releases, and the docs list Linux .deb, .rpm, and AppImage options, Windows installer and portable options, macOS DMG builds, Microsoft Store, Homebrew Cask, AUR, COPR, and Flatpak paths.

For macOS:

brew install --cask geolibre

For Windows:

winget install OpenGeos.GeoLibre

For Fedora:

sudo dnf copr enable giswqs/geolibre
sudo dnf install geolibre

For Linux users who already have AppImageLauncher installed, the desktop path is even simpler:

1. Open the latest GeoLibre GitHub Release .
2. Download the GeoLibre.Desktop_<version>_amd64.AppImage asset.
3. Open the downloaded AppImage.

AppImageLauncher should offer to integrate it into your desktop menu. If your file manager does not launch it directly, mark it executable first:

#wget -O GeoLibre.Desktop_2.1.0_amd64.AppImage https://github.com/opengeos/GeoLibre/releases/download/v2.1.0/GeoLibre.Desktop_2.1.0_amd64.AppImage && chmod +x GeoLibre.Desktop_2.1.0_amd64.App
  Image && ./GeoLibre.Desktop_2.1.0_amd64.AppImage
chmod +x GeoLibre.Desktop_*_amd64.AppImage
./GeoLibre.Desktop_*_amd64.AppImage

For Jupyter users, the install is separate:

pip install geolibre

Or with conda:

conda install -c conda-forge geolibre

Then in a notebook:

from geolibre import Map

m = Map(center=(-100, 40), zoom=4)
m.add_geojson("https://example.com/data.geojson", name="Data")
m

What You Can Load

GeoLibre’s format surface is broad.

The browser and desktop paths cover common GIS files and services, including:

• GeoJSON
• GeoParquet
• GeoPackage
• Shapefile
• FlatGeobuf
• KML/KMZ
• GPX
• CSV and delimited text
• COG and GeoTIFF rasters
• MBTiles
• PMTiles
• WMS and WFS
• ArcGIS FeatureServer and VectorTileServer layers
• vector tiles
• 3D Tiles
• Zarr
• LiDAR
• geotagged photos
• glTF/GLB and Gaussian splats

The desktop app has the strongest local-file story. The Docker/browser version is excellent for web-capable workflows, but a browser cannot magically hand a container an arbitrary local file path. For sidecar conversions in Docker, mount data into the container, normally under /data.

Field Note: Local Trial

I validated GeoLibre in three layers.

First, I cloned and inspected the repo:

git clone --depth 1 https://github.com/opengeos/GeoLibre.git tmp/foss-post/geolibre

The README, docs/getting-started.md, docs/downloads.md, docs/architecture.md, Dockerfile, docker/entrypoint.sh, docker/nginx.conf, root package.json, Python package metadata, and backend sidecar metadata all lined up with the project claims.

Second, I smoked the published container:

docker run -d --name geolibre-smoke -p 8097:80 ghcr.io/opengeos/geolibre:latest
curl -fsS http://127.0.0.1:8097/healthz
curl -fsS http://127.0.0.1:8097/ | sed -n 's/.*<title>\\([^<]*\\)<\\/title>.*/\\1/p'
docker rm -f geolibre-smoke

Result:

health: ok
page title: GeoLibre
image digest: sha256:e0c30a4191dcfec48eee4ed7d2839311ddde353f87afce21f2639358ea2c623a

Third, I validated the Home-Lab compose config:

docker compose config

That rendered the expected service, localhost port binding, /data mount, sidecar environment variables, and health check.

I did not build the Tauri desktop app from source on this machine.

That path needs Node 22+, Rust, and the Linux Tauri/WebKitGTK prerequisites, and it is heavier than needed for a post centered on the published Docker and install paths.

Where GeoLibre Fits

GeoLibre belongs beside the practical open-source mapping stack:

The interesting part is that GeoLibre crosses those boundaries. It is not only a map library, not only a desktop app, and not only a notebook widget.

It gives you one project format and one UI surface that can move between those modes.

FAQ

Is GeoLibre a QGIS replacement?

Not entirely. QGIS is still the deeper desktop GIS ecosystem.

GeoLibre is more interesting as a modern, portable, browser-friendly GIS workspace with desktop and notebook paths.

Why GeoLibre instead of MapLibre, Libre Map, or OpenStreetMap?

They are not really the same kind of project.

• OpenStreetMap is the community and open geographic database. Use it as data, basemap source, or an editing ecosystem.
• MapLibre is the open-source map rendering library family. Use it when you are building your own map app.
• Libre Map Project is closer to an archive/collection of free maps and GIS data.
• GeoLibre is the application layer: a ready-to-use GIS workspace where you can load data, style layers, run spatial SQL, use processing tools, work from Docker, desktop, browser, or Jupyter, and save/share projects.

So the better framing is not “GeoLibre versus OpenStreetMap”; it is “GeoLibre with OpenStreetMap and MapLibre underneath.”

GeoLibre itself uses MapLibre GL JS for map rendering and can consume OSM-derived datasets such as Geofabrik extracts.

Can I self-host GeoLibre?

Yes. The upstream image is ghcr.io/opengeos/geolibre, and the Home-Lab compose snippet above runs it on 127.0.0.1:8097 by default.

For a one-command trial:

docker run --rm -p 8097:80 ghcr.io/opengeos/geolibre:latest #http://127.0.0.1:8097/

Does the Docker version include every desktop feature?

No. Docker serves the browser app and optional sidecar.

Desktop-only local filesystem features still need the Tauri desktop app.

Which open datasets make sense for testing GeoLibre?

Start with small vector datasets first, then move into cloud-native formats:

• Natural Earth - public-domain countries, admin boundaries, populated places, rivers, roads, and raster basemaps. Good first test because the files are small and cartography-friendly.
• Geofabrik OpenStreetMap extracts - daily OSM regional extracts in .osm.pbf and shapefile formats. Start with a city, country, or small region before trying continent-scale data.
• Overture Maps - cloud-native GeoParquet for buildings, places, transportation, addresses, base, and divisions. This is a good match for GeoLibre’s GeoParquet and DuckDB-style workflows.
• Source Cooperative - public geospatial products such as COG, Zarr, GeoParquet, and PMTiles datasets. Useful when testing raster, remote-sensing, and cloud-native data paths.
• OpenGeos Datasets for GeoAI - open-access GeoAI datasets from the same broader geospatial ecosystem. Good for experimenting with imagery and ML-oriented mapping workflows.

My suggested first run: load a Natural Earth countries layer, add a local Geofabrik shapefile extract for one city or region, then try a bounded Overture building download as GeoJSON or GeoParquet.

Does GeoLibre upload my local data?

The core browser workflow processes local files in the browser.

If you connect remote services, use collaboration features, or deploy your own container, then normal network and deployment considerations apply.

Who should try it?

Try GeoLibre if you work with maps, GeoJSON, GeoParquet, COGs, WMS/WFS, spatial SQL, or notebook maps and want something more portable than a traditional desktop-only GIS workflow.