Hale, in text

The whole of the documentation and every article, as plain HTML. No script, no webfont, no images, no colours of ours — your browser decides how this looks. Same source as the styled site, so it does not go stale.

Hale is a concurrent systems language with a GC-free runtime: typed message-bus concurrency, data-race-free by design.

Install

curl -fsSL https://hale-lang.org/install.sh | sh

Documentation

Introduction

• Introduction
• Claims & the law
• Effects & contracts
• Libraries (pond)
• Reference
• The design
• Verification

Basics

• Control flow
• When a call can fail
• Your first program
• Functions
• Math, money & time
• Strings & text
• Values & variables

Everyday

• CLI & config
• Lists & maps
• Hashing, encoding & randomness
• Files
• HTTP
• JSON
• The locus, gently
• Logging
• Metrics
• Records & data
• UDP & TLS
• Testing

Getting started

• Your first run
• Install

Services

• The bus
• Concurrency & placement
• When things fail
• The lifecycle
• Across binaries
• Parents & children
• Composition patterns
• Perspectives

Spec

• Design decisions (the F-series)
• Design rationale
• spec/ffi.md — Foreign-function interface (`@ffi("c")`)
• Forms
• Codename legend
• Memory model
• Package management
• Operator precedence and associativity
• Projects
• Runtime
• Operational semantics
• Standard library
• Style guide
• Testing pipeline
• Lexical structure
• Type system
• Static verification surface

Systems

• Binding C
• Forms under the hood
• Memory & lifetime
• Modes
• Operations & debugging
• Performance
• Record & replay
• WebAssembly & the browser
• Zero-copy & the high-frequency bus

Tutorial

• Build a job queue

Articles

• Record & Replay — 13 August 2026. Record one concurrent execution, then re-run the same program with the same journaled inputs and the same per-consumer delivery order. How Hale turns its typed bus, effect frontier, and runtime ownership of scheduling into a replayable incident — without asking application code to instrument itself.
• Secrets — 8 August 2026. A signing key the rest of the program cannot reach, using the ownership model that was already there. One annotation closes the gap in it, one built-in effect class marks the privileged operation, and the law is written with the claim forms the language already has.
• Fleets — 6 August 2026. Claims close one application; a fleet plan closes one deployment of many. Topology artifacts compose across binaries, cross-process law gets checked with cross-process witnesses, and signatures carry the certificate to the machine that runs it. What a development lifecycle looks like when every stage from function to fleet is either proven or refused.
• Constitutions — 5 August 2026. Claims stay closed-world, but their source no longer has to be copied into every main locus. Constitutions share one claimset across entrypoints and environments, compose only by addition, and make missing coverage an error.
• Claims — 4 August 2026. Write the system's laws before finishing its implementation, then let the compiler drive the program toward them. Named claims over Hale's call, message, effect, and topology graphs turn isolation, required wiring, single-writer rules, capability boundaries, and quantitative limits into ordinary development feedback.
• Effects — 31 July 2026. A function can declare what it is allowed to reach, and the compiler proves the claim over the entire call graph. Effect classes, quantitative budgets, per-phase contracts, causal tracking in both directions across the bus, and effect classes a program declares for itself.

Elsewhere

• Source, on GitHub
• The styled site, which has a playground and diagrams
• llms.txt