The Architecture of Generative Jurisprudence

Governance as Code, Justice as Narrative

Legalis-RS is a Rust framework for parsing, analyzing, and simulating legal statutes across multiple jurisdictions. It transforms natural language legal documents into structured, machine-verifiable code while preserving the essential distinction between:

• Deterministic Logic (Code): Computationally derivable legal outcomes (age requirements, income thresholds, deadlines)
• Judicial Discretion (Narrative): Areas requiring human interpretation and judgment

This separation is the philosophical core of Legalis-RS - it explicitly marks where AI-assisted legal processing must yield to human judgment, serving as a safeguard against algorithmic overreach in legal systems.

🌍 Global Coverage: 23 operational jurisdictions spanning Civil Law, Common Law, Socialist, Islamic Law, and Supranational legal traditions:

• 🇦🇪 UAE - Civil Law + Islamic Law (Federal Law, Commercial, Labor, PDPL, Free Zones - DIFC/ADGM)
• 🇦🇺 Australia - Common Law + Statutory (Torrens system, Fair Work Act, Consumer Law, Privacy, Immigration)
• 🇧🇷 Brazil - Civil Law (Código Civil, CDC, LGPD, CLT, Tax Law - ISR/IVA/IEPS)
• 🇨🇦 Canada - Common Law + Civil Law (Quebec) (Charter of Rights, Aboriginal rights, Federal-provincial)
• 🇨🇳 China - Socialist Civil Law (民法典 7 Books, Data Security Law, Foreign Investment Law, Anti-Monopoly Law)
• 🇩🇪 Germany - Civil Law (BGB, GmbHG, HGB, Grundgesetz)
• 🇪🇺 European Union - Supranational Law (GDPR, Competition Law, Treaties, 11 languages)
• 🇫🇷 France - Civil Law (Code civil, Code du travail, 35-hour work week)
• 🇮🇩 Indonesia - Civil Law (Civil Code, UU Cipta Kerja Omnibus Law, Investment, Labor, Tax)
• 🇮🇳 India - Common Law + Statutory (Constitution, BNS/BNSS/BSA, DPDP, Companies Act, IBC)
• 🇯🇵 Japan - Civil Law + Asian Tradition (Minpō, Labor, IP Law, e-Gov integration, 16+ domains)
• 🇰🇷 South Korea - Civil Law (민법, 근로기준법, 개인정보 보호법, Commercial Code, Fair Trade Act)
• 🇱🇦 Lao PDR (Laos) - Civil Law + Socialist Tradition (Civil Code 2020, Japanese/French influences, ODA)
• 🇲🇽 Mexico - Civil Law (Código Civil Federal, LFT, LFPDPPP, Tax Law - ISR/IVA/IEPS)
• 🇲🇾 Malaysia - Common Law + Islamic Law (Federal Constitution, Companies Act, PDPA, Islamic Family Law)
• 🇷🇺 Russia - Civil Law (Гражданский кодекс 4 Parts, Tax Code, Labor Code, 152-FZ Data Protection)
• 🇸🇦 Saudi Arabia - Islamic Law + Civil Law (Basic Law, Sharia, Companies Law 2015, PDPL 2021)
• 🇸🇬 Singapore - Common Law + Statutory (Companies, Employment, PDPA, Banking, Payment Services)
• 🇹🇭 Thailand - Civil Law (Civil & Commercial Code 6 Books, Labor Law, BOI, Tax Law)
• 🇬🇧 United Kingdom - Common Law (Employment Rights, Consumer Rights, Financial Services)
• 🇺🇸 United States - Common Law (Restatement of Torts, 51 jurisdictions, Choice of Law)
• 🇻🇳 Vietnam - Socialist Civil Law (Civil Code 91/2015, Cybersecurity Law, Competition Law)
• 🇿🇦 South Africa - Mixed Law (Constitution 1996, Companies Act, LRA/BCEA, POPIA, Customary Law)

Total: 1,553 jurisdiction files (~383k jurisdiction LoC), 74 workspace crates (16 core + 23 jurisdictions + 35 examples), 18,398 tests passing with comprehensive coverage across all jurisdictions.

"Not everything should be computable."

The LegalResult<T> type embodies this principle:

pub enum LegalResult<T> {
    Deterministic(T),           // Automated processing possible
    JudicialDiscretion { ... }, // Human judgment required
    Void { reason: String },    // Logical inconsistency detected
}

legalis-rs/
├── crates/
│   ├── # Core Layer
│   ├── legalis-core/      # Core types, traits, state management
│   ├── legalis-dsl/       # Domain Specific Language parser
│   ├── legalis-registry/  # Statute registry with version control
│   ├── # Intelligence Layer
│   ├── legalis-llm/       # LLM integration (OpenAI, Anthropic, etc.)
│   ├── legalis-verifier/  # Formal verification (SMT solver)
│   ├── # Simulation & Analysis Layer
│   ├── legalis-sim/       # Simulation engine (ECS-like)
│   ├── legalis-diff/      # Statute diffing and change detection
│   ├── # Internationalization & Porting Layer
│   ├── legalis-i18n/      # Multi-language/jurisdiction support
│   ├── legalis-porting/   # Cross-jurisdiction law transfer
│   ├── # Interoperability Layer
│   ├── legalis-interop/   # Import/export: Catala, Stipula, L4 formats
│   ├── # Output Layer
│   ├── legalis-viz/       # Visualization (decision trees, flowcharts)
│   ├── legalis-chain/     # Smart contract export (Solidity, WASM, Ink!)
│   ├── legalis-lod/       # Linked Open Data (RDF/TTL) export
│   ├── # Infrastructure Layer
│   ├── legalis-audit/     # Audit trail and decision logging
│   ├── legalis-api/       # REST API server
│   └── legalis/           # Command-line interface
├── jurisdictions/
│   ├── ae/                # UAE: Federal Law, Commercial, Labor, PDPL, Free Zones
│   ├── au/                # Australia: Torrens, Fair Work, Consumer, Privacy, Immigration
│   ├── br/                # Brazil: Civil Code, Consumer, LGPD, CLT Labor
│   ├── ca/                # Canada: Charter, Aboriginal rights, Federal-provincial
│   ├── cn/                # China: Civil Code, Contract, Corporate, Data Protection
│   ├── de/                # Germany: BGB, GmbHG, HGB, Grundgesetz
│   ├── eu/                # EU: GDPR (11 languages), Competition, Treaties
│   ├── fr/                # France: Code civil, Code du travail (35h week)
│   ├── id/                # Indonesia: Civil Code, Investment, Labor, Tax
│   ├── in/                # India: Constitution, IPC/BNS, DPDP, Consumer, Corporate
│   ├── jp/                # Japan: Minpō, e-Gov, APPI, 16+ domains
│   ├── la/                # Lao PDR: Civil Code 2020, Japanese/French influences
│   ├── sg/                # Singapore: Banking, Payments, PDPA, CPF
│   ├── th/                # Thailand: Civil Code, Labor, Investment, Data Protection
│   ├── uk/                # UK: Employment, Consumer, Financial Services
│   ├── us/                # USA: Restatement, 51 jurisdictions, Choice of Law
│   ├── vn/                # Vietnam: Civil Code, Investment, Labor, Cybersecurity
│   └── za/                # South Africa: Companies Act, LRA/BCEA, POPIA, BBBEE
├── examples/
│   ├── jp-constitution-3d/ # 3D visualization of Japanese Constitution
│   └── welfare-benefits/   # Welfare benefits eligibility system
├── legalis.md             # Full specification document
├── Cargo.toml             # Workspace configuration
└── README.md

Project Scale (v0.1.6):

Testing Infrastructure:

• Unit Tests: 18,398 passing (cargo nextest, 2 skipped)
• Integration Tests: 22+ test files
• Benchmark Suites: 13 Criterion benchmarks
• Property-Based Tests: 10+ tests across multiple crates
• Fuzzing Targets: 3 libFuzzer-based fuzz targets
• Doc Tests: 343 passing

Edition: Rust 2024 | MSRV: 1.86

All 74 workspace crates (16 core + 23 jurisdictions + 35 examples) compile cleanly with NO WARNINGS - strict quality policy enforced.

Legalis-RS now includes comprehensive support for 23 major jurisdictions (all fully implemented):

Total: 1,553 jurisdiction files (~383k jurisdiction LoC), 74 workspace crates (16 core + 23 jurisdictions + 35 examples), comprehensive test coverage across all 23 jurisdictions

The following 6 examples (4,488 lines total) demonstrate that Legalis-RS is NOT country-specific code - it is a universal legal computation platform that handles ANY legal system with the SAME engine:

Total Implementation: 4,488 lines (1,851 Rust + 1,752 Markdown + 116 JSON + 203 sample data)

Quality Metrics:

• ✅ Clippy warnings: 0
• ✅ All tests passing
• ✅ No warnings policy: 100% compliant
• ✅ Implementation time: 17 hours (12h initial + 3h polish + 2h generalization)

Achievement Unlocked: "Individual Logic" → "Universal Engine"

Market Impact:

• Before: "Japanese law parser" (niche market, ~¥100M)
• After: "Universal Legal Computation Platform" (global market, ¥兆円規模)
• Evidence: Same engine processes Civil Law (JP/DE), Common Law (US), Supranational (EU)
• Scalability: Adding jurisdiction #19 requires ~0.1% new code (vs traditional: +100% new codebase)

Key Insight:

Traditional Legal Tech: Country-specific code (each jurisdiction = separate system)
Legalis-RS:            Generic engine + data files (one engine for all jurisdictions)

Comparison with Traditional SIer Approach:

This is the proof that Legalis-RS has transcended from "niche tool" to "universal platform".

• Rust 1.85+ (Edition 2024)
• Cargo

# Clone the repository
git clone https://github.com/cool-japan/legalis
cd legalis

# Build all crates (default features: includes REST + gRPC APIs)
cargo build

# Build without gRPC (minimal dependencies)
cargo build --no-default-features

# Run tests
cargo test

# Check for issues
cargo clippy

The legalis-verifier crate has an optional smt-solver feature for rigorous formal verification using OxiZ (Pure Rust SMT solver):

# Build with SMT solver (Pure Rust - no external dependencies)
cargo build --features smt-solver

# Build with all features
cargo build --all-features

# Run tests with all features
cargo nextest run --all-features

Note: OxiZ is a Pure Rust SMT solver, so no external libraries or environment variables are needed!

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

// Parse a statute from DSL
let parser = LegalDslParser::new();
let statute = parser.parse_statute(r#"
    STATUTE adult-rights: "Adult Rights Act" {
        WHEN AGE >= 18
        THEN GRANT "Full legal capacity"
    }
"#)?;

// Or build programmatically
let statute = Statute::new(
    "voting-rights",
    "Voting Rights Act",
    Effect::new(EffectType::Grant, "Right to vote in elections"),
)
.with_precondition(Condition::Age {
    operator: ComparisonOp::GreaterOrEqual,
    value: 18,
});

use legalis_sim::{SimEngine, PopulationBuilder};

// Create a test population
let population = PopulationBuilder::new()
    .generate_random(1000)
    .build();

// Run simulation
let engine = SimEngine::new(vec![statute], population);
let metrics = engine.run_simulation().await;

println!("{}", metrics.summary());

use legalis_verifier::StatuteVerifier;

let verifier = StatuteVerifier::new();
let result = verifier.verify(&statutes);

if !result.passed {
    for error in result.errors {
        eprintln!("Verification error: {}", error);
    }
}

Transform complex municipal ordinances into decision trees, highlighting ambiguous "gray zones" requiring human interpretation.

Detect logical contradictions in draft legislation before enactment - treating legal bugs as compile errors.

Port legal frameworks across jurisdictions while adapting to local cultural parameters.

Automate Deterministic cases (small claims, administrative procedures) while routing JudicialDiscretion cases to human judges.

Legalis-RS provides pluggable LLM support through the LLMProvider trait:

use legalis_llm::{OpenAiClient, AnthropicClient, LawCompiler};

// Use OpenAI
let client = OpenAiClient::new("your-api-key", "gpt-4");
let compiler = LawCompiler::new(client);
let statute = compiler.compile("Any person aged 18 or older may vote.").await?;

// Or Anthropic
let client = AnthropicClient::new("your-api-key", "claude-3-opus");

Generate blockchain-deployable contracts from verified statutes:

use legalis_chain::{ContractGenerator, TargetPlatform};

let generator = ContractGenerator::new(TargetPlatform::Solidity);
let contract = generator.generate(&statute)?;

println!("{}", contract.source);

Legalis-RS can import from and export to other legal DSL formats:

use legalis_interop::{LegalConverter, LegalFormat};

let converter = LegalConverter::new();

// Auto-detect and import from Catala
let catala_source = r#"
declaration scope AdultRights:
  context input content integer
"#;
let (statutes, report) = converter.auto_import(catala_source)?;

// Export to L4 format
let (l4_output, _) = converter.export(&statutes, LegalFormat::L4)?;

// Direct format conversion
let (stipula_output, _) = converter.convert(
    catala_source,
    LegalFormat::Catala,
    LegalFormat::Stipula
)?;

Export statutes to RDF/TTL format for semantic web integration:

use legalis_lod::LodExporter;

let exporter = LodExporter::new();
let ttl_output = exporter.export_to_turtle(&statutes)?;

// Or export to RDF/XML
let rdf_output = exporter.export_to_rdf_xml(&statutes)?;

This enables integration with knowledge graphs and semantic web systems, allowing legal data to be linked with other open data sources.

1. No External Orchestrator Dependency: Uses Rust's native async (Tokio) instead of external task queues
2. Vendor-Agnostic LLM Layer: Trait-based abstraction allows swapping providers without code changes
3. Explicit Discretion Markers: The type system enforces acknowledgment of human judgment requirements
4. SMT Solver Integration: Uses OxiZ (Pure Rust) for formal verification of legal consistency
   • Achieved: 100% Pure Rust implementation with no external C/C++ dependencies
5. Object Storage: S3-compatible storage support for audit trails
   • Note: MinIO can be replaced with rs3gw (Pure Rust S3-compatible gateway) from the COOLJAPAN Ecosystem

• v0.1.6 (June 16, 2026) - CUDA GPU acceleration, legalis-api security/governance layer, legalis-audit new modules (autonomous, federation, quantum, scale, tenant), OxiSQL migration (pure Rust), DSL round-trip improvements, French law enhancements
• v0.1.5 (February 2026) - Pure-Rust PDF Backend (fop-render), Full Code Splitting (2,221 Rust files), No-Unwrap Policy, Workspace Versioning, CVE Remediation
• v0.1.4 (January 27, 2026) - Universal Engine Proof: 6 new examples proving Legalis-RS is a generic legal computation platform (not country-specific code)
• v0.1.3 (January 21, 2026) - Global Expansion: 11 new jurisdictions (AE, AU, BR, CN, ID, IN, TH, VN, ZA + more)
• v0.1.2 (January 15, 2026) - Code Quality: Clippy Compliance
• v0.1.1 (January 10, 2026) - Jurisdiction Expansion: EU, Singapore, UK
• v0.1.0 (January 5, 2026) - Genesis: Initial release

Detailed technical papers are available in multiple languages:

These papers provide comprehensive coverage of the system architecture, core technologies, design philosophy, and case studies.

Legalis is developed and maintained by COOLJAPAN OU (Team Kitasan).

If you find Legalis useful, please consider sponsoring the project to support continued development of the Pure Rust ecosystem.

https://github.com/sponsors/cool-japan

Your sponsorship helps us:

• Maintain and improve the COOLJAPAN ecosystem
• Keep the entire ecosystem (OxiBLAS, OxiFFT, SciRS2, etc.) 100% Pure Rust
• Provide long-term support and security updates

Licensed under the Apache License, Version 2.0 (LICENSE or http://www.apache.org/licenses/LICENSE-2.0).

Contributions are welcome! Please read the contribution guidelines before submitting pull requests.

This project draws inspiration from legal informatics research and the growing field of computational law. The goal is not to replace human judgment in law, but to clarify where such judgment is necessary.

"Code is Law" - but Law must preserve space for human narrative.