your notes,
they compute.

You're outlining a problem. You want to verify a calculation. Today: tab to a REPL, paste, run, tab back, paste the result. Maybe annotate. Two days later you can't tell which number was hand-typed and which one was computed.

outl removes the tabbing. The code lives in your note. The result lives in your note. The note is the notebook.

A fenced code block isn't syntax highlighting. It's an invitation.

```python
from datetime import date
commits = [42, 17, 31, 9, 28, 14, 22]
total = sum(commits)
avg = total / len(commits)
print(f"{total} commits · avg {avg:.1f}/day")
```

The button on the right is the same key as gx in the TUI. Or set auto-run:: on on the block and it runs every time the page opens — cache-aware, so unchanged source returns the cached result in <1ms.

Each language is an outl-exec adapter — about 80 lines of Rust. The runtime registry is plugin-shaped: a new language ships as a new crate.

nums = [1, 1, 2, 3, 5, 8, 13]
print(sum(nums) / len(nums))

(define (sq x) (* x x))
(map sq '(1 2 3 4 5))

const days = (a, b) =>
  (b - a) / 864e5;
days(new Date('2026-01-01'), new Date())

local t = {1, 2, 3, 4, 5}
local sum = 0
for _, v in ipairs(t) do sum = sum + v end
return sum

fn main() {
    let v: Vec<i32> = (1..=10).collect();
    println!("{}", v.iter().sum::<i32>());
}

Set auto-run:: on on a block. Every time the page opens, the block evaluates — but only if its source changed.

The hash is stamped into the result subblock as source-hash::. If you edit the source, the hash changes, the cache misses, the block re-runs. Deterministic and observable.