Build software that survives failure.
Browser playground runs Nulang Core. Actor supervision and durable recovery require the local runtime.
Compiler loads on first run.
One model from source code to recovery.
Nulang keeps the resilient-systems primitives close together: typed effects describe what code may do, actors isolate state and failure, supervisors coordinate recovery, and persistent actors can hydrate durable state after restart.
Explore the actor runtimeHM inference, rows, variants, capabilities, algebraic effects
spawn · send · ask · link · monitor · supervisors
snapshots · journals · restart hydration · pluggable stores
From first run to local development
Run Nulang Core in the browser, then install a checksummed release for the full native runtime.
Persistence without bolting on an ORM
Ordinary actors are in-memory. Mark an actor persistent and declare durable or event-sourced state to opt into checkpointing and journaling. The CLI can reopen a durable store and hydrate persistent actors across process restarts. Nulang is still alpha, so validate recovery semantics for your workload before production use.
Explicit local, durable, event-sourced, and CRDT state models
File-backed durable storage by default for programs that declare durable state
Recovery and supervisor hydration are covered by runtime tests
Pluggable JSON, RocksDB, and Postgres store URIs where the corresponding features are enabled
# Durable programs use .nulang/store/ by default
$ nulang counter.nula
# Or choose a store explicitly
$ nulang --store json:.nulang/store counter.nula
# Environment-based configuration is also supported
$ NULANG_STORE_PATH=.nulang/store nulang counter.nulaDurable distributed applications, with fewer moving parts
Building reliable distributed software often means combining an actor framework, workflow engine, message broker, cache and database. Nulang is exploring how typed actors, supervised recovery, durable state and Fabric messaging can live within one coherent runtime.
Compare languages and actor frameworks
Understand Nulang’s tradeoffs against Erlang, Elixir, Go, Rust, Akka, Orleans and Ray—including the maturity and production guarantees those established systems already provide.
Explore the programming language and actor framework comparisons →
The infrastructure consolidation roadmap
Experimental Fabric streams, durable workflows and early NuDB research target use cases often served by Redis, NATS, Kafka, Temporal and, eventually, databases. These are works in progress, not drop-in replacements today.
See current implementations, missing guarantees and the roadmap →
Language + runtime capabilities
Each capability is labeled by maturity so you can distinguish stable language surfaces from experimental runtime features.
Actor Runtime
Stable core · experimental multi-nodeSpawn, links, monitors, supervision, and actor messaging are stable language surfaces. Multi-node transport and gossip clustering are experimental; source-level CRDT state integration is still incomplete.
Algebraic Effects
StableKoka-inspired row-polymorphic effects with compile-time checking. Handle, perform, resume — algebraic effect handlers compose freely without monad transformers.
Row-Polymorphic Types
StableFull Hindley-Milner type inference with row polymorphism for both records and effects. Pony-inspired reference capabilities (iso, trn, ref, val, box, tag) enforced at compile time.
BEAM/OTP Primitives
Stable actor surfaceSupervision trees (one_for_one, one_for_all, rest_for_one, simple_one_for_one), process groups, named registration, and exit trapping — battle-tested fault tolerance patterns.
WASM Backend
ExperimentalFeature-gated MIR→WASM compilation with Wasmtime execution, SIMD support, and AOT artifacts. Treat compatibility and performance as experimental while the backend matures.
AI Runtime
ExperimentalFeature-gated provider integrations, agent pipelines, debate teams, supervisor hierarchies, and memory primitives. This is optional runtime functionality, not part of the frozen language core.
See the numbers, not a speed claim.
Same-host, single-CPU Savina-style message-passing baselines across Nulang, Go, Erlang/BEAM, and Rust. These are measured runtime primitives, not equivalent actor-framework implementations.
All four workloads, exact results, and methodologyShared CI hardware is noisy. Rust here uses native threads andstd::sync::mpsc; no third-party actor frameworks have been measured.
Don’t take the homepage on faith
Run the compiler, inspect executable conformance cases, and look at regression-gated benchmark data. Nulang’s strongest claims should be independently checkable.
Real compiler frontend + CoreVM in WebAssembly.
Open playgroundVerify itConformance suiteExecutable behavior cases for language and runtime semantics.
Browse testsMeasure itPerformance benchmarksMeasured Nulang, Rust, Go, and BEAM results with source artifacts and limitations.
View measurementsKeep going
Read the language docs, follow the tutorial, inspect the implementation, or explore the managed platform.
Ready to try Nulang?
Nulang is alpha software and open source under the Apache 2.0 license. Try it in the browser, install a release binary, run the examples, and pressure-test the ideas.