OxiGeo

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.

_{Mj7.1 Kumamoto earthquake, 28 July 2026, 16:27 JST. Five consecutive Sentinel-2 L2A passes over Mt Mayuyama, above Shimabara, at 10 m: unbroken forest a year earlier, cloud over the site on every pass in the fortnight before the quake, then the slope reappearing the next morning already scarred, and clearing completely six days later. Change detection against the 2025 scene — same season, so vegetation phenology cancels — at NDVI drop ≥ 0.15 and a 0.5 ha minimum patch finds 168.8 ha across 85 patches over the full preset area of interest, the largest being this 52 ha bare-ground scar; the animation is a crop holding 114 ha of that. What the pictures can and cannot say: the scar is absent on 2025-07-29 and present ~19 hours after the earthquake, but every 2026 pre-event pass was overcast over the site (2.5%, 12.1% and 0.0% clear on 07-14, 07-21 and 07-24), so imagery alone dates the failure only to that 12-month interval. Note too where this method does not look — the epicentral damage in Kumamoto Prefecture itself, collapsed buildings, bridge failures, liquefaction and fires, leaves no NDVI signature at all. Every step, from the STAC search to the polygon areas, runs in the browser in Pure-Rust WebAssembly, and it is the first preset in the live demo. Run it yourself}

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. The current release is v0.2.3, which implements real Warped VRT support — reading and resampling <GDALWarpOptions> VRTs such as gdalwarp -of VRT output (issue #15) — and a public vector-layer API, Dataset::layers()/Layer::features() for GeoPackage/Shapefile/GeoJSON (issue #16). It builds on v0.2.2's issue #14 correctness campaign (2026-07-30), v0.2.1's production-hardening pass (2026-07-28), and v0.2.0, published to crates.io on 2026-07-20 as the first release under the OxiGeo name — a rename-only release, functionally identical to v0.1.7, which was published the same day as the final release under the OxiGDAL name (v0.1.6 released 2026-06-15). The library delivers ~797K Rust SLoC across 75 workspace crates, covering 16 geospatial format drivers exposed through oxigeo::Dataset::open() (plus separate KML/KMZ and TopoJSON format support in dedicated crates, see 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.

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

  Additional format support (dedicated crates, not part of the
  `Dataset::open()` driver registry above, so not counted in the 16):
  drivers-adv  KML/KMZ       Read + write (oxigeo-drivers-advanced)
  geojson-s    TopoJSON      Writer only: arcs, quantization (oxigeo-geojson streaming module)

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 (RETIRED in 0.2.1)
  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

Additional, separately-shipped format support not listed above (not part of the oxigeo::Dataset::open() driver registry, so not counted in the 16): KML/KMZ read+write (oxigeo-drivers-advanced) and a TopoJSON writer (oxigeo-geojson streaming module).

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::Dataset;

// GeoPackage needs the (non-default) `gpkg` feature; .shp and .geojson are on
// by default.
let dataset = Dataset::open("cities.gpkg")?;
println!("layers  : {}", dataset.layer_count());

let layer = dataset.layer(0)?;                  // or .layer_by_name("cities")
println!("{} ({:?}), {:?} features, fields {:?}",
         layer.name(), layer.geometry_type(), layer.feature_count(),
         layer.field_names());

for feature in layer.features()? {
    // feature.geometry: Option<oxigeo::Geometry>
    // feature.properties: HashMap<String, oxigeo::FieldValue>
    println!("{:?} — {:?}", feature.geometry, feature.properties);
}

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

oxigeo-kafka (Apache Kafka integration) was retired in 0.2.1 and will receive no further releases. It was the only crate in the workspace that made a C toolchain mandatory — rdkafka-sys builds librdkafka through cmake — which stands against the COOLJAPAN Pure Rust Policy, and it had no consumers anywhere inside the workspace. With it removed, cargo check --workspace --all-features no longer needs cmake. The kafka features of oxigeo-etl and oxigeo-workflow were removed at the same time. For messaging, use oxigeo-streaming, oxigeo-kinesis, oxigeo-pubsub, or oxigeo-mqtt; to talk to Kafka specifically, use a Kafka client directly in your own code. Workflow definitions can still describe Kafka endpoints via the pure-Rust IntegrationType::Kafka / MessageQueueType::Kafka metadata enums in oxigeo-workflow.

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