JANUS

A systems programming language that combines teaching simplicity with production power.

Status: Alpha -- in heavy development. Breaking changes expected.

Version: 2026.3.31

License: Libertaria Suite (LCL-1.0 / LSL-1.0 / LUL-1.0)

Repository: https://git.sovereign-society.org/janus/janus-lang

New here? Quickstart | What Works | Stdlib Guide

---

What Is Janus?

Janus is a systems language that compiles natively through Zig and LLVM. It uses a profile system for progressive disclosure -- you start with simple fundamentals (:core) and unlock concurrency, distributed systems, and hardware control as you advance.

The key idea: code you write on day one compiles to a native binary. No interpreter, no VM, no rewrites later.

func main() do
    println("Hello, Janus!")
end

---

Why Janus Over Go?

Go popularized goroutines and channels. Janus takes the same model and fixes what Go got wrong:

Concern	Go	Janus
Goroutine leaks	Common, silent, hard to debug	Impossible -- nurseries enforce structured concurrency
Error handling	if err != nil boilerplate everywhere	!T error unions, fail, catch, ? propagation
Memory	GC pauses, unpredictable latency	Explicit allocators, zero GC, deterministic cleanup
Hidden costs	Runtime scheduler, GC, reflection -- all invisible	All costs visible -- Syntactic Honesty doctrine
Generics	Arrived late, limited	First-class monomorphization from day one
Pattern matching	None	Exhaustive match with compile-time coverage checks
Zig stdlib	N/A	Full access via use zig -- zero FFI overhead
FFI	cgo is slow and awkward	graft c / graft zig -- native integration

---

Profile System

Profile	Status	Scope
:core	Functionally complete	Types, control flow, structs, enums, generics, error handling, match, defer
:service	Functionally complete	Channels, select, nursery, spawn, structured concurrency, row polymorphism
:sovereign	WIP	Capabilities, pledges, distributed identity, hardware declarations
:compute	Planned	GPU/NPU kernels, tensor IR, data-parallel computation

:core and :service pass their test suites and cover the language features listed above. They are not yet battle-tested in production deployments. Expect rough edges.

---

Language Features

Core Language

• Functions, closures, multi-function programs
• let / var / const with type inference
• Control flow: if/else, while, for..in
• match with exhaustiveness checking, else fallback, .Variant patterns
• Error handling: !T error unions, fail, catch, ? postfix propagation
• Structs with ..defaults initialization, enums, arrays, slices, optionals
• Generics with monomorphization (func identity[T](x: T) -> T)
• defer for deterministic cleanup
• graft c / graft zig for foreign function integration

Structured Concurrency (:service)

• Nurseries -- structured concurrency boundaries
• Spawn -- launch tasks within nursery scope
• Channels -- CSP-style buffered/unbuffered message passing
• Select -- multi-channel wait with timeout and default cases

Code Examples

// Error handling
error DivisionError { DivisionByZero }

func divide(a: i64, b: i64) !i64 do
    if b == 0 do
        fail DivisionByZero
    end
    return a / b
end

func main() do
    let result = divide(10, 0) catch |err| do
        println("Caught: division by zero")
        0
    end
    println(result)
end

// Structured concurrency
func main() do
    nursery do
        spawn worker(1)
        spawn worker(2)
        spawn worker(3)
    end
    println("All workers done")
end

func worker(id: i64) do
    println("Worker running")
end

---

Quick Start

Requirements: Zig 0.16.x, Linux x86_64

git clone https://git.sovereign-society.org/janus/janus-lang.git
cd janus-lang
zig build

./zig-out/bin/janus build examples/hello.jan
./hello

Important: Use ./scripts/zb instead of raw zig build test for the full test suite -- it throttles parallelism to prevent OOM on LLVM-linked tests.

---

Compilation Pipeline

Source (.jan) -> Parser -> ASTDB -> Semantic Analysis -> QTJIR (SSA IR) -> LLVM -> Native Binary

• ASTDB -- Columnar semantic database; query code structure programmatically
• QTJIR -- SSA intermediate representation with sovereign string ownership
• Profile enforcement -- Compile-time gating of features by profile level

---

Toolchain

• janus build <file.jan> -- compile to native binary
• janus build --profile=service <file.jan> -- compile with :service features
• janus doc <file.jan> -- generate documentation
• janus query "<predicate>" <file.jan> -- semantic queries against ASTDB
• janus init [name] -- scaffold new project with janus.kdl manifest
• janus pkg <cmd> -- package management via Hinge

---

Known Limitations

• Alpha compiler -- bugs and missing diagnostics are expected. File issues.
• Linux x86_64 only -- primary development target. Other platforms are untested.
• No stable ABI -- internal representations change between versions.
• Early package ecosystem -- Hinge works but the public registry is not live yet.
• IDE support is basic -- LSP exists but is minimal.
• :service concurrency -- functional but not stress-tested at scale.

---

The Four Doctrines

1. Syntactic Honesty -- all costs visible, no hidden complexity
2. Mechanism over Policy -- tools, not restrictions
3. Explicit Choice -- all allocations, effects, and trade-offs visible
4. Revealed Complexity -- no magic, predictable behavior

---

Documentation

• Quickstart -- get running in 5 minutes
• What Works -- current feature status
• User Manual -- guides and operations
• Specifications -- compiler internals
• Doctrines -- philosophy and design law
• Contributing -- how to contribute

---

Issues: https://git.sovereign-society.org/janus/janus-lang/issues Website: https://janus-lang.org License: Libertaria Suite