One million lines. Under one second.
A direct emitter, declaration-level incremental work, and no LLVM make 1M+ lines/sec/core the baseline design target. It is a target we measure and publish, including where we miss it—see the blog.
> open source, measured in public_
Neper is the first general-purpose programming language optimized end to end for LLM-generated software.
Build deterministic native software for Windows, Linux, macOS, CPU, and GPU. Neper is MIT open source, designed for AI coding agents, and 100% self-hosted—from compiler and linker to its ultra-rich standard library.
use e.io
fn main(args: []str) -> err {
try io.print("Hello, Neper")
ret ok
}
$ neper run hello.e
(32 msec, 3648 bytes)
Hello, Neper1M+ LOCper second, per core
< 1 secwhole-project rebuild target
CPU + GPUone language, one module
0 VMtiny native executables
MITopen source, fork anything
100% Neperself-hosted compiler + toolchain
3 OSWindows · Linux · macOS
Self-verifyingbyte-identical compiler fixed point
> get started_
Get started in three steps.
No account to create, and no third-party toolchain to cross compile for any OS: no LLVM, MSVC or MinGW, no Xcode or macOS SDK, no system linker, no Docker. One machine writes the Windows, Linux and macOS executables itself.
$ git clone https://github.com/nebosa-company/neper
$ scripts/build-selfhost.ps1 # Linux, macOS: scripts/build-selfhost.sh
$ neper run hello.e # the hello.e example above
Hello, NeperRead docs/llm-neper-card.md first. Then write a Neper command-line
program, wordfreq.e, that reads a text file and prints its ten most
frequent words. Add @test functions, run them, and fix every
diagnostic by its code and span. Then build it for x64 windows,
x64 linux and aarch64 macos with emit-executable.$ neper emit-executable wordfreq.e . x64 windows wordfreq.exe --release
$ neper emit-executable wordfreq.e . x64 linux wordfreq-linux --release
$ neper emit-executable wordfreq.e . aarch64 macos wordfreq-mac --release00 // watch it work
From prompt to native binary.
See one agent generate, check, repair, test, and compile a CPU/GPU program without leaving the deterministic Neper toolchain.
Neper in 30 seconds
From prompt to native binary, in full
01 // ultra by design
Everything between prompt and binary is optimized.
Neper is not a familiar language with an AI tool bolted on. Its vocabulary, compiler protocol, library, artifacts, and hardware model are designed as one system for generated software.
Extreme dead-code elimination. Every bit counts.
Neper traces every reachable function, type, and constant, then strips everything else. No VM, garbage collector, or LLVM runtime. Ship the program, not the toolchain.
A standard library built to finish products.
Algorithms, crypto, codecs, compression, data, networking, time, concurrency, UI, ML, and GPU compute—versioned and tested together.
Keywords optimized for model tokens.
A compact, frozen vocabulary gives every keyword one job. No aliases, overloads, contextual meanings, or macro dialects to make the model guess.
02 // batteries included
An ultra-rich standard library.
One coherent library surface replaces dependency archaeology. Every module is fenced, fixture-driven, and available to the compiler, the agent, and the reviewer under the same version.
603standard-library modules
1,248standard-library algorithms
115native UI controls
234chart types
e.algosorting, search, graphs, geometry, hashing, random
e.cryptohashes, signatures, encryption, key derivation, X.509
e.codecJSON, XML, CSV, images, archives, binary formats
e.compressdeflate, gzip, zstd, lz4, brotli, streaming codecs
e.datacollections, tables, schemas, query, validation
e.netHTTP, TLS, DNS, WebSocket, QUIC, MQTT
e.textUnicode, regex, search, diff, templates, locale
e.timecalendars, time zones, schedules, monotonic clocks
e.taskthreads, synchronization, pools, resilience
e.uinative windows, layout, controls, accessibility
e.mllinear algebra, classifiers, clustering, neural nets
e.gpuCPU, Vulkan, CUDA, tensors, images, presentation
e.db x.sqlite.sqlite x.postgresql.libpq x.oracle.mysql x.microsoft.odbc x.microsoft.tdsone SQL contract (connections, prepared statements, streaming row readers, transactions) with drivers for SQLite, PostgreSQL, MySQL, SQL Server over its own TDS protocol, and any database with an ODBC driver, tested against live servers on Windows and Linux
e.ui // showcase
Meet Neper Forge.
A polished verification dashboard showing how navigation, data, actions, status, progress, tables, and responsive surfaces work as one native design system.
03 // one module, every processor
Write once. Step on CPU. Launch on GPU.
A plain Neper function marked @gpu compiles beside its host code. Run the same kernel on the CPU for exact debugging, then launch it through Vulkan or CUDA without changing languages or build systems.
- one type system and module
- compile-time checked kernel arguments
- explicit transfers and synchronization
- CPU backend for deterministic debugging
use e.gpu
@gpu(256)
fn saxpy(a: f32, x: []const f32, y: []f32) {
let i = usize(gpu.gid.x)
if i < x.len { y[i] = a*x[i] + y[i] }
}
fn run(q: *gpu.Queue, x: []const f32, y: []f32) -> err {
let dx = try gpu.upload[f32](q, x)
let dy = try gpu.upload[f32](q, y)
try gpu.launch[saxpy](q, gpu.grid1(x.len), 2.0, dx, dy)
try gpu.download(q, dy, y)
ret ok
}
// q may target .Cpu, .Vulkan, or .Cuda04 // the complete llm stack
Optimized for every step an LLM takes.
“LLM-friendly” is not syntax sugar. Neper reduces uncertainty and token cost across generation, retrieval, editing, compilation, repair, testing, and final verification. The 26 guarantees below explain exactly how.
Fast builds, but a runtime-centered contract.
Go is an excellent compiled default, yet garbage collection, external language-server state, and separate build, test, and provenance surfaces leave agents coordinating several sources of truth.
Excellent tooling, but many delivery layers.
TypeScript adds strong language services to JavaScript, then depends on a runtime, transpilation, package scripts, configuration, and a large dependency graph that make native proof harder.
One deterministic contract from edit to artifact.
Neper combines compact explicit semantics, bounded compiler context, transactional edits, causal diagnostics, machine-applicable repairs, hermetic native builds, and content-addressed verification.
From prompt to proof.
Every source snapshot, semantic edit, dependency, unsafe boundary, test, and native artifact is connected by verifiable hashes.
Verification receipts
One content-addressed receipt binds the requested behavior, source snapshot, toolchain, tests, environment, unsafe boundaries, and native artifact.
Why: Trust becomes portable, inspectable evidence.Self-verifying compiler
The Neper compiler compiles itself again and reaches a byte-identical fixed point: the compiler verifies the compiler.
Why: The toolchain proves its own consistency.Deterministic artifacts
Offline builds, content identities, immutable snapshots, and authenticated caches make repeated results comparable.
Why: Same inputs always produce comparable results.Transactional edits
Rename and change plans verify snapshot hashes and unrelated-diff guards before anything is applied.
Why: Stale or partial changes cannot silently land.Semantic conflict detection
Parallel agent changes are merged against a shared snapshot, checked for textual and semantic conflicts, then reverified together.
Why: Parallel agents cannot merge incompatible meanings.Causal diagnostics
Stable codes, exact spans, expected and actual types, related causes, and bounded notes explain what failed and why.
Why: Models fix causes instead of chasing symptoms.Machine-applicable repairs
Typed fixes include confidence, preconditions, and affected spans so an agent can repair without guessing.
Why: Repairs are checked actions, not guesses.Bounded semantic context
The compiler returns the types, effects, ownership, callers, and dependencies needed for one edit—not an entire repository.
Why: Models get truth without repository overload.Compiler-issued LLM cards
The grammar, APIs, diagnostics, and capability surface are emitted as compact model context for the selected toolchain.
Why: Documentation cannot drift from the active compiler.Complete unsafe inventory
One command enumerates every unsafe boundary and escape hatch with its source, reason, and provenance.
Why: Every escape hatch stays visible and auditable.Script-free packages
Packages are hash-verified and stored immutably. Installation executes no package code and grants no surprise authority.
Why: Installing dependencies cannot execute hidden code.Hermetic build identity
Every tool, dependency, platform fact, input, and environment condition that can affect a result enters its identity.
Why: Ambient machine state cannot hide inside results.Explicit semantics
Casts, allocation, ownership, error flow, transfers, and unsafe boundaries are written where they happen.
Why: Critical behavior never depends on invisible inference.Lossless syntax model
Tokens retain exact spans and trivia; the recoverable tree preserves source identity instead of reconstructing it.
Why: Tools edit code without destroying human intent.Stable JSON protocols
Tokens, syntax, symbols, references, tests, builds, and results use versioned machine-readable records.
Why: Agents consume facts without parsing prose.Built-in verification
Tests, timeouts, structured events, reproducible manifests, and self-host fixed points define an objective stop state.
Why: Work stops only when evidence says done.See 10 moreShow less
Declaration-level reuse
Incremental builds recheck only affected declarations and explain every keep-or-rebuild decision.
Why: Feedback stays fast as projects grow.Generated-code source maps
Diagnostics in generated files route back to the source span the model should actually change.
Why: Models repair the real editable source.Single-purpose keywords
A short, closed vocabulary with no synonyms or contextual meanings keeps generation compact and deterministic.
Why: Fewer meanings reduce generation errors.No overloaded names
Each name resolves one way. Calls, operators, protocols, and imports never depend on a hidden candidate set.
Why: Resolution avoids hidden candidate sets.Search-stable declarations
Every top-level declaration begins at column zero with a keyword, and a file path is its module name.
Why: Relevant code is cheap to locate.Canonical formatting
One formatter produces one layout, shrinking diffs and preventing agents from spending tokens debating style.
Why: Formatting noise disappears from every diff.Direct native toolchain
Neper emits native executables through its own linker without LLVM, a VM, a garbage collector, or a hidden scheduler.
Why: Programs ship without heavyweight runtime baggage.Optimization explanations
The toolchain explains why code was retained, eliminated, rebuilt, instantiated, or linked instead of hiding those decisions.
Why: Performance decisions remain inspectable and debuggable.Honest flaky-test outcomes
Retries cannot turn nondeterminism into a pass. Attempts, seeds, and evidence remain visible as an explicit flaky result.
Why: Nondeterminism cannot masquerade as correctness.Measured token economics
Language changes are evaluated against tokenizer cost and verified repair success, making model efficiency an engineering constraint.
Why: Language evolution must justify model cost.05 // blog
Notes from measuring Neper.
We hold the language to the claim on this page with numbers from real sessions, including the columns where it loses.
A 1 TiB ceiling that costs 3 MiB
A program now takes the memory it needs with no flag, gives it back, and can free one object with use-after-free refused at compile time. Windows, Linux and macOS, measured, with how it compares to Go, Rust, C++ and Node.
Read the post →
Neper writes WebAssembly itself
The same compiler that writes PE, ELF and Mach-O writes wasm32-wasi: an 18 KB hello world, a 1.7 MB window, the compiler itself running as WebAssembly, and a phone keyboard in a canvas. Measured, with the limits listed.
Read the post →