Coherence Language

A coherence-native programming language, compiler, and runtime for explicit effects, identity-aware systems, and one-source multi-backend execution.

17

compiler stages from .cl source through checking, IR, and code generation

5

core effect kinds, all declared explicitly instead of hidden

L0-L3

identity levels enforced at compile time for sensitive systems

1,684

.cl modules in the current public software stack

What It Is

Why we built a language at all

Coherence Language is the language stack behind the lab. We built it because ordinary languages treat effects, identity, governance, and runtime boundaries as conventions or libraries instead of part of the language itself.

We needed one language that could describe pure computation, governed runtimes, compilers, and site generation from the same surface, then compile that surface across browser, GPU, VM, native, and Python paths.

Coherence Language snapshot

Declared effects

IO, identity touch, world stepping, and rail-sensitive actions stay visible in the source

Identity-aware

Identity levels are part of the language model instead of being bolted on later

Multi-backend

One language surface reaches six paths: native (LLVM), VM, Python, browser (WASM), GPU, and Luau

Operational proof

Classic Mode on this site is generated from .cl source as a live proof of the stack

Bootstrap and software traceability figure

Where It Fits Best

What Coherence Language is really good at

No hidden side effectsThe language is strongest when the source needs to say clearly what can happen instead of hiding behavior in runtime convention.

Built for governed systemsIdentity levels, rails, and explicit effect boundaries make it fit for sensitive or policy-constrained systems.

Good at real infrastructureIt is especially good at compilers, site generators, governed runtimes, and one-source systems that need to target browser, GPU, VM, native, and Python backends.