GeoLibre Roadmap: Complete Development Plan from v0.1 to v1.3

GeoLibre's development roadmap is structured as thirteen versioned milestones, from the initial v0.1 map viewer through the v1.3 AI-powered collaboration release, with each version delivering concrete features tracked as completed checklist items in docs/roadmap.md.

The opengeos/GeoLibre repository maintains its official roadmap in a dedicated markdown document that serves as both a project-management board and public documentation. This article breaks down every milestone, explains the architectural decisions behind the roadmap, and shows how to interact with key features through actual source code.

GeoLibre Roadmap Overview: Releases v0.1 Through v1.3

The GeoLibre roadmap spans thirteen incremental releases, each building on a Tauri desktop + Vite web + Python FastAPI side-car architecture. Below is the complete breakdown of what each version delivers.

v0.1: Foundation (Map Viewer & Basic UI)

The inaugural release established the core shell: Tauri desktop framework, React UI, and MapLibre GL JS rendering. Key capabilities included GeoJSON loading, an attribute table interface, a processing UI scaffold, and the plugin framework foundation.

This version lives in packages/core/src/store.ts, where the Zustand store became the single source of truth for all application state.

v0.2: Project Persistence

Introduced the .geolibre.json project format with save/open operations, recent-project tracking, and feature highlighting. The UI gained a dedicated recent-projects panel.

v0.3: Cloud-Native Formats

Added GeoParquet and FlatGeobuf import via DuckDB-WASM, plus PMTiles and COG/GeoTIFF raster rendering. This release positioned GeoLibre as a modern, cloud-optimized GIS platform.

v0.4: DuckDB Spatial Integration

Full DuckDB-WASM support with spatial SQL queries and multi-format vector imports. The processing engine began leveraging in-browser analytical capabilities.

v0.5: Advanced "Add Data" & Plugin-Backed Layers

Rich Add-Data dialogs and the Components plugin supporting FlatGeobuf, PMTiles, Zarr, LiDAR, and Gaussian splat data. Desktop builds gained MBTiles handling.

v0.6: Project Access & Web Embeds

Persistent recents, Open-Project with file vs. URL distinction, PostgreSQL integration, STAC search, and the plugin marketplace infrastructure.

v0.7: Data Loading, Identify & Settings

Expanded format support with GPX, delimited text, WFS, and WMS GetFeatureInfo. The Whitebox side-car integration debuted alongside inline editing and a comprehensive settings dialog.

v0.8: Viewer Packaging & Dynamic Layers

Cloudflare Worker viewer deployment, 3D Tiles support, external plugin ZIP loading, and safe fallbacks for crypto.randomUUID in restricted environments.

v0.9: Data Integrations, Processing & UI Overhaul

Major integrations with Planetary Computer, Earth Engine, and Overture Maps. Added SQL workspace, Time-Slider, conversion tools, and a redesigned processing UI.

v1.0: Stable Prototype & Pipelines

The landmark stable release introduced GDAL/Rasterio/GeoPandas pipelines, external plugin distribution, marketplace UI, share actions, and the Python anywidget API. Cross-platform installers arrived via Tauri v2.

v1.1: Vector Styling & Atmospheric Effects

In-browser GeoPandas, deck.gl exposure to plugins, advanced style panels, and atmospheric rendering effects.

v1.2: New Sources, Analytics & Polish

OSM PBF loading, NetCDF/HDF support, authenticated 3D Tiles, attribute analytics, routing capabilities, undo/redo, and PWA support.

v1.3: Depth of Analysis & Collaboration

The roadmap's current horizon: spatial statistics, AI segmentation, real-time multi-user collaboration, story-map builder, AI GIS assistant, and mobile-first layouts.

Architectural Foundations Supporting the Roadmap

The GeoLibre roadmap isn't arbitrary—it's built on specific architectural patterns implemented in key source files.

Store-Driven Architecture

Every roadmap feature extends the central Zustand store in packages/core/src/store.ts. Components, plugins, and side-car operations all read from or write to this store, with @geolibre/map handling MapLibre GL JS synchronization.

Plugin System Evolution

Built-in plugins reside in packages/plugins/src/plugins/. Registration happens through apps/geolibre-desktop/src/hooks/usePlugins.ts:

// From apps/geolibre-desktop/src/hooks/usePlugins.ts
import { useEffect } from 'react';
import { registerPlugin } from '@geolibre/core';

export const usePlugins = () => {
  useEffect(() => {
    // Auto-loads built-in and external plugins
    const loadPlugins = async () => {
      const builtIn = await import('@geolibre/plugins');
      builtIn.default.forEach(registerPlugin);
    };
    loadPlugins();
  }, []);
};

External plugins dropped into apps/geolibre-desktop/public/plugins/ or loaded from ZIP files enable the "dynamic external plugin" feature introduced in v0.8.

Processing Pipeline Architecture

The packages/processing workspace orchestrates client-side tools (Turf.js, DuckDB-WASM) and server-side engines (GDAL, Rasterio, GeoPandas). The v1.0 redesign supports both pipeline types side-by-side in packages/processing/src/processing.ts:

import { runTool } from '@geolibre/processing';
import { ToolName } from '@geolibre/processing/types';

async function bufferLayer(layerId: string, distance: number) {
  await runTool(ToolName.Buffer, {
    inputs: { layerId },
    params: { distance },
  });
}

Python Side-Car Integration

The FastAPI side-car in backend/geolibre_server/app/main.py provides heavy-weight operations when running in desktop mode. The API surface enables raster reprojection, WhiteboxTools execution, and GeoPandas operations:

import axios from 'axios';

async function rasterReproject(inputPath: string, outputPath: string) {
  const resp = await axios.post('http://127.0.0.1:8765/raster/reproject', {
    input: inputPath,
    output: outputPath,
    dst_crs: 'EPSG:3857',
  });
  return resp.data;
}

Jupyter AnyWidget API (v1.0)

The python/ package bundles the web app as a Jupyter anywidget, fulfilling the v1.0 "Python package for Jupyter notebooks" goal:

from geolibre import Map

m = Map()
m.add_geojson(my_geojson, name="Sample")
m.add_tile_layer("https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", name="OSM")
m.to_html("my_map.html")

Source: python/src/geolibre/__init__.py

Cross-Platform Desktop Packaging

Tauri v2 builds native installers for Windows, macOS, and Linux. The build pipeline in apps/geolibre-desktop/src-tauri/Cargo.toml automatically packages the side-car and web assets:

npm run tauri:build

Key Source Files by Roadmap Area

Area	File	Roadmap Relevance
Core state management	packages/core/src/store.ts	Foundation for all v0.1+ features
Plugin registration	apps/geolibre-desktop/src/hooks/usePlugins.ts	v0.8 dynamic external plugins
Map rendering sync	packages/map/src/MapController.ts	v0.1-v1.3 visualization
Processing engine	packages/processing/src/processing.ts	v0.9, v1.0 pipeline architecture
Python API server	backend/geolibre_server/app/main.py	v0.7-v1.0 side-car operations
Jupyter integration	python/src/geolibre/__init__.py	v1.0 anywidget API
Desktop build config	apps/geolibre-desktop/src-tauri/Cargo.toml	v1.0 unified installers
Official roadmap	docs/roadmap.md	Canonical development plan

How the GeoLibre Roadmap Is Maintained

The roadmap document at docs/roadmap.md uses GitHub-flavored markdown checkboxes. Completed items carry [x] markers; pending items show [ ]. When a release is tagged, the corresponding checked items become part of the shipped product, and development shifts to the next version's checklist.

This approach makes the roadmap simultaneously:

• A project-management board for maintainers
• Public documentation for users evaluating the platform
• A traceability matrix linking features to specific releases

Summary

• GeoLibre's roadmap spans v0.1 through v1.3, with each version delivering concrete, verifiable features tracked in docs/roadmap.md.
• v0.1-v0.9 focused on core GIS capabilities: visualization formats, DuckDB integration, processing tools, and cloud-native data support.
• v1.0 marked the stable prototype with GDAL pipelines, Python anywidget API, and cross-platform installers.
• v1.1-v1.3 advance toward production: vector styling, analytics, AI integration, and real-time collaboration.
• Five architectural pillars support every roadmap item: the Zustand store, plugin system, processing pipelines, Python side-car, and Tauri packaging.

Frequently Asked Questions

Where is the official GeoLibre roadmap documented?

The canonical roadmap lives in docs/roadmap.md at the repository root. This file contains versioned checklists with completed items marked [x] and pending items marked [ ]. It serves as both the internal project board and public feature preview.

What is the current stable version of GeoLibre?

According to the roadmap structure, v1.0 represents the first stable prototype release. It introduced GDAL/Rasterio/GeoPandas pipelines, the Python anywidget API, external plugin distribution, and unified desktop installers for Windows, macOS, and Linux.

How can developers contribute to the GeoLibre roadmap?

Contributors should examine docs/roadmap.md to identify unclaimed features in upcoming versions. The modular architecture—particularly the plugin system in packages/plugins/ and processing workspace in packages/processing/—allows isolated development that aligns with roadmap milestones. Pull requests should reference specific roadmap version targets.

When will AI features arrive in GeoLibre?

AI segmentation and the AI GIS assistant are scheduled for v1.3, the final documented milestone. These features accompany real-time multi-user collaboration and the story-map builder. Earlier versions (v0.9-v1.2) establish necessary foundations: Earth Engine integration, Python pipelines, and processing infrastructure.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}