<!-- Developer Start -->

# See the whole loop: source text in, accepted JSON projection out.

## Start with one document and one runtime call.

If you are evaluating AEON as a developer, the first useful question is: what do I write, what does the runtime produce, and where does validation happen?

```
import { runRuntime } from "@altopelago/aeon-runtime";

const source = [
  'app:object = {',
  '  name:string = "AEON demo"',
  '  port:number = 8080',
  '  enabled:boolean = true',
  '}'
].join("\n");

const result = runRuntime(source, {
  mode: "strict",
  output: "json",
  includeAnnotations: true
});

if (result.meta.errors.length === 0) {
  console.log(result.document);
}
```

The finalized JSON projection is plain application data produced after AEON has checked the source claims.

```
{
  "app": {
    "name": "AEON demo",
    "port": 8080,
    "enabled": true
  }
}
```

- **Write** Start with typed bindings, objects, lists, tuples, references, and prose blocks in the playground.
- **Validate** Run in strict mode when you want reserved datatypes, explicit structure, and fail-closed diagnostics.
- **Materialize** Ask for JSON when you want ordinary application data after AEON has preserved and checked the source claims.
- **Inspect** Turn on annotations when tooling needs source spans, comments, or parallel metadata without changing the data.

[Open playground](/playground.php)  
[Learn syntax](/walkthrough.php)  
[Runtime package](https://www.npmjs.com/package/@altopelago/aeon-runtime)

<!-- Install -->

## Use the published runtime from npm.

For most applications, the runtime package is the simplest entry point because it coordinates compile, validation, reference handling, finalization, and diagnostics.

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

[Open npm](https://www.npmjs.com/package/@altopelago/aeon-runtime)  
[TypeScript workspace](https://github.com/AltoPelago/aeon/tree/main/implementations/typescript)

<!-- Examples -->

## Learn the language from small working examples.

The examples repository is the best next stop when you want to see AEON source beside runnable code. Start with the Hello World examples, then move into typed objects, schemas, validation, and runtime output.

- **Hello World** Begin with the smallest source files to see how bindings and scalar values become application data.
- **Runtime loops** Compare source input, validation diagnostics, and accepted JSON projections in compact examples before wiring AEON into a larger project.
- **Language patterns** Use the examples to learn objects, lists, references, schemas, and browser demos in practical context.

[Open examples repo](https://github.com/AltoPelago/aeon-examples)  
[Read walkthrough](/walkthrough.php)

<!-- Next -->

## Move from the runtime loop into the language and system model.

### Learn the syntax in order

_Walkthrough_

Walk through bindings, scalar values, containers, types, comments, and multiline text before moving into references and nodes.

[Start walkthrough](/walkthrough.php)

### Understand the meaning model

_Language Layer_

Read how vocabulary, grammar, profiles, schemas, conventions, and Tonics add meaning without giving documents authority over themselves.

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

### Experiment without setup

_Playground_

Use the playground to switch modes, inspect AES and data output, and see annotation stream behavior while you edit.

[Open playground](/playground.php)