Why Janus?

Janus is a systems programming language designed for AI-human collaboration. It combines Python-simple syntax with native LLVM compilation and AI-queryable semantics.

Status: v2026.3.8 — :core + :service profiles complete.

The Dual Interface

Most languages were designed before AI coding assistants existed. They have one interface: human-readable text.

Janus has two interfaces:

Human Interface: Clean, teaching-friendly syntax (like Python)
Machine Interface: Queryable semantic database (like nothing else)

Why AI Agents Love Janus

Code is a Database (ASTDB)

Traditional languages: AI sees text.

def foo(x):
    return x + 1

Janus: AI sees queryable semantic data.

SELECT function_name, parameter_types, return_type
FROM declarations
WHERE allocates_memory = true

Stable Identity (The Atom)

Every declaration has a permanent UUID:

Rename a function? UUID stays the same
AI tracks dependencies across refactors
“Find all callers” = database query, not regex

Explicit Everything

func process(allocator: Allocator, data: []u8) !Result do
    // AI can see:
    // - Takes allocator (memory effect visible)
    // - Can fail (! = error union)
    // - Data is a slice (no hidden copies)
end

Profile System (Capability Contracts)

:core      // AI knows: single-threaded, deterministic
:service   // AI knows: channels, nurseries, async
:cluster   // AI knows: actors, message-passing
:sovereign // AI knows: raw pointers, unsafe

AI can verify code fits the profile before compilation.

Why Humans Love Janus

Simple, Honest Syntax

func fibonacci(n: i64) !i64 do
    if n < 0 do fail DomainError end
    if n <= 1 do return n end

    let a = fibonacci(n - 1)?
    let b = fibonacci(n - 2)?
    return a + b
end

Reads like Python. Compiles like C. Performs like Rust.

Zero-Cost Zig Integration

use zig "std/ArrayList"
use zig "std/json"

// Instant access to industrial-grade tools
var list = zig.ArrayList(i64).init(allocator)

No FFI overhead. Just works.

Progressive Disclosure

Start simple:

func hello() do
    println("Hello, World!")
end

Scale to production:

func processStream(ctx: Context, stream: AsyncStream) !void do
    using ctx.region do
        let buffer = Buffer.with(ctx.allocator)
        // Sophisticated, but still readable
    end
end

Comparison

Feature	Janus	Python	Rust	Go
Queryable AST	ASTDB	Text	Limited	Text
Stable IDs	UUID	Location	Location	Location
Explicit Effects	Profiles	Hidden	Partial	Hidden
Type System	Static	Dynamic	Static	Static
Memory Model	Explicit	GC	Borrow checker	GC
Performance	Native	Slow	Native	Native
Human Readable	Simple	Simple	Complex	Simple
Structured Concurrency	Nurseries	No	Unstructured	Goroutines leak

Current Status

v2026.3.8 — Production Ready

1,376+ tests passing (99.8% coverage)
265/275 build steps green
:core profile: 100% complete
:service profile: 100% complete — Go parity achieved

What Works Today

Functions, variables, type inference
Control flow: if/else, for, while, match
Error handling: !T, fail, catch, try/?
Traits, impl blocks, static + dynamic dispatch
Generics with monomorphization
Multi-dispatch (Julia-style, unique to Janus)
Structured concurrency: nurseries, channels, select, spawn
Closures (3 capture types)
Zero-cost Zig stdlib integration
Native LLVM compilation

Next Steps

[Quick Start Guide]/learn/getting-started/ — Write your first Janus program
[Profiles System]/learn/profiles/ — Understand capability sets