<!-- Language Walkthrough -->

# Learn AEON step by step.

## Basic features.

This first page covers the smallest useful document, the core container shapes, and the authoring features that make the language comfortable to read and write.

AEON is small at the surface, but deep in capability. The depth comes from orthogonality, not from hidden rules.

That complexity is meant to be predictable, deterministic, explicit, composable, non-magical, and non-executable: the opposite of surprising implicit behavior.

The second page continues with attributes, anonymous child metadata, separator values, references, and nodes once the basic document model is clear.

[Start with the basics](#step-1)  
[Go to advanced features](/walkthrough-advanced.php)

<!-- Step 1 -->

## The smallest AEON document

The smallest useful AEON document is a single binding. If you understand the shape of one binding, you understand the foundation of the language: a name, an equals sign, and a value.

```aeon
hi = "Hello World!"
```

<!-- Step 2 -->

## Basic scalar values

Most AEON documents begin as ordinary data. Strings, numbers, booleans, toggles, and numeric literals are straightforward, so simple documents stay simple.

```aeon
name = "Alice"
score = 23
enabled = true
ratio = 3.14e-2
large = 1_000_000
```

<!-- Step 3 -->

## Optional type labels

AEON can carry explicit type labels when a document needs them. That lets a producer state intent without turning the document into executable logic.

```aeon
hi:string = "Hello World!"
score:number = 23
isWinning:boolean = false
```

<!-- Step 4 -->

## Objects and nesting

Once you know a single binding, the next step is nested structure. Objects group related bindings together and form the backbone of most structured AEON documents.

```aeon
contact = {
  name = "Bob"
  occupation = "patissier"
}
```

<!-- Step 5 -->

## Lists and tuples

After objects, the next natural step is ordered containers. Lists are for repeated values of the same general kind, while tuples are for fixed positions where each slot has a defined role.

```aeon
animals:list = ["cat", "dog", "mouse"]

measurements:list = [
  3
  4
]
```

When every element has the same intended type, a generic type annotation on the list is the compact form.

```aeon
measurements:list<number> = [3, 4, 5]
```

```aeon
sound:tuple = ("cat", "meow")

point:tuple = (12, 42)
```

Tuples can also declare the intended type of each position with a generic type annotation.

```aeon
sound:tuple<string, string, number> = ("cat", "meow", .7)
```

Tuples look similar at a glance, but they represent a positional record rather than a sequence of interchangeable items.

<!-- Step 6 -->

## Whitespace, newlines, and commas

AEON is meant to be authored, not just generated. You can write structures across multiple lines, inline with commas, or with trailing commas when that makes editing easier.

```aeon
version = "2.1.1", contact = { name = "Bob", occupation = "patissier" }

contact = {
  name = "Bob",
  occupation = "patissier",
}
```

<!-- Step 7 -->

## Comments

Comments are part of the normal authoring experience. They let teams leave notes, preserve review context, and keep explanatory material alongside the data without changing the data itself.

```aeon
// single-line comment
/*
multi-line
comment block
*/
```

<!-- Step 8 -->

## Multiline strings

Multiline strings belong in the basic toolkit because real documents carry longer text. Once you know bindings and containers, block text becomes straightforward to read and author.

```aeon
story = `
Long
story
told
word
for
word
per
line
`
```

Use plain backticks when you want the text exactly as written. Use trimticks when you want to indent the source neatly without keeping that leading indentation in the resulting value. The reserved prose label marks formatted trimtick text while richer interpretation stays with profiles or applications.

```aeon
story:prose = >`
  Long
  story
  told
  word
  for
  word
  per
  line
`
```

<!-- Step 9 -->

## Try writing a small AEON document.

Now that the basic shapes are familiar, edit a short document and let the walkthrough check whether the source still parses cleanly.

### Try it

Edit the source and check the verification line below the editor.

```aeon
hi = "Hello World!"
contact = {
  name = "Bob"
  occupation = "patissier"
}
measurements:list<number> = [3, 4, 5]
```

<!-- Next -->

## Continue with the advanced language features.

When the basic document model is comfortable, the next page introduces custom type labels, attributes, separator values, references, nodes, and semantic comment channels.

[Open advanced walkthrough](/walkthrough-advanced.php)