◉ COOLJAPAN
← All posts
March 10, 2026 • 8 min read

PandRS 0.2.0 Released — Production-Ready Enterprise DataFrames with ReBAC, Zero-Vuln Defaults, and SciRS2 Integration

A major milestone for the pure Rust DataFrame library — PandRS 0.2.0 delivers all planned v1.0.0 features. Google Zanzibar-style ReBAC authorization, 6,984 unwrap() calls eliminated, a zero-vulnerability default build, optional SQL backends, new SciRS2 0.3.1 stats/linalg integration, 300+ pages of docs, and 24-month LTS. 3-9x faster than pandas with up to 89% less memory.

release pandrs dataframe pandas scirs2 rebac security pure-rust

The DataFrame layer of the COOLJAPAN scientific stack just grew up — and it grew up enterprise.

Today we released PandRS 0.2.0 — a major milestone that takes our pure Rust DataFrame library from a fast pandas alternative to a production-hardened, security-first foundation, delivering all planned v1.0.0 features with the public API now frozen for v1.0.0 compatibility.

No C. No Cython. No pandas/NumPy C-extensions.
No Python GIL. No FFI surprises at deploy time.
Just clean, blazing-fast columnar data that compiles to a single static binary (or WASM) and runs the same on your laptop, in CI, and in production.

Why PandRS 0.2.0 is a game changer

For decades, “data work” in the Python world meant pandas — powerful, ubiquitous, and built on a stack of C/Cython extensions that leak through every abstraction. You get the GIL, fragile installs, silent type coercions, and KeyError surprises in production. And when you need authorization, multi-tenancy, or auditable error handling, you’re entirely on your own.

PandRS 0.2.0 closes that gap. This is the “Major Milestone — Production-Ready Enterprise Features” release, and the wins are concrete:

And it’s still fast: 3-5x faster CSV reading than pandas, 3-4x GroupBy, 4x Join, 8-9x string operations, and up to 89% memory reduction.

Technical Deep Dive: How We Hardened a DataFrame for Production

PandRS 0.2.0 is structured in layers, each carrying its own guarantee.

  1. The production-hardened error model
    The headline engineering effort: 6,984 unwrap() calls removed — 100% from production code paths — and replaced with Result-based error handling throughout. Nothing in a hot path panics on bad input anymore; every fallible operation hands you an error you can match on. This is the difference between a prototype and something you page on.

  2. ReBAC, security, and multi-tenant isolation
    The new Relationship-Based Access Control layer is modeled on Google Zanzibar: you declare hierarchical relationships, the engine resolves transitive permissions, and multi-tenant namespace isolation keeps tenants cleanly separated. An LRU permission cache keeps repeated checks cheap. Authorization lives where the data lives.

  3. The SciRS2 statistics & linalg tier
    New in 0.2.0: an optional dependency on scirs2-core / scirs2-stats / scirs2-linalg 0.3.1, gated behind the scirs2 feature. Enable it and your DataFrames sit directly on the SciRS2 scientific stack — the same stack NumRS2 builds on — bringing advanced statistical routines and linear algebra to your columns without leaving pure Rust.

  4. Feature-flag modularity and a zero-vuln default
    Security-first means optional-by-default. SQL is now disabled unless you ask for it, and database backends are split into granular sql-mysql / sql-postgres / sql-sqlite features. Making MySQL out-of-default mitigates the RSA timing attack (RUSTSEC-2023-0071), and bytes was updated for RUSTSEC-2026-0007. The result: a default build with zero known vulnerabilities, plus curated bundles (stable, test-safe, all-safe) so you opt into exactly what you need.

This release is large and thoroughly tested: 233,963 lines of Rust (186,042 code) across 635 files, 999 lib tests plus ~155 integration tests and 144 doc tests all passing with --all-features, 95%+ coverage, zero clippy warnings (-D warnings), and CI green on Linux, macOS, and Windows.

Getting Started

Install it:

cargo add pandrs

A first taste — note the production-grade error handling:

use pandrs::{DataFrame, Series};

fn main() -> pandrs::error::Result<()> {
    let mut df = DataFrame::new();
    df.add_column(
        "city".to_string(),
        Series::from_vec(vec!["Tokyo", "Osaka", "Kyoto"], Some("city")),
    )?;
    df.add_column(
        "population".to_string(),
        Series::from_vec(vec![13_960_000, 2_750_000, 1_460_000], Some("population")),
    )?;

    // Production-grade error handling — no panics, just Results
    let big = df.filter("population > 2000000")?;
    let total: f64 = df.column("population")?.sum()?;
    println!("{} large cities, total population {}", big.shape().0, total);
    Ok(())
}

Want the new SciRS2 statistics and linear algebra integration? Enable the feature:

cargo add pandrs --features scirs2

There are 118 production-ready example files to crib from, and 300+ pages of documentation — a ~148-page User Guide, a ~105-page pandas Migration Guide, an Enterprise Support Guide, and an LTS Policy — with 95%+ rustdoc coverage.

What’s New in 0.2.0

Tips

This is the foundation

PandRS is the DataFrame layer of the COOLJAPAN scientific computing stack — and as of 0.2.0 it’s wired directly into SciRS2 0.3.1, sitting alongside NumRS2 in the same pure Rust scientific ecosystem:

Tabular data, statistics, and numerics — all sovereign, all panic-free in production, all one cargo add away.

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

Star the repo if you want production-grade DataFrames without pandas’ C/Cython baggage, the Python GIL, or surprise panics in production.

The era of “just pip install pandas” — with all its native dependencies and silent failures — is ending.

Pure Rust data engineering is here — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ March 10, 2026

↑ Back to all posts