1. Try
Start in five minutes
Once the idea is clear, open the developer start page to see source text go through the runtime and become validated JSON.
AEON
Documents should never surprise you.
// an introduction to the AEON language
announce:object = {
message:string = "Hello World!"
}AEON is a language system for explicit meaning.
AEON is a human-readable data notation system built on a simple belief: meaning should be layered and explicit. This lets it operate with a zero-trust mindset, where each layer of meaning is validated before materialization. AEON treats determinism as a feature rather than an implementation detail.
This page introduces you to Another Easy Object Notation Language.
If you are tired of data notation languages that are too bare, too magical, or too verbose, AEON gives you a way to write documents that are clear, predictable, and safe.
Get Started
AEON TypeScript packages are published on npm.
The reference TypeScript implementation is available under the @altopelago scope, including the runtime, core parser pipeline, AEOS validation, canonical form, CLI, and WebAssembly package.
npm install @altopelago/aeon-runtimeFirst Path
A practical route through AEON for a new developer.
2. Integrate
Use the runtime when you need the pipeline
Reach for the TypeScript runtime when you need profile compilation, schema validation, reference resolution, finalization, and annotations together.
3. Language
Understand the language layer
Read how vocabulary, grammar, processing stages, profiles, schemas, conventions, and Tonics fit together.
Why AEON Exists
Configuration and document languages became too implicit, too brittle, or too magical.
AEON exists because important documents should not depend on hidden conventions, parser guesses, runtime coercion, or schemas bolted on after the fact.
It restores clarity by making structure, type, intention, and trust boundaries visible at the surface of the file.
Motivation
AEON is a correction to familiar data-language pain points.
Implicit Magic
Values do not silently change shape because a parser decided that a word looked like a boolean, date, number, or missing value.
Unstructured Blobs
The document carries visible type and structure, so tools can validate intent before they materialize runtime objects.
Runtime Surprises
A document may make claims, but the consumer decides which schemas, profiles, conventions, and Tonics are trusted.
Capabilities
A document with nothing to hide.
AEON documents are ordinary to read and unambiguous to interpret. The visible surface teaches you the shape of the data before any runtime object exists.
project:object = {
name:string = "AEON website"
status:toggle = on
owner:string = "Alto Pelago"
tags:list<string> = ["docs", "language", "tools"]
}Types are visible.Readers and validators do not have to infer whether a value is text, a toggle, a list, or an object.
Assignments are explicit.Documents cannot surprise you with implicit merging, mutation, or execution.
Lists declare their element type.Validation can stay predictable without scanning for mixed or accidental forms.
Everything is deterministic.The same source produces the same assignment stream and canonical representation.
Who It Is For
AEON is for people who need documents to be readable, deterministic, and safe to process.
It is designed for configuration authors, system designers, schema-driven environments, tool builders, agent runtimes, and zero-trust pipelines.
Configuration authorsUse AEON when readable files need explicit shape, safer defaults, and fewer parser guesses.
Tool buildersUse AEON when stable streams, source spans, annotations, and canonical output matter.
Validation pipelinesUse AEON when syntax, schema checks, meaning checks, and materialization need clean boundaries.
Interchange systemsUse AEON when documents need to move between implementations without losing structure.
How It Works
AEON documents do not go straight into your system.
They pass through deterministic layers that preserve source claims, validate structure, apply consumer meaning checks, produce stable representation, and only then materialize meaning under consumer authority.
source text → AES → AEOS → meaning validation → canonical form → Tonic
AES = assignment event stream
AEOS = form validation
meaning validation = consumer context checks
canonical = stable representation
Tonic = trusted materializationThis pipeline exists because a document should not choose its own runtime. AEON separates claims, which are what the document says, from trust, which is what the consumer accepts.
Profiles describe optional semantic behavior. Schemas validate form. Conventions name shared ecosystem rules. These layers can work together, but they never blur.
Explore
Try the language before you study the whole system.
Playground
Write AEON and inspect the result
Use the playground to type AEON, switch between transport, strict, and custom modes, and inspect the parsed data stream.
Templating
Render AEON nodes as HTML
Explore how AEON data, node templates, semantic comments, and output HTML stay inspectable.
Ecosystem
See the surrounding system
Map AEON Core to schemas, canonical output, Tonics, &ND prose, NEON-style experiments, and implementation surfaces.
Learn
Move from motivation into language, then into reference material.
Why AEON
Understand the motivation
Read the case for visible meaning, explicit trust, deterministic processing, and safer document boundaries.
AEON Language
Learn the inner workings
Go deeper into vocabulary, grammar, processing layers, profiles, schemas, conventions, and Tonics.
Language Guide
Read the core forms
Learn bindings, containers, references, nodes, modes, and the common grammar shapes in a compact practical guide.
Specifications And Source
Leave the site when you need the source material.
Wiki
Read the public AEON guide
Open the fuller guide for quick start notes, examples, value types, processing model, contracts, security model, and spec reference map.
Repository
Inspect the implementation source
Go to the AEON repository for packages, examples, implementation work, and project history.
Specifications
Check the normative language rules
Use the specs repository when you need authority-level behavior for the core language, contracts, profiles, and conventions.