NURL

v0.91.1

A compiled language without a virtual machine, garbage collector, or interpreter — designed as a target for LLM code generation, with deterministic builds and native LLVM performance.

Start with NURL Open Playground

99,373lines of NURL in the compiler

1,940compiler test programs

243stdlib modules

11tested targets

65registry packages

Contributors

Hindurable

iljasrb

WHY NURL

Built for generated code

NURL keeps generated code easy to parse. Fixed arity removes precedence ambiguity, short dependency windows limit context, and the grammar fits on one page.

Regular prefix-arity grammar

Every operator has a fixed arity. There is no infix syntax or precedence table.

Local semantics

A token’s meaning depends on a short span of preceding tokens.

Single-owner memory

Values auto-drop at scope exit. Borrow checking, an explicit unsafe/raw boundary, and a mechanized Lean 4 proof (formal/) guarantee memory safety.

Deterministic compiler

Bootstrap compiles the compiler twice and requires identical LLVM IR from both runs.

LLVM-backed

One LLVM pipeline targets desktops, servers, WebAssembly, RISC-V, and embedded systems.

Self-hosting

The compiler is written in NURL and builds itself from source.

SYNTAX

Prefix notation, end to end

NURL uses OP ARG1 ARG2 …. There is no operator precedence or infix syntax.

Add two integers

@ add i a i b → i { ^ + a b }

( add 3 4 )     // → 7

FizzBuzz

: ~ i i 1
~ <= i 100 {
    ? == 0 % i 15 { ( nurl_print `FizzBuzz\n` ) }
    ? == 0 % i 3  { ( nurl_print `Fizz\n` ) }
    ? == 0 % i 5  { ( nurl_print `Buzz\n` ) }
    { ( nurl_println_int i ) }
    = i + i 1
}

See the language reference for generics, traits, pattern matching, errors, channels, compile-time evaluation, and async runtime support.

BENCHMARKS

Measured runtime performance

25 verified benchmarks compare NURL with C, Rust, Node, and Python. Each implementation must produce the same output before timing.

5 languagesGitHub Actions ubuntu-latest runnerMeasured 2026-11-13Benchmark sources →CI run →

Benchmark runtime in milliseconds; lower is better.
Benchmark	NURL	C	Rust	Node	Python
`lcg`20M-step 64-bit LCG + xorshift	30 ms	30 ms	29 ms	1,115 ms	2,711 ms
`packet_classifier`25M unpredictable branches	43 ms	42 ms	43 ms	130 ms	2,330 ms
`ring_write`20M ring-buffer stores	31 ms	30 ms	31 ms	52 ms	3,404 ms
`histogram_bins`20M binned increments	30 ms	30 ms	30 ms	53 ms	3,000 ms
`prefix_scan`1M 16-wide prefix scans	17 ms	17 ms	17 ms	48 ms	2,231 ms
`binary_search`5M lower-bound searches	16 ms	16 ms	16 ms	70 ms	3,653 ms
`sort_window`2M 8-element bubble sorts	22 ms	21 ms	22 ms	135 ms	6,388 ms
`bloom_filter`4M Bloom-filter queries	10 ms	9.9 ms	10 ms	1,550 ms	3,877 ms
`hash_join`5M hash-table probes	18 ms	18 ms	20 ms	1,865 ms	4,079 ms
`sieve`Sieve of Eratosthenes to 10M	16 ms	16 ms	16 ms	51 ms	1,720 ms
`fib`Recursive fib(35)	20 ms	20 ms	20 ms	75 ms	532 ms
`collatz`Longest Collatz chain below 100k	12 ms	13 ms	13 ms	43 ms	404 ms
`matmul`256x256 integer matrix product	27 ms	26 ms	27 ms	64 ms	1,934 ms
`json_parse`20 parses of a 64 KB document	6.2 ms	10 ms	14 ms	34 ms	28 ms
`nbody`500k n-body integration steps	22 ms	35 ms	23 ms	74 ms	1,682 ms
`safe_record_array`10M by-value record updates in a Vec	55 ms	49 ms	55 ms	n/a	n/a
`payload_state_machine`10M events through an enum/result state machine	84 ms	77 ms	74 ms	n/a	n/a
`captured_closure_queue`10M calls through a queue of 16 closures	98 ms	94 ms	100 ms	n/a	n/a
`dynamic_method_mix`10M two-method calls on 64 trait objects	117 ms	115 ms	115 ms	n/a	n/a
`csv_table_pipeline`4 parses + scans of a 100k-row RFC 4180 table	70 ms	79 ms	69 ms	n/a	n/a
`chacha20`ChaCha20 over 16 MiB (RFC 8439)	6.3 ms	24 ms	25 ms	n/a	n/a
`poly1305`Poly1305 MACs over 64 MiB (RFC 8439)	9.6 ms	20 ms	20 ms	n/a	n/a
`blake2b`BLAKE2b-512 over 32 MiB (RFC 7693)	33 ms	53 ms	58 ms	n/a	n/a
`sha512`SHA-512 over 16 MiB (FIPS 180-4)	37 ms	38 ms	41 ms	n/a	n/a
`x25519`1000 chained X25519 scalar mults (RFC 7748)	26 ms	38 ms	39 ms	n/a	n/a

Median wall-clock time for the full process. Lower is better. NURL is highlighted only when its displayed time is lower than every other displayed time.

GET STARTED

Start with NURL

Try it in the browser

Write, build, and run NURL in your browser.

Open the Playground →

Install a release

curl -fsSL https://nurl-lang.org/install.sh | sh
irm https://nurl-lang.org/install.ps1 | iex

Install guide →

Build from source

git clone https://github.com/nurl-lang/nurl
cd nurl && ./build.sh

View the repository →

Editor support

The VS Code extension also works in Cursor and Windsurf, with diagnostics, completion, and formatting.

Editor guide →

TARGETS

One LLVM pipeline across targets

The compiler emits target-agnostic LLVM IR for desktop, server, browser, unikernel, and embedded targets.

Linux x86_64

Windows x86_64

macOS x86_64 and ARM64

FreeBSD x86_64

WebAssembly

Linux ARM64

Linux RISC-V64

Unikernel x86_64, ARM64, and RISC-V64

Milk-V Duo

ESP32 Xtensa

ESP32-C3/C6

Embedded hardware. NURL runs an HTTP file server on the Milk-V Duo and drives ESP32 GPIO through memory-mapped registers.

Browser builds. The playground compiles to wasm32-wasi in your tab and can cross-compile downloadable native binaries.

Bootable programs. The unikernel path links NURL programs without a host OS for x64, ARM64, and RISC-V targets.

STANDARD LIBRARY

243 modules, included with the toolchain

The standard library is plain NURL source: core types, general-purpose modules, and optional higher-level integrations.

Network

TCP, UDP, Post-Quantum TLS 1.3, QUIC, HTTP/1.1, HTTP/2, HTTP/3, WebSocket, MQTT, SMTP, and peer-to-peer networking.

Data

JSON, Protobuf, Zstandard, TOML, YAML, XML, MessagePack, CBOR, CSV, PostgreSQL, and SQLite.

Concurrency

Threads, mutexes, channels, atomics, and a stackful M:N async runtime.

Core

Collections, arbitrary-precision numbers, regex, crypto, compression, UUIDs, paths, and processes.

AI and MCP

Anthropic API support plus MCP clients, servers, sessions, and registries.

Tooling

LSP, formatter, documentation tools, test and benchmark runners, and a differential fuzzer.

Browse the standard library →

PROJECTS

NURL projects

The compiler itself

A self-hosting compiler that produces identical LLVM IR in two compilation rounds.

Explore →

A Game Boy emulator

A complete DMG emulator compiled to WebAssembly for the browser.

Explore →

The playground backend

NURL serves the playground, build service, MCP endpoint, and package registry.

Explore →

Examples

Examples include Game of Life, HTTP/2, MCP servers, agents, and embedded targets.

Explore →

PACKAGES

Packages, one command away

The registry supports semver ranges, reproducible lockfiles, and signed tarballs verified by nurlpkg before unpacking.

nurlpkg search whisper
nurlpkg install nq
nurlpkg add tensor
nurlpkg publish

Browse the registry →

nurllama

whisper

onnx

tensor

grad

yoloe

nwasm

image

MCP SERVER

NURL tools for agents

Connect an MCP client to build, run, and cross-compile NURL without a local toolchain.

claude mcp add --transport http nurl https://play.nurl-lang.org/mcp

Read the MCP setup guide →

REFERENCES

Source, specification, and release history

Documentation

Guides and language reference for installing, writing, and running NURL.

Read the docs →

README

A repository overview of the language, runtime, and build pipeline.

Open README →

Formal grammar

The versioned EBNF grammar and historical snapshots.

Open grammar →

Formal proof (Lean 4)

60,000+ lines of Lean 4 mechanizing NURL’s memory model (A1, A2 & A3): structs, enums, closures, panics, concurrency, data-race freedom, and leak freedom.

Interactive explorer →GitHub source →

Changelog

A release-by-release record of changes.

Read changelog →

Roadmap

Current work and plans toward 1.0.

Read roadmap →

Package registry

Browse packages, source, and generated API documentation.

Open registry →