◉ COOLJAPAN
← All posts
January 21, 2026 • 7 min read

Legalis-RS 0.1.3 Released — 18 Jurisdictions, One Pure Rust Engine

Legalis-RS 0.1.3 doubles jurisdiction coverage from 8 to 18 — adding the UAE, Australia, Brazil, Canada, China, India, Indonesia, Laos, Thailand, Vietnam and South Africa — across 41 crates, 863,282 lines and 13,083 passing tests.

release legalis legal-tech rust legal-dx jurisdictions comparative-law

Eighteen legal systems now reason on a single Pure Rust engine — no per-country forks, no bespoke runtimes.

Today we released Legalis-RS 0.1.3 — doubling jurisdiction coverage from 8 to 18 by adding 11 new legal systems, all running on the same Pure-Rust engine.

No C. No C++. No Fortran. No JVM. Where the rest of legal-tech leans on closed legal SaaS, on Java/Python stacks, or pulls in the Z3 SMT solver (C++) to do anything formal, Legalis-RS ships as a single static binary — or compiles to WASM. Even the optional formal proofs are Pure Rust: the verifier’s SMT engine is OxiZ, the COOLJAPAN Z3 alternative, so there is nothing native to install. Legalis-RS parses, analyzes, and simulates statutes — Legal DX — by cleanly separating Deterministic Logic from Judicial Discretion, and it does so without dragging a single line of C into your build.

Why 0.1.3 is a milestone

Legal-tech tooling is almost always single-jurisdiction. You buy a product locked to one country’s vendor, and the moment you need to compare a rule across borders, you re-implement everything from scratch in a different stack with a different model. Cross-border reasoning becomes a re-write, not a query.

0.1.3 attacks that head-on. The 11 new jurisdictions span the major legal families — common-law (Australia, Canada, India, South Africa), civil-law (Brazil, China, Indonesia, Laos, Thailand, Vietnam), and Gulf/mixed (the UAE) — and every one of them is expressed in the same Statute, Condition, and Effect types. One engine now reasons across 18 legal systems.

Concretely:

The key design decision is that jurisdictions are data plus thin crates over a generic core — not bespoke per-country engines. Every legalis-<cc> crate supplies statutes, conditions, and effects built from the generic legalis-core types. There is no separate interpreter for India versus Brazil versus the UAE; there is one engine, and eighteen catalogues of rules feeding it.

That is what makes the verifier and the simulator work unchanged across all of them. legalis-verifier (optionally OxiZ-backed via the smt-solver feature) checks a rule the same way whether it came from legalis-in or legalis-au. legalis-sim runs a synthetic population against any jurisdiction’s statutes without knowing which country it is. The 11 new crates added in 0.1.3 are:

These sit on top of the architecture from earlier releases: the Core layer (legalis-core, the DSL, and the registry); the Intelligence layer (legalis-llm plus legalis-verifier); the Simulation layer (legalis-sim, legalis-diff); the i18n/porting, interop, and viz/chain/lod tooling; the audit/api surface; and the legalis CLI. The jurisdictions plug in; the engine stays the same.

Getting Started

Add the core library:

cargo add legalis-core

The CLI binary is legalis. To bring in a specific jurisdiction, add its crate — for example, India:

cargo add legalis-in

Build a rule once and it runs anywhere:

use legalis_core::{Statute, Condition, Effect, EffectType, ComparisonOp};

// the SAME engine now backs 18 jurisdictions — build a rule once, verify it anywhere
let statute = Statute::new(
    "data-transfer",
    "Cross-Border Data Transfer Rule",
    Effect::new(EffectType::Grant, "Transfer permitted"),
)
.with_precondition(Condition::Age {
    operator: ComparisonOp::GreaterOrEqual,
    value: 18,
});

And verify it, optionally with OxiZ-backed proofs:

use legalis_verifier::StatuteVerifier;

let verifier = StatuteVerifier::new();
let result = verifier.verify(&statutes); // optional `smt-solver` feature → OxiZ-backed proofs

What’s New in 0.1.3

11 new jurisdictions (jurisdictions 8 → 18):

Changed:

Fixed:

Statistics:

Tips

Part of the COOLJAPAN ecosystem

Legalis-RS rides the COOLJAPAN Pure-Rust stack. Its optional SMT proofs use OxiZ — the Pure-Rust Z3 alternative — and it sits alongside siblings such as SciRS2, NumRS2, OxiBLAS, OxiFFT, and Oxicode. Same philosophy throughout: fast, safe, and free of native dependencies by default.

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

Star the repo if a Pure Rust engine reasoning across 18 legal systems is the kind of legal infrastructure you want to see.

Eighteen legal systems, one Pure Rust engine — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ January 21, 2026

↑ Back to all posts