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_
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
> your first program_
Run one in a minute.
Three small steps. Each one is yours to take, and none needs an account.
$ git clone https://github.com/nebosa-company/neper
$ # save the hello.e example above as hello.e
$ neper run hello.e
Hello, Neper00 // 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.
Ten languages, one window: what you install
One compiler builds Windows and Linux desktop programs from one machine, the user installs nothing to run them, and the window is 2.7 MiB. Set against the install guides of ten popular desktop languages, with the limits listed.
Read the post →
Why Neper is built for the agent loop
Search, generate, edit, check, repair: what each step costs a model, and the language rules, JSONL commands and diagnostics that make each one cheaper, including the claims we have not yet proved.
Read the post →
Text the way Windows draws it: ClearType in Neper
Neper's Windows look now draws hinted ClearType text, with its own TrueType bytecode interpreter and a GDI-style rasteriser. Against 77 native Windows captures the off pixels fell from 30,800 to 11,321. It is not pixel-exact yet, and the post says by how much.
Read the post →
Faster charts, smaller SVG, and what we are doing about PNG size
The same chart drawn by Neper, base R, lattice, ggplot2 and matplotlib: 3.4 to 73 times faster as SVG, 2 to 24 times faster as PNG, SVG 28 to 32 percent smaller. Neper's PNG is three times larger than R's, and the post says why, what we measured, and the lossy step that cuts it by 47 percent.
Read the post →
234 charts, and when to use each
A field guide to every chart Neper draws, from bars and box plots to Laney control charts, Kaplan-Meier curves, Sankeys and Nyquist plots: the question each one answers, when to reach for another, and how fast it is against matplotlib.
Read the post →
A million lines, eight compilers
Neper's sc1m scale program ported to seven languages with checked answers. Neper's binary runs it in 47 ms from 2.73 MiB, Dart compiles it fastest cold — and Zig 0.16 never finishes.
Read the post →
Six algorithms we first skipped
A backtracking regex engine with a step budget, mixed-integer programming by branch and cut, model checking that returns the shortest counterexample, AC-2001, crash dumps from both operating systems, and sign-on as the user who is already signed in: what each is for, and a program for each.
Read the post →
Bring your own OpenSSL: SQL Server scans, three times faster
Neper's SQL Server driver can hand its TLS record cipher to the host's OpenSSL, looked up at run time and never shipped, while the handshake and certificate checks stay Neper's. Scans get 3.2–3.6 times faster, and on Windows Neper's scan becomes the fastest of Neper, C, Go and Rust.
Read the post →
One SQL contract, five drivers
How e.db works, how to write a driver, and what differs between SQLite, PostgreSQL, MySQL, ODBC and SQL Server, whose TDS protocol Neper speaks itself inside TLS 1.3 — then the same workload in Neper, C, Go and Rust on Windows and Linux. C wins, Rust is second, Neper third ahead of Go, and scans are still where Neper loses.
Read the post →
Neper vs Dart: what it costs an LLM to write each one
Seven days of Claude transcripts, measured byte by byte. The same cost per KB, 43% cheaper direct edits and more first-try builds for Neper — and 2.2× the context, which is what we fix next.
Read the post →