<!-- AEON -->

# Documents should never surprise you.

```aeon
// 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.

[Walkthrough](/walkthrough.php)  
[Playground](/playground.php)  
[Why AEON](/why-aeon.php)

<!-- 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.

```aeon
npm install @altopelago/aeon-runtime
```

[Open npm package](https://www.npmjs.com/package/@altopelago/aeon-runtime)  
[Developer start](/developer-start.php)  
[GitHub repo](https://github.com/AltoPelago/aeon)

<!-- First Path -->

## A practical route through AEON for a new developer.

### Start in five minutes

_1. Try_

Once the idea is clear, open the developer start page to see source text go through the runtime and become validated JSON.

[Developer start](/developer-start.php)

### Use the runtime when you need the pipeline

_2. Integrate_

Reach for the TypeScript runtime when you need profile compilation, schema validation, reference resolution, finalization, and annotations together.

[Open runtime](https://github.com/AltoPelago/aeon/tree/main/implementations/typescript/packages/runtime)

### Understand the language layer

_3. Language_

Read how vocabulary, grammar, processing stages, profiles, schemas, conventions, and Tonics fit together.

[Language layer](/aeon-language.php#language-layer)

<!-- 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.

[Read why AEON](/why-aeon.php)  
[See how it works](/aeon-language.php)

<!-- Motivation -->

## AEON is a correction to familiar data-language pain points.

### No hidden meaning behind conventions

_Implicit Magic_

Values do not silently change shape because a parser decided that a word looked like a boolean, date, number, or missing value.

### No guessing what a field intends

_Unstructured Blobs_

The document carries visible type and structure, so tools can validate intent before they materialize runtime objects.

### No execution before validation

_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.

```aeon
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.

[Capabilities](/capabilities.php)

<!-- 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 authors** Use AEON when readable files need explicit shape, safer defaults, and fewer parser guesses.
- **Tool builders** Use AEON when stable streams, source spans, annotations, and canonical output matter.
- **Validation pipelines** Use AEON when syntax, schema checks, meaning checks, and materialization need clean boundaries.
- **Interchange systems** Use AEON when documents need to move between implementations without losing structure.

[Learn the basics](/walkthrough.php)  
[Open system map](/ecosystem.php)

<!-- 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.

```aeon
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 materialization
```

This 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.

[Read AEON language](/aeon-language.php)  
[Open schemas](/schemas.php)

<!-- Explore -->

## Try the language before you study the whole system.

### Write AEON and inspect the result

_Playground_

Use the playground to type AEON, switch between transport, strict, and custom modes, and inspect the parsed data stream.

[Open playground](/playground.php)

### Render AEON nodes as HTML

_Templating_

Explore how AEON data, node templates, semantic comments, and output HTML stay inspectable.

[Open templating](/templating.php)

### See the surrounding system

_Ecosystem_

Map AEON Core to schemas, canonical output, Tonics, &ND prose, NEON-style experiments, and implementation surfaces.

[Open ecosystem](/ecosystem.php)

<!-- Learn -->

## Move from motivation into language, then into reference material.

### Understand the motivation

_Why AEON_

Read the case for visible meaning, explicit trust, deterministic processing, and safer document boundaries.

[Open why AEON](/why-aeon.php)

### Learn the inner workings

_AEON Language_

Go deeper into vocabulary, grammar, processing layers, profiles, schemas, conventions, and Tonics.

[Open AEON language](/aeon-language.php)

### Read the core forms

_Language Guide_

Learn bindings, containers, references, nodes, modes, and the common grammar shapes in a compact practical guide.

[Open language guide](/language.php)

<!-- Specifications And Source -->

## Leave the site when you need the source material.

### Read the public AEON guide

_Wiki_

Open the fuller guide for quick start notes, examples, value types, processing model, contracts, security model, and spec reference map.

[Open wiki](https://github.com/AltoPelago/aeon/wiki)

### Inspect the implementation source

_Repository_

Go to the AEON repository for packages, examples, implementation work, and project history.

[Open repository](https://github.com/AltoPelago/aeon)

### Check the normative language rules

_Specifications_

Use the specs repository when you need authority-level behavior for the core language, contracts, profiles, and conventions.

[Open specs](https://github.com/aeonite-org/aeonite-specs)