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
Build the compiler, run a first program, and build a GPU training executable.
Language guideexplanationThe full tour: syntax, types, quantities, effects and families, and why Alpha is built this way.
Families and branchesanalysisIndexed data, constructors, motives, recursion, and exhaustive elimination.
The REPL and editor toolsexplanationThe browser REPL's exact boundary, alpha repl's commands, and the language server and debugger behind an editor.
The standard libraryexplanationA tour of Std, Data and Model: the core types, naturals, collections, bytes, words, floats, codecs, effects and testing.
Build
A system taken apart: model, learner, run policy and pairing, the build directory, and how to build, run and test it.
Targets, devices and pairingsexplanationTarget packages, evidence-carrying device profiles, admission of demands against supplies, and the derived host.
Tests, gates and CIexplanationThe declared suite, proof roots checked to the bit, the negative corpus, gates with executed mutants, and CI.
ObservabilityexplanationRecording any command as an AOS stream, reading it back, and how receipts and gates reach their verdicts.
Workspace and packagesexplanationThe alpha.project manifest, alpha.package files, module resolution, and the content-pinned lockfile.
Distributed
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 tradeoffsanalysisThe case for compiler-owned distributed training (exact, inspectable, self-contained, refusal by name) weighed against what it cannot do yet.
Participants, endpoints and framesexplanationRoles and compact membership, star and hierarchy topologies, native connection setup, bounded identity-checked frames, and protocols projected to every role.
Combining contributionsexplanationOrdered 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 stateexplanationThe distributed learners, and partitioning of optimizer state, parameters and gradients, each equal bit for bit to the replicated learner.
Distributed checkpoints and resumeexplanationLogical shard manifests, immutable publication, manifest trees, path-only restore, and resuming on a different owner count.
Hybrid hosts and multiple GPUsexplanationOne 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 hardwareexplanationThe physical qualification driver, its refusal and host-shadow controls, the tracker, and every two-GPU result to date.
Toward 200,000 devicesanalysisThe heterogeneous fleet design target, the five kinds of scale claim, and the bounded-fan-out representations that already exist for it.
Understand
How Alpha turns learning ideas into checked, comparable experiments on real hardware.
Language and compileranalysisHow source becomes checked core, typed machine work, native artifacts, and evidence.
Built for agentsanalysisWhy 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.
PhilosophyanalysisWhy Alpha reopens the design space for agents instead of freezing today's AI stack.
The living catalogueanalysisHow a growing library of typed knowledge could let agents assemble and test learning systems from humanity's reusable ideas.
Catalogue-guided searchanalysisA research architecture for turning source-grounded mechanisms into diverse, qualified Alpha experiments.
Evaluate
What Alpha is good at, what it is bad at, and the central tradeoff.
Criticisms and hard questionsanalysisAn adversarial review agenda covering Alpha's thesis, engineering, science, evidence, and viability.
Where the ideas come fromanalysisPrimary literature behind dependent, quantitative, effectful, and verified programming.
Evidence and statusanalysisHow to read checked, run and measured claims, and what each one does not establish.
Tooling
Every alpha command with its flags, profiles, exit statuses, JSON events, receipts and resource budgets.
FormatterexplanationWhat alpha fmt guarantees: parse, declaration and comment preservation, idempotence, and its one style.
Language serverexplanationalpha lsp: what each editor request is answered from, what it costs, and the VS Code extension.
Debugger adapterexplanationalpha debug: launch, evaluate, source-map-verified breakpoints, and what is declared unsupported.
ProfilerexplanationWhere compile time goes, and what an emitted program is made of, by definition and by source line.
Compiler internals
One engine behind every tool, the bootstrap packages, the trusted kernel, the lossless source model and the two emission lanes.
Compiler pipelineexplanationEach stage from bytes to an ELF, with the module that owns it.
Core and IRexplanationThe dependently typed core that says what a program means, and the typed IR that says what it does.
Incremental engineexplanationWhat the interface cache is keyed by, why a comment edit is cheap, and the cache-trust boundary.
Reference
The normative language semantics and trusted boundary.
GrammargeneratedGenerated concrete syntax and parser-facing forms.
Language referencegeneratedExact forms, quantities, effects, interfaces, and artifacts.
Language formsgeneratedEvery surface form's feature contract: its edition, status, grammar, typing, elaboration, diagnostics and tests.
DiagnosticsgeneratedStable error codes, phases, and repair guidance.
Observability standard (AOS 1.0)normativeThe proposed Alpha Observability Standard, draft 1: identity, time, coverage, evidence and conformance for every observation.