Documentation

Learn Alpha.

Start with Getting started, keep the language guide open while you write, read a learning system taken apart before you build one, and turn to the specification when you need the exact rule.

Browse every Alpha source file →

Learn

Getting startedstart

Build the compiler, run a first program, and build a GPU training executable.

Language guideexplanation

The full tour: syntax, types, quantities, effects and families, and why Alpha is built this way.

Families and branchesanalysis

Indexed data, constructors, motives, recursion, and exhaustive elimination.

The REPL and editor toolsexplanation

The browser REPL's exact boundary, alpha repl's commands, and the language server and debugger behind an editor.

The standard libraryexplanation

A tour of Std, Data and Model: the core types, naturals, collections, bytes, words, floats, codecs, effects and testing.

Build

Anatomy of a learning systemexplanation

A system taken apart: model, learner, run policy and pairing, the build directory, and how to build, run and test it.

Targets, devices and pairingsexplanation

Target packages, evidence-carrying device profiles, admission of demands against supplies, and the derived host.

Tests, gates and CIexplanation

The declared suite, proof roots checked to the bit, the negative corpus, gates with executed mutants, and CI.

Observabilityexplanation

Recording any command as an AOS stream, reading it back, and how receipts and gates reach their verdicts.

Workspace and packagesexplanation

The alpha.project manifest, alpha.package files, module resolution, and the content-pinned lockfile.

Distributed

Distributed learningexplanation

How one learning system becomes cooperating executables across several GPUs, hosts and instruction sets, and what has been checked, run and physically qualified.

Benefits and tradeoffsanalysis

The case for compiler-owned distributed training (exact, inspectable, self-contained, refusal by name) weighed against what it cannot do yet.

Participants, endpoints and framesexplanation

Roles and compact membership, star and hierarchy topologies, native connection setup, bounded identity-checked frames, and protocols projected to every role.

Combining contributionsexplanation

Ordered combine trees instead of opaque collectives, delivery to every owner or one, numerical contracts, and how the declared order is shown to have run.

Distributing learning stateexplanation

The distributed learners, and partitioning of optimizer state, parameters and gradients, each equal bit for bit to the replicated learner.

Distributed checkpoints and resumeexplanation

Logical shard manifests, immutable publication, manifest trees, path-only restore, and resuming on a different owner count.

Hybrid hosts and multiple GPUsexplanation

One executable per role and target, x86-64 and AArch64 participants, binding a GPU by UUID, unequal devices, and memory admission across processes.

Qualifying on real hardwareexplanation

The physical qualification driver, its refusal and host-shadow controls, the tracker, and every two-GPU result to date.

Toward 200,000 devicesanalysis

The heterogeneous fleet design target, the five kinds of scale claim, and the bounded-fan-out representations that already exist for it.

Understand

Learning systemsanalysis

How Alpha turns learning ideas into checked, comparable experiments on real hardware.

Language and compileranalysis

How source becomes checked core, typed machine work, native artifacts, and evidence.

Built for agentsanalysis

Why Alpha is literal, fast to compile, strictly typed, and names every device and GPU instruction: so agents can take a system apart and rebuild it.

Philosophyanalysis

Why Alpha reopens the design space for agents instead of freezing today's AI stack.

The living catalogueanalysis

How a growing library of typed knowledge could let agents assemble and test learning systems from humanity's reusable ideas.

Catalogue-guided searchanalysis

A research architecture for turning source-grounded mechanisms into diverse, qualified Alpha experiments.

Evaluate

Fit and limitsanalysis

What Alpha is good at, what it is bad at, and the central tradeoff.

Criticisms and hard questionsanalysis

An adversarial review agenda covering Alpha's thesis, engineering, science, evidence, and viability.

Where the ideas come fromanalysis

Primary literature behind dependent, quantitative, effectful, and verified programming.

Evidence and statusanalysis

How to read checked, run and measured claims, and what each one does not establish.

Tooling

Command-line referenceexplanation

Every alpha command with its flags, profiles, exit statuses, JSON events, receipts and resource budgets.

Formatterexplanation

What alpha fmt guarantees: parse, declaration and comment preservation, idempotence, and its one style.

Language serverexplanation

alpha lsp: what each editor request is answered from, what it costs, and the VS Code extension.

Debugger adapterexplanation

alpha debug: launch, evaluate, source-map-verified breakpoints, and what is declared unsupported.

Profilerexplanation

Where compile time goes, and what an emitted program is made of, by definition and by source line.

Compiler internals

Compiler architectureexplanation

One engine behind every tool, the bootstrap packages, the trusted kernel, the lossless source model and the two emission lanes.

Compiler pipelineexplanation

Each stage from bytes to an ELF, with the module that owns it.

Core and IRexplanation

The dependently typed core that says what a program means, and the typed IR that says what it does.

Incremental engineexplanation

What the interface cache is keyed by, why a comment edit is cheap, and the cache-trust boundary.

Reference

Specificationnormative

The normative language semantics and trusted boundary.

Grammargenerated

Generated concrete syntax and parser-facing forms.

Language referencegenerated

Exact forms, quantities, effects, interfaces, and artifacts.

Language formsgenerated

Every surface form's feature contract: its edition, status, grammar, typing, elaboration, diagnostics and tests.

Diagnosticsgenerated

Stable error codes, phases, and repair guidance.

Observability standard (AOS 1.0)normative

The proposed Alpha Observability Standard, draft 1: identity, time, coverage, evidence and conformance for every observation.

Editions

Edition alpha-2026generated

The public stable edition manifest.

Edition alpha-2027generated

The repository-selected draft edition manifest.

Focused guides

Application formsexplanation

Application syntax, grouping, associativity, and diagnostics.

Buildersexplanation

Bounded byte construction and runtime image building.

Pathsexplanation

Path representation and file-effect boundaries.

Incremental cacheexplanation

Cache identity, invalidation, and verification.