◉ COOLJAPAN
← All posts
February 23, 2026 • 6 min read

OxiGDAL 0.1.0 Released — A Pure Rust GDAL, Built for the Cloud-Native Era

The first public release of OxiGDAL: a 100% Pure Rust reimplementation of GDAL with zero C/C++/Fortran in default features. 11 format drivers (GeoTIFF/COG, GeoParquet, Zarr, NetCDF, HDF5, GRIB, JPEG2000, ...), a Pure Rust PROJ with 211+ EPSG definitions, SIMD raster/vector algorithms, cloud-native async I/O, and WASM + Python bindings — across 68 workspace crates.

release oxigdal gdal geospatial geotiff cog geoparquet proj pure-rust cloud-native

Geospatial computing finally has a home in Pure Rust — no C toolchain, no PROJ/GEOS, no 1 GB Docker images.

Today we released OxiGDAL 0.1.0 — the first public release of a Pure Rust reimplementation of GDAL, built from the ground up for cloud-native geospatial data abstraction.

No C. No C++. No Fortran. No PROJ, no GEOS, no libcurl as a system dependency. No build hell. No “install the right GDAL version and pray the C++ doesn’t segfault.” Just clean, memory-safe, fast geospatial processing that compiles to a single static binary (or a sub-1 MB WASM bundle) and runs everywhere — laptops, browsers, embedded boards, and cloud clusters alike.

Why OxiGDAL 0.1.0 matters

For decades, virtually every serious geospatial workflow has been built on the GDAL C/C++ library. It is extraordinary software — and it comes with a tax: a heavy C/C++ toolchain, PROJ and GEOS system libraries, fragile cross-compilation, manual memory management, thread-unsafe APIs, slow Python bindings, and Docker images that routinely cross a gigabyte.

OxiGDAL takes a different path. This first release already delivers a broad, production-shaped surface — and the numbers from the release itself tell the story:

And on performance, the published 0.1.0 benchmarks are already competitive with — or ahead of — the C incumbents:

Technical Deep Dive: How OxiGDAL is built

The 68 crates are organized into clean, pay-for-what-you-use functional layers.

  1. Core & algorithms (oxigdal-core, oxigdal-proj, oxigdal-algorithms) The core defines the abstract data model — Dataset, RasterDataset, VectorDataset, BoundingBox, GeoTransform — plus async I/O traits and an Arrow-backed GeoBuffer for zero-copy columnar work. oxigdal-proj is a from-scratch Pure Rust PROJ: 20+ projections (UTM 1–60, Web Mercator, Lambert Conformal Conic, Albers, Polar Stereographic, Japan Plane Rectangular I–XIX), a complete WKT2 (ISO 19162:2019) parser with WKT1/ESRI backward compatibility, and Helmert/Molodensky/NTv2/NADCON datum transformations. oxigdal-algorithms brings SIMD raster/vector kernels with feature-gated AVX2, AVX-512, and ARM NEON paths.

  2. Format drivers (11 formats) GeoTIFF/COG (BigTIFF > 4 GB, overviews, HTTP range, DEFLATE/LZW/ZSTD/PackBits/JPEG), GeoJSON (RFC 7946, streaming, GeoArrow), GeoParquet (Arrow-native, predicate pushdown), Zarr v2/v3 (sharding, codec pipeline), FlatGeobuf (packed Hilbert R-tree), Shapefile (SHP/SHX/DBF), NetCDF (CF conventions), HDF5, GRIB1/2, JPEG2000 (wavelet DWT, tier-1), and VRT.

  3. Cloud & storage (oxigdal-cloud, oxigdal-compress) First-class async backends for AWS S3, Google Cloud Storage, and Azure Blob, with HTTP range requests for byte-range COG access and a RangeCoalescer that batches small requests. Compression is Pure Rust throughout via the OxiArc ecosystem (Deflate, LZ4, Zstd, BZip2, LZW, LZH).

  4. Platform & bindings A WebAssembly target (oxigdal-wasm) with a WasmCogViewer JS/TS API under 1 MB gzipped, Python bindings (oxigdal-python, PyO3/Maturin, NumPy returns, manylinux/macOS/Windows wheels), Node.js N-API bindings, a Jupyter kernel, iOS/Android mobile crates, and no_std embedded support.

The Rust advantages run through all of it: guaranteed memory safety, fearless concurrency, trivial cross-compilation, and rich typed Result<T, OxiError> instead of C error codes.

Getting Started

cargo add oxigdal

oxigdal ships with the GeoTIFF, GeoJSON, and Shapefile drivers enabled by default; add features = ["full"] for all eleven.

use oxigdal::Dataset;

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

The same universal opener is available from Python via the PyO3 bindings, with NumPy arrays returned directly from read_geotiff(), read_geoparquet(), and read_zarr().

What’s inside

This is the Independence Release — the goal was a complete, end-to-end geospatial stack, not a thin wrapper. Highlights from the 0.1.0 changelog:

Tips

This is the foundation

OxiGDAL is the geospatial layer of the broader COOLJAPAN Pure Rust ecosystem, and 0.1.0 already builds directly on its siblings: compression rides on OxiArc (oxiarc-deflate, oxiarc-zstd, oxiarc-lz4, …) instead of the zip/flate2 C stack, binary serialization uses OxiCode in place of bincode, numerical pieces lean on SciRS2-Core, and S3-compatible access goes through the RS3GW gateway. The result is a geospatial foundation that is sovereign top to bottom — no hidden C dependency anywhere in the default build.

Repository: https://github.com/cool-japan/oxigdal

Star the repo if you want high-performance geospatial computing without the GDAL toolchain headaches.

The era of “just install GDAL and hope the C++ doesn’t segfault” is ending.

Pure Rust cloud-native geospatial is here — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ February 23, 2026

↑ Back to all posts