Pure Rust Geospatial Data Abstraction Library — Production-Grade GDAL Alternative

Note: OxiGeo is the new name of OxiGDAL. v0.1.7 was the final release under the OxiGDAL name; development continues as OxiGeo from v0.2.0 with an otherwise identical codebase. This project is an independent reimplementation and is not affiliated with the GDAL project.

GeoSentinel: watch any place on Earth for change — and tell no one where you're looking. It searches the public Earth Search STAC API for a cloud-filtered Sentinel-2 scene pair, streams only the needed COG windows via HTTP range requests, and runs the whole change-detection pipeline — NDVI difference, thresholding, polygonization, geodesic areas, GeoJSON export — 100% client-side in Pure-Rust WebAssembly; your area of interest never leaves your machine. Try it live — one of four hosted demos below, alongside GeoLab, GeoVault, and GeoParquet Live.

OxiGeo is a comprehensive, production-ready geospatial data abstraction library written in 100% Pure Rust with zero C/C++/Fortran dependencies in default features. Development is now at v0.2.0, the first version under the OxiGeo name (v0.1.7 completed production-hardening validation on 2026-07-20; v0.1.6 released 2026-06-15; 0.1.7 has not yet been published to crates.io — publication is a separate, not-yet-taken step). The library delivers ~747K Rust SLoC across 76 workspace crates, covering 17 geospatial format drivers, full CRS transformations, raster/vector algorithms, cloud-native I/O, GPU acceleration, enterprise security, and cross-platform bindings (Python, Node.js, WASM, iOS, Android).

[dependencies]
oxigeo = "0.2"  # GeoTIFF + GeoJSON + Shapefile by default

# Full feature set:
oxigeo = { version = "0.2", features = ["full"] }

use oxigeo::Dataset;

fn main() -> oxigeo::Result<()> {
    let dataset = Dataset::open("world.tif")?;
    println!("Format : {}", dataset.format());
    println!("Size   : {}x{}", dataset.width(), dataset.height());
    println!("CRS    : {}", dataset.crs().unwrap_or("unknown"));
    Ok(())
}

Four live, hosted demos — each one runs 100% client-side: Pure-Rust WebAssembly in your browser tab, no server-side processing, no accounts, no telemetry.

The GeoLab viewer is a Pure-Rust WebAssembly build of the raster pipeline — GeoTIFF decode, combined_hillshade, and colormap rendering all run in the browser tab, not on a server.

Hosted, nothing to install: cooljapan.tech/geolab

Or run it locally (builds the WASM module, then serves the static demo):

cd crates/oxigeo-wasm
wasm-pack build --scope cooljapan --target web --out-dir pkg --release
cd ../../demo/cog-viewer
python3 -m http.server 8080
# open http://localhost:8080

The same algorithms, invoked directly from Rust (no browser, no WASM) against the San Francisco / Marin Headlands SRTM DEM:

combined_hillshade × Colormap::Terrain	slope() × Colormap::Spectral
aspect() masked by slope() × Colormap::Jet	elevation × Colormap::Viridis

Every image on this page — the hero screenshots, the interaction GIFs, the demo galleries, and the four native renders above — is a real capture or render produced by this repository's own code, not a mockup. Reproduce the native gallery yourself with: cargo run -p oxigeo-server --example render_hero --release -- --mode all

Watch any place on Earth for change — and tell no one where you're looking. GeoSentinel searches the public Earth Search STAC API for a cloud-filtered Sentinel-2 L2A scene pair, streams only the needed COG windows (red + NIR bands) via HTTP range requests, and runs the whole change-detection pipeline — NDVI difference, fixed or Otsu thresholding, polygonization, Karney geodesic areas, GeoJSON export — inside WebAssembly. Try it live

Hosted, nothing to install: cooljapan.tech/geosentinel

Or run it locally (builds the WASM package if missing, then serves the demo):

cd demo/geosentinel
./run.sh
# open http://localhost:8080

Scene A — true color (before)	Scene B — true color (after)
NDVI-drop heatmap (red = vegetation loss)	Change polygons + geodesic hectares (GeoJSON export)

Honest notes — the analysis (NDVI, thresholding, polygonization, geodesic areas) runs locally in your tab; the Sentinel-2 imagery is streamed directly from the AWS open-data bucket (sentinel-cogs S3, found via the public Earth Search STAC API); your location and area of interest are never sent to any backend of ours — there isn't one. Verified example: the Lahaina wildfire preset detects 713 ha of burn scar (≈880 ha ground truth) from 9.0 MB of streamed imagery.

Analyze sensitive terrain data in a browser clean-room that can prove its session log afterwards. Every operation is appended to a blake3 hash chain, rolled up into a Merkle root, and sealed with an Ed25519 signature — producing a downloadable attestation that an independent verifier page (or a native Rust example) re-checks from the JSON alone, while a strict Content-Security-Policy forbids every external connection during the session. Try it live

Hosted, nothing to install: cooljapan.tech/geovault

Or run it locally (shares the GeoLab/GeoSentinel WASM package):

wasm-pack build crates/oxigeo-wasm --target web --out-dir pkg   # once, from repo root
cd demo/geovault
python3 -m http.server 8080
# open http://localhost:8080

Workstation — every action lands in the session ledger	Anomaly detection (Z-score / IQR / modified-Z)
Seal session — Merkle root + Ed25519 signature	Independent verifier — chain ✓ · root ✓ · signature ✓

Trust model, stated honestly — the attestation cryptographically proves that the recorded operation log is complete and unaltered since sealing (blake3 chain → Merkle root → Ed25519 seal); the zero-egress claim is enforced by a browser Content-Security-Policy and observed by in-page fetch/XHR/beacon hooks — it is not mathematically proven, because no browser page can prove what other software on the machine did. Log integrity: proven. No-egress: enforced and observed.

Query a dataset bigger than your laptop, over the network, with no database. The browser points at the VIDA Japan building-footprints GeoParquet — 5.9 GB, 47.66 million rows, 9,533 row groups — and answers bounding-box + attribute queries by downloading only the byte ranges that survive metadata pruning: the Shinjuku preset prunes 9,533 row groups down to 7 survivors, fetches 4.7 MB of column chunks, and refines the exact matches in 13 ms. Try it live

Hosted, nothing to install: cooljapan.tech/geoparquet

Or run it locally (serve.py answers HTTP Range requests with 206, which stock python3 -m http.server does not):

cd demo/geoparquet
./build.sh              # wasm-pack build of crates/oxigeo-wasm-geoparquet (once)
python3 serve.py 8080
# open http://127.0.0.1:8080

All 9,533 row groups — grey pruned · amber survivors · green fetched	Confidence-colored footprints on a Leaflet canvas
dataset: 5.9 GB · fetched: N MB · uploaded: 0 · server: none

Honest notes — the 17.8 MB Parquet footer is fetched once, on first open only (the browser Cache API serves it on later visits); snappy-compressed GeoParquet is supported via the pure-Rust snap codec, while zstd-compressed files are not — no pure-Rust parquet zstd path exists yet (documented limitation); plan() previews row groups / bytes / request count before a single data byte is fetched, and over-broad queries are refused rather than silently downloaded.

76 workspace crates organized into functional layers:

Core & Algorithms
  oxigeo                    Umbrella crate (unified API entry-point)
  oxigeo-core               Types, traits, async I/O, Arrow buffers, no_std core
  oxigeo-proj               Pure Rust PROJ: 20+ projections, 211+ EPSG, WKT2
  oxigeo-algorithms         SIMD raster/vector algorithms (AVX2, AVX-512, NEON)
  oxigeo-index              Spatial indexing (R-tree, grid, geometry validation/operations)
  oxigeo-qc                 Data validation, anomaly detection, quality scoring

Format Drivers (16 formats)
  geotiff      GeoTIFF/COG   BigTIFF, HTTP range, overviews, DEFLATE/LZW/ZSTD/JPEG
  geojson      GeoJSON       RFC 7946, streaming parser, GeoArrow zero-copy
  geoparquet   GeoParquet    Arrow native, spatial predicate pushdown, 10x faster
  zarr         Zarr v2/v3    Sharding, codec pipeline, consolidated metadata
  flatgeobuf   FlatGeobuf    Packed Hilbert R-tree, spatial filter during decode
  shapefile    Shapefile     SHP/SHX/DBF, full attribute table support
  netcdf       NetCDF        CF conventions, unlimited dims, root group (pure-Rust oxinetcdf)
  hdf5         HDF5          Hierarchical, attributes, real read/write (pure-Rust oxih5)
  grib         GRIB1/2       Meteorological parameter/level tables
  jpeg2000     JPEG2000      Wavelet DWT, full EBCOT tier-1 decoder (MQ coder, 3-pass)
  vrt          VRT           Band math, source mosaicking, on-the-fly processing
  copc         COPC/LAS      Cloud Optimized Point Cloud (LAS 1.4, octree)
  gpkg         GeoPackage    SQLite-based, vector features + tiles
  mbtiles      MBTiles       Tile storage, TMS/XYZ schemes
  pmtiles      PMTiles v3    Hilbert curve, single-file tile archive
  geojson-s    GeoJSON (streaming)  Streaming GeoJSON parser/writer/filter

Cloud & Storage
  oxigeo-cloud              S3 / GCS / Azure Blob backends with HTTP range support
  oxigeo-cloud-enhanced     Multi-cloud orchestration, auto-tiering
  oxigeo-drivers-advanced   Multi-part S3, ADLS, GCS optimized reads
  oxigeo-compress           OxiArc compression: Deflate, LZ4, Zstd, BZip2, LZW
  oxigeo-cache-advanced     Multi-tier: in-memory LRU -> disk -> Redis
  oxigeo-rs3gw              Rust S3-compatible gateway

Domain Modules
  oxigeo-3d                 3D Tiles 1.0 (B3DM, I3DM, PNTS), glTF, Delaunay
  oxigeo-terrain            DEM, hydrology, viewshed, TRI/TPI, watershed
  oxigeo-temporal           Time-series datacube, change detection, gap filling
  oxigeo-analytics          Spatial stats, Getis-Ord Gi*, clustering, zonal ops
  oxigeo-sensors            IoT sensor ingestion, calibration, SOS
  oxigeo-metadata           ISO 19115:2014, ISO 19139 XML, FGDC CSDGM
  oxigeo-stac               SpatioTemporal Asset Catalog 1.0.0 client
  oxigeo-query              SQL-like geospatial query engine with optimizer

Enterprise & Infrastructure
  oxigeo-server             OGC server: WMS 1.3.0, WFS 2.0.0
  oxigeo-gateway            API gateway: JWT, OAuth2, rate limiting
  oxigeo-security           AES-256-GCM, ChaCha20-Poly1305, Argon2id, RBAC/ABAC
  oxigeo-observability      Prometheus metrics, OpenTelemetry tracing, alerting
  oxigeo-services           WMS/WFS endpoints, health checks
  oxigeo-workflow           Workflow automation and scheduling
  oxigeo-distributed        Distributed partitioning and sharding
  oxigeo-cluster            Raft consensus-based cluster coordination
  oxigeo-ha                 High-availability failover and leader election
  oxigeo-postgis            PostGIS connector
  oxigeo-db-connectors      PostgreSQL, SQLite, DuckDB connectors

Streaming & Messaging
  oxigeo-streaming          Real-time stream processing
  oxigeo-kafka              Apache Kafka integration
  oxigeo-kinesis            AWS Kinesis integration
  oxigeo-pubsub             Google Pub/Sub integration
  oxigeo-mqtt               MQTT IoT sensor messaging
  oxigeo-websocket          WebSocket real-time updates
  oxigeo-ws                 WS/WSS server
  oxigeo-etl                ETL pipeline engine
  oxigeo-sync               CRDT-based offline sync (OR-Set, Merkle tree, vector clocks)

Platform Bindings
  oxigeo-wasm               WebAssembly: WasmCogViewer JS/TS API, < 1MB gzipped
  oxigeo-pwa                Progressive Web App: Service Worker, offline-first
  oxigeo-offline            Offline-first sync, operation queue, delta sync
  oxigeo-node               Node.js N-API bindings (napi-rs, CJS + ESM)
  oxigeo-python             Python bindings (PyO3/Maturin, NumPy, manylinux wheels)
  oxigeo-jupyter            Jupyter kernel (evcxr + plotters rich display)
  oxigeo-mobile             iOS (Swift FFI) and Android (Kotlin/JNI)
  oxigeo-mobile-enhanced    Battery/network-aware mobile scheduling
  oxigeo-embedded           no_std for microcontrollers (heapless, embedded-hal)
  oxigeo-noalloc            no_std geospatial primitives (zero heap allocation)
  oxigeo-edge               Edge computing, streaming sensor ingestion, local DB

GPU & ML
  oxigeo-gpu                GPU acceleration (wgpu compute shaders)
  oxigeo-gpu-advanced       Advanced GPU kernels
  oxigeo-ml                 ML pipeline integration
  oxigeo-ml-foundation      Foundation model support

Tooling
  oxigeo-cli                CLI: info, convert, dem, rasterize, warp (Clap)
  oxigeo-dev-tools          File watching, progress bars (indicatif), diff utils
  oxigeo-bench              Criterion benchmarks with pprof flamegraph profiling
  oxigeo-examples           Runnable examples

use oxigeo_geotiff::GeoTiffReader;
use oxigeo_core::io::FileDataSource;

let source = FileDataSource::open("elevation.tif")?;
let reader = GeoTiffReader::open(source)?;
println!("Size  : {}x{}", reader.width(), reader.height());
println!("Bands : {}", reader.band_count());

// COG tile access (HTTP range requests supported transparently)
let tile = reader.read_tile(0, 0, 0)?;

use oxigeo_proj::{Coordinate, Crs, Transformer};

let wgs84  = Crs::from_epsg(4326)?;
let utm54n = Crs::from_epsg(32654)?;   // UTM Zone 54N (Japan)
let tf     = Transformer::new(wgs84, utm54n)?;   // takes ownership of both CRS

let tokyo = Coordinate::from_lon_lat(139.7671, 35.6812);
let utm   = tf.transform(&tokyo)?;
println!("{:.2}, {:.2}", utm.x, utm.y);

// SIMD-vectorized batch transform (Transverse Mercator / Mercator / LCC
// projections get a dedicated SIMD kernel; other projections fall back to
// scalar per-point transformation)
let points = vec![tokyo; 1_000_000];
let batch  = tf.transform_batch(&points)?;

// Reuse a cached, thread-safe Transformer across many calls instead of
// rebuilding the PROJ pipeline every time:
use oxigeo_proj::TransformerCache;
let cache   = TransformerCache::new(16);
let cached  = cache.get_or_build(4326, 32654)?;
let utm2    = cached.transform(&tokyo)?;

use oxigeo_algorithms::raster::{hillshade, HillshadeParams};
use oxigeo_algorithms::{Resampler, ResamplingMethod};

// SIMD hillshade (AVX2 / NEON auto-selected at runtime)
let shaded = hillshade(&dem, HillshadeParams::standard())?;

// SIMD-accelerated resampling (nearest / bilinear / bicubic / lanczos)
let resized = Resampler::new(ResamplingMethod::Bilinear).resample(&dem, 512, 512)?;

// Full CRS reprojection combines a `Transformer` (oxigeo-proj, per-pixel
// coordinate mapping) with a `Resampler` — see `oxigeo-cli`'s `warp`
// command (crates/oxigeo-cli/src/commands/warp.rs) for the reference
// implementation, or invoke it directly: `oxigeo warp --t-srs EPSG:32654 in.tif out.tif`

use oxigeo_core::types::BoundingBox;
use oxigeo_geoparquet::GeoParquetReader;

let mut reader = GeoParquetReader::open("buildings.parquet")?;
let bbox       = BoundingBox::new(135.0, 34.0, 137.0, 36.0)?;

// Row-group pruning via the spatial index, then an exact per-row bbox check
let batches = reader.read_filtered_exact(bbox)?;

import oxigeo

ds   = oxigeo.open("satellite.tif")     # mode="r" by default
data = ds.read_band(1)                   # returns a NumPy ndarray
meta = ds.get_metadata()
print(f"Size: {meta['width']}x{meta['height']}")

result = oxigeo.calc("A * 2", A=data)   # raster algebra
oxigeo.write("output.tif", result, metadata=meta)

import init, { WasmCogViewer } from '@cooljapan/oxigeo';
await init();

const viewer = new WasmCogViewer();
await viewer.open('https://example.com/cog.tif');

const imageData = await viewer.read_tile_as_image_data(0, 0, 0);
ctx.putImageData(imageData, 0, 0);

oxigeo info world.tif
oxigeo convert input.shp output.fgb
oxigeo dem hillshade elevation.tif hillshade.tif --azimuth 315 --altitude 45
oxigeo warp --t-srs EPSG:32654 input.tif output.tif

• Encryption at rest: AES-256-GCM and ChaCha20-Poly1305
• Password hashing: Argon2id
• Transport: TLS 1.3 via rustls (no OpenSSL)
• Authentication: JWT, OAuth2
• Authorization: RBAC and ABAC
• Audit logging: SOC2 and GDPR-ready
• Message integrity: HMAC-SHA256
• All crypto: pure Rust (ring, rustls, aes-gcm, chacha20poly1305, argon2)

• Raft consensus-based cluster coordination
• Automatic failover and leader election
• Distributed partitioning and sharding (oxigeo-distributed)
• Multi-tier cache: in-memory LRU -> on-disk -> Redis (oxigeo-cache-advanced)
• CRDT-based offline sync with Merkle tree verification (oxigeo-sync)

• WMS 1.3.0 tile server
• WFS 2.0.0 feature service
• API gateway with JWT auth and rate limiting

cargo build --all-features
cargo nextest run --all-features
cargo clippy --all-features -- -D warnings
tokei .

See crates/oxigeo-examples/src/ for runnable examples.

See CONTRIBUTING.md for the full guide. Short version — follow COOLJAPAN policies:

1. No unwrap() or expect() in production code
2. Files must stay under 2,000 lines (use splitrs for refactoring)
3. All dependencies via workspace (*.workspace = true)
4. Run cargo clippy --all-features -- -D warnings before submitting
5. Use cargo nextest run --all-features for testing

Licensed under the Apache License, Version 2.0 (LICENSE).

• GDAL Project — original inspiration and reference implementation
• GeoRust Community — ecosystem collaboration
• PROJ — CRS reference and test suite
• Specifications: GeoTIFF, COG, OGC (WMS/WFS), STAC, ISO 19115, RFC 7946

Made with love by COOLJAPAN OU (Team Kitasan)
Pure Rust · Cloud Native · WebAssembly · Production Enterprise