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

> Explore the GeoLibre development roadmap from v0.1 to v1.3. Discover concrete features and milestones for this open-source geospatial library. See the complete plan.

- Repository: [Open Geospatial Solutions/GeoLibre](https://github.com/opengeos/GeoLibre)
- Tags: roadmap
- Published: 2026-08-16

---

**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`](https://github.com/opengeos/GeoLibre/blob/main/docs/roadmap.md).**

The [opengeos/GeoLibre](https://github.com/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`](https://github.com/opengeos/GeoLibre/blob/main/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`](https://github.com/opengeos/GeoLibre/blob/main/.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`](https://github.com/opengeos/GeoLibre/blob/main/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`](https://github.com/opengeos/GeoLibre/blob/main/apps/geolibre-desktop/src/hooks/usePlugins.ts):

```typescript
// 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`](https://github.com/opengeos/GeoLibre/blob/main/packages/processing/src/processing.ts):

```typescript
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`](https://github.com/opengeos/GeoLibre/blob/main/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:

```typescript
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:

```python
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`](https://github.com/opengeos/GeoLibre/blob/main/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`](https://github.com/opengeos/GeoLibre/blob/main/apps/geolibre-desktop/src-tauri/Cargo.toml) automatically packages the side-car and web assets:

```bash
npm run tauri:build

```

## Key Source Files by Roadmap Area

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

## How the GeoLibre Roadmap Is Maintained

The roadmap document at [`docs/roadmap.md`](https://github.com/opengeos/GeoLibre/blob/main/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`](https://github.com/opengeos/GeoLibre/blob/main/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`](https://github.com/opengeos/GeoLibre/blob/main/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`](https://github.com/opengeos/GeoLibre/blob/main/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.