Write Python, JavaScript, Rust, C++ and 8 more languages in a single file. Ship with confidence — NAAb's governance engine catches hallucinated APIs, incomplete logic, and oversimplified stubs before they reach production.
Use each language where it shines. Variables flow between languages automatically — no FFI, no serialization, no microservices.
main { let numbers = [10, 20, 30, 40, 50] // Python: statistical analysis let stats = <<python[numbers] import statistics mean = statistics.mean(numbers) stdev = statistics.stdev(numbers) f"mean={mean}, stdev={stdev:.1f}" >> // Rust: high-performance hashing let hash = <<rust fn main() { let input = std::env::args().last() .unwrap(); println!("{:x}", md5::compute( input.as_bytes() )); } >> print(stats) print(hash) }
$ naab-lang app.naab mean=30, stdev=15.8 a7b9f3e2d1c4... ─────────────────────── 2 polyglot blocks executed python ............ 42ms rust ............ 18ms
Modern language features, a rich standard library, and developer tools that make polyglot programming productive.
Expressive match expressions with exhaustive checking, wildcard patterns, and value binding.
Non-blocking concurrent execution with async functions and await for I/O-bound operations.
First-class functions with closure capture. Pass functions as values, return them, store them in data structures.
Chain operations with |> for readable data transformation pipelines. Left-to-right composition.
Import/export with named imports, wildcard imports, and aliasing. Organize code across multiple files.
try/catch/throw with polyglot error propagation. Errors from Python or JavaScript blocks flow into NAAb's catch.
Pass variables into polyglot blocks with <<python[x, y]. Automatic serialization across language boundaries.
Independent polyglot blocks run in parallel automatically. Dependency analysis ensures correct ordering.
"Did you mean?" suggestions for typos, detailed error messages with examples, and common mistake detection.
Drop a govern.json in your project. NAAb checks every polyglot block against your policies before execution.
{
"version": "3.0",
"mode": "enforce",
"languages": {
"allowed": ["python", "javascript"]
},
"code_quality": {
"no_secrets": { "level": "hard" },
"no_sql_injection": { "level": "hard" },
"no_oversimplification": { "level": "hard" },
"no_incomplete_logic": { "level": "soft" },
"no_hallucinated_apis": { "level": "soft" }
}
}
$ naab-lang app.naab Error: Hallucinated API in python block: ".push()" SOFT Rule: code_quality.no_hallucinated_apis Help: .push() is JavaScript In Python, use .append() To override: --governance-override
Catches .push() in Python, print() in JS, json.stringify() instead of json.dumps() — with "did you mean?" corrections for 86+ patterns across Python and JavaScript.
Detects stub functions, pass-only bodies, validate() that always returns True, identity functions, NotImplementedError, and fabricated status responses. 35+ patterns.
Catches except:pass, bare raises, vague error messages like "something went wrong", degenerate loops, and always-true/false conditions. 40+ patterns.
SQL injection, path traversal, shell injection, privilege escalation, unsafe deserialization, data exfiltration, and entropy-based secret detection.
Placeholders (TODO/FIXME), dead code, debug artifacts, simulation markers, mock data, apologetic language, hardcoded URLs/IPs, and PII detection.
Export governance results as SARIF for GitHub Code Scanning, JUnit XML for Jenkins/GitLab CI, or JSON for custom tooling. Three enforcement levels: HARD, SOFT, ADVISORY.
A comprehensive standard library with 204 error messages, "Did you mean?" suggestions, and detailed documentation.
15,000+ lines of modern C++17. Recursive descent parser, AST visitor pattern interpreter, and isolated polyglot executors.
Embedded via C API. In-process execution with variable injection.
Embedded QuickJS engine. Isolated runtime with fast startup.
Rust, C++, Go, C#, Nim, Zig compile to native binaries. Julia JIT-compiled. Thread-safe temp files.
Enterprise LLM & AI Governance Platform — 100% NAAb, best language for every task
Polyglot Code Evolution & Optimization Platform — 3-60x speedups with proven correctness
Sovereign Data Gateway & PII Protection — Zero leakage with mathematical certainty
NAAb is open source, MIT licensed, and ready for your next project.