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—not a stretch goal.
> first of its kind_
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
00 // 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.
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.
344standard-library modules
1,232standard-library algorithms
112native UI controls
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.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.