This repository is a reboot of the Ash programming language. The reboot keeps lessons from historical Ash while rebuilding the language from a small, coherent base. Historical Ash is evidence for design work, not authority for this project.
Ash is a rank-1 language with nominal data, interfaces, effects, lexical
handlers and scoped resources. Programs are acyclic graphs of passive source
modules. Each .ash file contains imports and declarations. Function signatures
may state interface constraints and effect rows. The entry module supplies a
local main function. Its row may contain default allocation and required native
symbol effects; the generated root and native interpretation discharge them:
main : Unit -> Int
main () = 42The current dialect is ffi-ash. The canonical specification
defines its implemented language and runtime behavior.
The ash tool guide explains module roots, invocation,
output and failures, including explicit native link inputs
and generated-host linkage checks.
Foreign libraries use source signatures and native link names on
x86_64-unknown-linux-gnu. Opaque Address, readonly synchronous Bytes pointers
and actual void returns form the supported boundary. Ordinary Ash modules own
null checks and cleanup policy; see the foreign rules.
The annotated mini-ash and modular-ash Git tags retain the earlier single-file
and passive-module/interface milestones. The completed library and effect
increments add explicit implementation selection, higher-kinded parameters,
relational interfaces, module and local newtype, scoped evidence, checked
one-shot resume/discard, cells, synchronous hooks and cleanup. ffi-ash also
includes generic cells, lexical region storage, retained continuations,
cooperative scheduling and two pinned workers with copied FIFO byte channels.
Current source contains no dialect selector; the tags retain historical
milestone states rather than selectable compiler modes.
The signed annotated ffi-ash tag retains the official current-dialect
checkpoint. Its closure report records the
scope, design-branch reconciliation, execution support and verification method.
The feature inventory records current product boundaries and distinguishes historical experimental evidence from the specified foreign interface. The design-note scope summary identifies implemented slices, historical evidence and open directions.
Project artifacts answer different questions:
- design notes record accepted designs, alternatives and unimplemented extensions;
- architectural decisions record accepted non-language decisions;
- change proposals propose language-semantic changes;
- tasks organize active implementation work;
- the development trajectory records dependencies and maturity;
- project documentation defines documentation, dependencies, and the development discipline;
- tool documentation describes the retained Ash executables.
Ash is not only a language for expressing programs. It aims to be a language for expressing truth about programs: values, behavior, invariants, and the laws that must hold. In the long-term direction, Ash wants programs to state not only what a computation does, but also what properties are required, which facts are assumed, which obligations are proven, and which remain subjects for testing. The language is designed to combine executable code with sound reasoning so that real systems can be built with principled guarantees rather than only informal confidence.
In other words, Ash aims to support the full arc from implementation to specification to evidence: ordinary computation, static guarantees, property checks, and proof-backed facts in one consistent language story.
Human contributors should start with CONTRIBUTING.md. Agents should start with AGENTS.md and reconstruct only the context needed for their task.
Ash is licensed under the GNU General Public License version 3
(GPL-3.0-only).