Mo Lang — Index
Start here. The state of the project is the whole picture, rewritten at every pause. The maps of content gather the pages behind it: the thesis and its evidence, the rounds and the measurements, the language, the runtime, the programs, for Robert, how we work. The roadmap board is the authority on order and status; the decision-log is what Robert reads.
Every wiki page, one line each. Read this after SCHEMA.md to find pages for any question. Last updated: 2026-09-19 | Total pages: 285
Directions we like
- Direction 1: Agents write nearly 100% of the code — Humans no longer write or closely review code
- Direction 2: Human-readable, but at a higher altitude — Mo stays readable by humans because it is the shared language of understanding, but humans read intent, contracts, and effects, not bodies
- Direction 3: The source carries its own evidence — Since review is gone, trust comes from what the compiler can check: contracts, effects, tests bound to requirements, proofs
- Direction 4: Style rules become laws, possibly with no escape hatch — Everything Tiger Style and Power of 10 enforce socially, Mo’s compiler enforces
- Direction 5: Old ideas, rethought AI-first — Much of what works is decades old (Tiger Style, Power of 10, contracts, simulation testing)
- Direction 6: Never OOP. No classes — Functional and procedural style
- Direction 7: Elixir-flavored functional, not Haskell-pure — Pragmatic functional style
- Direction 8: BEAM qualities without the BEAM — Compile to a single static binary, memory-efficient like Rust or Go
- Direction 9: Primary inspirations: Rust, Go, Elixir/BEAM, Elm — , plus anything else worth stealing
- Direction 10: Immutable data by default — Gives agents locality of reasoning: to understand a function you need only the function
- Direction 11: Statically typed — Inferred inside bodies, required at every function boundary
- Direction 12: Concurrency at the edges, like Go — Most code is plain functions on immutable data; isolated processes are a tool for concurrency and fault isolation, not the primary progra…
- Direction 13: Local `var` with mutable value semantics, plus `inout` parameters — In
- Direction 14: Processes are the only identity, and each is an Elm-shaped state machine — State + message type + pure
updatereturning new state and effect commands - Direction 15: Effects via capabilities, no effect type system — A function is pure unless it takes a capability parameter
- Direction 16: Direct-style I/O with runtime interception —
fs.read(path)reads like Go and blocks like Erlang, but compiles to “suspend, hand a command to the runtime, resume with result.” The r… - Direction 17: Every effectful call carries a mandatory deadline — Bounded waits, extending Power of Ten’s bounded loops
- Direction 18: Two kinds of failure, two mechanisms, never crossing — Expected failure (“rain”) is an
Errvalue, exhaustive, in the signature, handled by the caller - Direction 19: Negative space is the human-agent contract — Humans write nothing, not even the spec
- Direction 20: A human is pulled in when the shape changes — Agents add, rewrite, and refactor freely
- Direction 21: Production crashes are fully autonomous — A tripped
neveror contract crashes the process, the supervisor restarts it, and the agent takes the crash as a task and fixes it with … - Direction 22: Type system: Rust-plus-refinements from day one — Traits (without the deep solver machinery), enums with data, generics with bounds, exhaustive matching, plus refinement types on primitiv…
- Direction 23: Compile speed is a first-class requirement — The compile time is the latency of the agent’s loop; a slow teacher gets ignored
- Direction 24: Compilation target: C via the Zig toolchain for release, own fast backend for the edit loop — Zig toolchain as the only dependency (Tiger Style), trivial cross-compilation and static linking
- Direction 25: Fast path is an interpreter, never shipped — Build order: (1) bytecode interpreter for the edit loop, also the executable reference semantics and the host for the simulator, replay, …
- Direction 26: Optimize for developer happiness AND agent happiness — Robert’s favorite language to read and write is Ruby (Matz’s “developer happiness”)
- Direction 27: Design principle (Robert’s words) — the language needs to be as simple as possible and elegant like Ruby and Python
- Direction 28: Nothing is final until it is measured — (Robert, session 2) Every decision here — especially the performance-shaped ones — stands only until a benchmark, eval, or test says othe…
- Direction 29: Agents edit by declaration ID, not by text position — (Robert: in, session 2, “fascinating”) Every declaration gets a stable ID in a toolchain-owned
.mo.idssidecar; source stays plain text… - Direction 30: Supply-chain security is a first-class design goal — (Robert, session 2, very important) AI has made package-ecosystem attacks (npm, PyPI, and the rest) massive and unlike anything before
- Direction 31: Effects never hide in a value — (session 3, tension 1) anonymous fns are call-arguments only, captures read-only; a captured capability can’t outlive the call
- Direction 32: Proving is a separate tool; tier 3 v0 is testing in the interpreter — (session 3, tension 4) property tests + simulation in the interpreter;
mo provevendors a solver outside the zero-dep law - Direction 33: Bounded mailboxes; `send` never blocks; overflow is a roof — (session 3, tension 5)
mailbox: Nper process, sender crashes on overflow, backpressure viaask - Direction 34: Packages are recipes; the spec is shared, the bodies are yours — (Robert, session 3, to be proven) stdlib is the bricks, a package is the booklet, the agent builds it in your repo; zero dependencies by construction
- Direction 41: The small-model round — (Robert, 15 Sep) rerun the control run’s reliability and loop measures with smaller models; speed, memory, and dependencies do not move with the model, the two that do are where the checks would first earn their keep
- Direction 42: The Elixir round — (Robert, 15 Sep) round 10: the BEAM null hypothesis run in a pane, round 7’s job queue and round 8’s change in Elixir, read on reliability, the loop, dependencies, and the runtime rows
- Direction 43: Five measurements — (Fable, 15 Sep evening, at Robert’s request to drive) bodies as cache, sampling as verification, the erosion round, the incident round, tokens and first-fix rate as columns; the unfamiliarity tax named as the risk against the thesis
- Direction 40: Structured runtime events, not log lines — (outside session, 13 Sep) every scheduler, supervisor, capability, and mailbox event with a schema; feeds the MCP surface and the crash report
- Direction 39: Hot code reload — (Robert, 13 Sep) swap a module’s code under running processes; state migration is the design work
- Direction 38: Time-travel debugging for Mo processes — (outside session, 13 Sep) snapshots plus the message log as a stepwise query interface; mostly built under mo test
- Direction 37: Runtime MCP surface — every Mo program is queryable — (Robert, 13 Sep, “the ability to debug a process”) list, inspect, query, pause a running process; must be a capability
- Direction 36: VM-first runtime, C backend as an optimization — (Robert, 13 Sep, “you are beginning to persuade me”) the VM as the reference, native as ahead-of-time compilation of it; the frame for d37–d40
- Direction 35: Mo is an ecosystem; first-party batteries you own — (Robert, session 3) Laravel model for first-party tooling, Phoenix-auth/shadcn model for kits you own; three shelves: bricks, kits, recipes
Questions and their answers
- Q1: Comments — ✅ in — Options:
#(Ruby, Python, Elixir) or//(Rust, Go, C) - Q2: Strings and interpolation — ✅ in — Options: Ruby
"Hello #{name}"/ Pythonf"Hello {name}"/ Rustformat!("Hello {name}") - Q3: Numbers and units — ✅ in — Options: plain numerals only / numerals with unit suffixes as methods (
200.ms,90.days) / a full units system - Q4: Integer types and overflow — ✅ in — Options: wrap silently (C, Go) / crash on overflow (Rust debug, Zig safe modes) / checked types that return
Option - Q5: Option and the absence of nil — ✅ in — Options:
Option(T)withSome/None(Rust) /MaybewithJust/Nothing(Haskell, Elm) / aT?shorthand (Swift, Kotlin) - Q6: The `verified by` line — ✅ in — Options: written by the agent as a claim / computed by the compiler and displayed / both
- Q7: Process API syntax: spawn, send, receive, supervise — ✅ in — Recommendation:
- Q8: The verification dial in practice — ✅ in — Question: what checks run when, and what does an agent wait for?
- Q9: Compiler diagnostics as the agent’s teacher — ✅ in — Question: what does an error look like?
- Q10: Semantic IDs and how agents edit Mo — ✅ in — Question: do agents edit text, or the tree?
- Q11: The platform concept and the standard library — ✅ in — Question: where do I/O primitives live, and how batteries-included is Mo?
- Q12: Law numbers — ↩ counter — Question: the concrete limits behind the laws
- Q13: Implementation language for the Mo toolchain — ✅ in — Options: Zig / Rust / OCaml / Go
- Q14: The first real program — ✅ in — Options (from session 1): agent harness / backend service with a DB / infrastructure component (queue, KV store, proxy) / the Mo toolchai…
- Q15: The name — ✅ in — Question: is “Mo” it, and what’s the story?
- Q16: Escape hatch, revisited — ✅ in — Question: parked in session 1: laws with no override, ever?
- Q17: Package management and supply-chain security — ✅ in (session 3: six-layer design, plus aube additions) — Raised by Robert (session 2), flagged as very important
- Q18: The shape of main and the first real platform — main as a known shape like update; minimal Platform; CLI log analyzer before the job queue
Decisions
- Decision log — every choice in order, who made it, status, what first tests it
Syntax picks and examples
- Current base example (Robert’s style) — the refund module in Robert’s chosen style, the base every pick is applied to
- Draft example, Ruby-shaped (superseded) — the first Ruby-shaped draft of the refund module, superseded by the base example
- Full example with Q1–Q7 applied — This is the base with every pick applied, including Q1–Q7 above
- Syntax pick 1: Blocks: keyword … `end` — Robert first rejected
def/end, then braces, then wrote his own version with `fn - Syntax pick 2: Definition line —
fn refund(db: Ledger, clock: Clock) : Result(Refund, RefundError) - Syntax pick 3: Bindings — bare
now = clock.nowis an immutable binding, bound exactly once per scope; rebinding is a compile error;varis the only way to get … - Syntax pick 4: Conditionals —
ifis an expression, no parens around the condition, braces - Syntax pick 5: Pattern matching —
casewith arms, no catch-all on a closed enum,isfor one pattern - Syntax pick 6: Results and propagation — predicates end in
?(charge.refunded?); propagation is thetryprefix (charge = try db.find_charge(id, within: 200.ms)), never po… - Syntax pick 7: Types —
struct,enumwith data, refinements withwhere; construction by named fields - Syntax pick 8: Contracts —
requires/ensureslines come directly after the signature line, then a blank line, then the body, all inside the `fn - Syntax pick 9: Module header and `never` —
module Payments.Refundwith dot paths (Robert’s pick;::rejected, one symbol one idea, Elixir made the same call) - Syntax pick 10: Process —
processwith capabilities as parameters, astateblock,messagelines, oneupdate,invariant - Syntax pick 11: Loops and anonymous functions —
forclosed withend,map/filter/reducekept, anonymous functions as call arguments only - Syntax pick 12: Tests — in the same file as the code, under it
- Syntax pick 13: Capabilities and logging — capabilities are ordinary types obtained only at the program root (
fn main(platform: Platform)), passed down explicitly, narrowed on th… - Syntax pick 14: Modules — private by default,
pubto expose (thepublines are the spec altitude’s table of contents) - Syntax pick 15: Methods without objects, traits, generics — dot calls are sugar for first-argument functions (
charge.within_window?(now)iswithin_window?(charge, now)), uniform function call s… - Pick 16: the one-line if as a value — Robert, 14 Sep morning:
x = if c: a else: b, a value only - Syntax: how we got to Ruby’s look with Go’s discipline — AI-first constraint: Mo has zero corpus, so bodies borrow shapes models know cold; novelty is spent only where semantics need it (`intent…
Deep dives
- Bricks and the cost of zero dependencies — the shelf boundary (three tests), the cost measured against Zig’s std, five audit items per brick, the surface caps, the ordering rule, the vendored-C fallback; program 7’s two bricks (17 Sep)
- Compilation target and compile speed — C via the Zig toolchain for release, a VM for the edit loop; the compile-speed bets and how they are measured
- Effects and capabilities — - Effect: what a function does beyond computing (reads clock, writes ledger, sends to a process, calls network)
- Errors and failure: rain vs broken roof — Rain vs broken roof
- The fork in the road: three products called ‘a language for AI’ — “A language for AI” means three different products:
- ID-addressed editing — The problem: agent editing tools today use
str_replace(fails on non-unique or already-changed text), line ranges (wrong the moment any… - Idea backlog (Claude’s early proposals) — - Stable semantic IDs on every declaration so agents edit by ID instead of fragile text diffs
- Agent-native runtime features to test — a menu in three tiers: MCP surface, time travel, structured events, counterexamples as tests; the build order
- VM-first vs C-first for the Mo runtime — what a VM owns that C cannot, where Mo sits, stay on C-first and design the VM as the eventual primary
- Reading pack for an outside reviewer — seven things to read in order, what we want from an OTP and a capability-systems reader, and the tried-and-rejected appendix
- The closure audit — direction 31 cost round 7’s jobq 12 lines of 2,843; the finding is a spec contradiction: chapter 3 says named functions are values, the stdlib chapter says no signature can name one
- Outside review, 14 Sep 2026 — a deep review after round 6: protect capabilities, the failure model, the runtime surface; the shape laws and keywords are the weakest part; test Mo on the programs that exercise it
- Outside review, 14 Sep 2026: Fable’s response — what was already done, what is wrong on facts, seven things to act on, the fork put to Robert
- Outside review, 13 Sep 2026: Fable’s response and the baselines — the calls per item, Robert’s decision, the numbers to compare against
- Research agenda, Sep 2026: Fable’s response to the contradictions — seventeen “contradicts Mo” items called (agree, disagree, test); chapter 2’s recursion law corrected; reproducible builds measured
- Outside review, 13 Sep 2026: what to keep, revise, drop — Amp + oracle + librarian; verdict, ranked disagreements, keep/revise/drop table, next five moves
- Outside review, 13 Sep 2026: evidence — thirteen probes against the day-two toolchain and kv corpus, with file and line references
- Negative space programming — Source: Negative Space Programming
- Research summary, Sep 2026 — Nobody has built this yet
- PL history research, Sep 2026: bundle index — entry point for the 168k-word bundle: history eras, camps, deep dives, Mo synthesis, decision matrix
- PL history: lambda calculus through the 1970s — Church/Turing, Fortran, Lisp, ALGOL, Simula, C, Smalltalk, ML, Prolog, Scheme, Forth; lessons for Mo
- PL history: 1980s through 2000s — C++, Ada, Eiffel, Haskell, Erlang, Self, Python, Ruby, Java, JS, C#, Scala, Clojure, Coq/Agda/Idris; lessons for Mo
- PL history: 2010 to 2026, the modern era — Go, Rust, Swift, Kotlin, Elixir, Julia, TS, Zig, Koka, Unison, Roc, Austral, Vale, Hylo, Carbon, Mojo, Lean 4, AI era
- The eight camps of language design — paradigm, types, memory, concurrency, syntax, compilation, philosophy, ecosystem — Mo’s stance on each
- Implementation menu: what a language builder chooses — parsers, IRs, type-check algorithms, GC, VMs/JITs, package managers, verification, bootstrapping
- Mo synthesis: what history says to Mo — camp-by-camp mapping to Mo’s directions with reasoning
- PL design decision matrix for Mo — 18 design axes as a compact table: Options | Mo direction | Rationale
- State model — why immutable values with
varin place, no aliasing, and processes as the only identity - Steal list: what to take from other languages — Framing: Go ships a scheduler and GC inside every binary and nobody calls it a VM
- Tiger Style + Power of 10, rethought AI-first — Key move: both documents are style guides enforced socially by review
- Two altitudes in one language — - Spec altitude (what humans read): module and function signatures, contracts (
requires/ensures), effect declarations, anintent…
Plans
- interpreter-step-44 — brief: bounded binary
Conn.chunks, the server’s unchanged-wire F1 blocker, both runtimes, TLS and simulation - report-claim-check — proposed TypeSafe triage of worker report claims against raw evidence; never acceptance; not built (18 Sep 2026)
- interpreter-step-41 — brief:
Exec, a child process narrowed inmainto fixed commands, both runtimes and the simulator - interpreter-step-42 — brief: runtime memory safety: the corpus under compaction at every safe point in both runtimes, poisoned freed regions, the audit of what outlives a frame, a parcel type, a guard that kills the group
- mo-workspace-server-4a — brief: the six-tool service in Mo, part A: the wire, admission, the journal, the operator’s path and the five file tools, no machine
- ci-gate — brief: the compiler and corpus checked on every pull request; generated files out of the source tree, the corpus built in parallel, a fast and a full gate
- interpreter-step-43 — brief: every number in source validated before a runtime sees it (the auditor’s PR 15: literals past their type, the mailbox bound, a sweep, the fuzz driver’s budgets)
- mo-agent-report-cap — brief: the agent’s 256 KiB report cap replaced by a bound derived from the profile, now that the runtime defect is fixed
- mo-harness-end-to-end-v1 — brief: the Mo agent against the real service on the machine, then the scripted Logstat repair
- interpreter-step-40 — brief:
Fs.scopedmade to hold against symlinks in both runtimes, andFs.replace - mo-harness-step-2-live-tables — brief: six live suites as case tables, recovery’s tests made able to fail
- toolchain-raw-memory-report — brief: the native binary prints raw memory on a large report; interpreter panic at vm.zig:1531
- mo-harness-step-1-executor — brief: the two high executor defects fixed, duplicate Python machinery deleted
- mo-harness-step-8-agent — brief: the Mo agent’s review findings, tests that can fail, one budget rule
- mo-capabilities-for-the-harness — design:
scopedmade to hold against symlinks,Fs.replace, andExecnarrowed to fixed commands - mo-harness-in-mo — the harness moved into Mo: the capabilities Mo gains, the target shape, nine steps
- mo-first-coding-harness — selected Mo-written coding application; headless first slice, protected verification, matched Pi comparison; implementation authorized
- mo-executor-foundation — first provider-independent executor slice with bounded containers, independent cleanup and protected behavioral verdicts
- mo-coding-fixture-v1 — trusted headless Mo repair orchestration, exact edits and JSONL before isolated workspace/provider integration.
- mo-workspace-foundation — bounded persistent Linux workspace, real feedback commands and protected snapshot identity
- mo-application-build-v1 — pinned Linux application image and separately bounded build policy
- mo-workspace-recovery-v1 — accepted cleanup ownership after lost responses or owner death
- mo-workspace-http-v1 — accepted six-tool HTTP routing with independent cleanup ownership
- mo-application-workspace-v1 — draft Mo profile for six recorded remote tools and explicit command budgets
- mo-provider-bridge-v1 — native Pi history, strict recorded continuation and bounded offline Mo HTTP compatibility before live inference
- mo-provider-auth-v1 — private harness credential store and pinned device OAuth, independently tested with synthetic credentials before live login
- mo-provider-foundation — pinned provider-only turns, synthetic SSE controls and usage/error distinctions before the Mo bridge or live authentication.
- mo-agent-terminal-auth — versioned Agent-specific terminal-401 policy, separate recipe binding and independently counted HTTP-status controls
- Step 30: processes on every core — a scheduler per core, messages across threads, fsync off the scheduler; accepted 15 Sep, the Mac table, the row that led to step 34
- Step 31: a deferred reply, brief for the worker — chapter 10 §1:
reply_tokept in state and answered later, the asker keeps its deadline and seesDownon a crash; the batching queue’s fix for round 8’s outage - Step 32: crash reports apart from the ring, and the reopening store — what P6 on Mo found:
/crashesempty under load, and the restart pattern no corpus file shows - Step 33: the crash report freed, and the interpreter’s abort on a full disk — what generation three found: the leak per restart, the abort under mo run
- The audit workflow: who reads what, and when — the auditor Robert opens, the three ratified stopping rules, Fable’s parallel readings, the evidence bundles under
audit/evidence/, the loop and its violations - Step 36: the TLS brick, part one: a TLS 1.3 server in both runtimes — an engine over bytes in Zig,
platform.tls, aConnthat stays aConnbehind the handshake; step 37 is the client, the chain, ALPN, and the differential run - Step 37: the TLS brick, part two: the client, the chain, ALPN, and the audit items —
Tls.client,TlsClient.connect, the chain checked to a trusted root, ALPN byoffer, KeyUpdate either way, the differential run against OpenSSL and the fuzz hour, the four things the auditor found in step 36 closed - Step 38: a full-duplex Conn, TCP_NODELAY, and the handshake abuse rows — queued before program 7’s build: a
Connthat reads while a write waits, Nagle off, and resets and alerts at every handshake state under both runtimes - interpreter-step-39 — the TLS brick’s corrections (the chain, ALPN, plaintext records, the instruments, the corpus),
F_FULLFSYNCon macOS; queued 18 Sep - The generation-four memory control probe — pre-registered: is generation four’s 46 MiB the contract’s walk (H1), the design (H2), or the walk’s allocation (H3); a cheap
ensuresand a deleted one, eight cells, two trials - Step 35: the crypto brick, written once for both runtimes — SHA-2, HMAC, HKDF, AES-GCM, ChaCha20-Poly1305, X25519, Ed25519, Argon2id,
Random; one Zig file overstd.cryptolinked into both runtimes; the five audit items (17 Sep) - Step 34: placement, so the Mac’s cores stop costing — a process placed with its starter, the crossing made cheap, measured at 1, 4, and 14 cores
- Step 29b: replay memory on a real log — Fable’s 1M probe on an HTTP-written log passed 8 GB after the fold; the rule bounded-by-what-the-update-reaches made to hold in every loop shape
- Step 29: the runtime honest —
restart: :neverhonoured,platform.exitwith a pending delayed send, replay streamed, simulated time only when a test waits, invariants counted - Program 6: ledger in Mo — the brief for the payments ledger whose invariants are the point; after step 28
- Step 28: what round 7 found in the runtime — a map written in place, the tuple
reduce, resident memory, replay, theneverrule’sifgap, six gaps - The control run, round 7 — pre-registered on Robert’s measure: the hidden defect suite, native speed and memory, the feedback loop, dependencies
- Sampling as verification — measurement 2 of direction 43: five regenerations of the queue’s board, a random driver, disagreements against the hidden suite
- Bodies as cache — measurement 1 of direction 43: every program regenerated from its stripped spec, twice; completeness per program
- The control run, round 10, the Elixir round — pre-registered: the BEAM null hypothesis in a pane, round 7’s queue and round 8’s change in Elixir under the same suites
- The Mac scaling run — the one script for step 30 at 1, 4, 10, 14 cores on the M3 Max, and what to read from it
- The erosion round, generations two to five — changes 2 to 5 to the Mo, Go, Python, and Elixir queues by fresh maintainers, a hidden suite per generation, P6, the speed row per generation; the live round
- The control run, round 9, the small-model round — pre-registered: round 8’s change by five smaller models in the Pi harness, reliability and loops as the columns that move
- The control run, round 8, the maintenance round — pre-registered: the finished queues handed to fresh agents with a changed spec, regressions and defects, read on reliability and dependencies together
- Step 27: what round 6 found — the file law gone,
state/result/oldas names, aneverreads values at rest, the escape,fold_lines - The control run, round 6 — pre-registered: logstat and jobq, the baselines with their checks bolted on, the null hypothesis stated as P3
- Step 26: the one-line if in tail position — what step 25’s acceptance found: tail position is a value, two keyword diagnostics; before round 6
- Step 25: the one-line if and keyword field names — Robert’s two calls of 14 Sep morning; the production, the formatter rule, the fix reversed,
stateafter a dot - Step 24: what program 5 found — the authority hole, a handle in a state field, a delayed send,
Deadline.remaining, four gaps, the simulator’s ask - Step 23: the runtime surface —
platform.runtime, the event ring,mo run --surface PORT; directions 37 and 40 against program 1’s nine questions - Step 22: what program 1 and round 5 found — the
--recipeline count, the fixture’s missing folder, a JSON integer, the derived deadline (reply_by), the recipe’s rewrite rule, two diagnostics - Step 21: memory and green threads — a process is not an OS thread; chapter 7’s bets measured;
Fs.fixture()refuses..; three diagnostics, no syntax - Step 20: the runtime owns the loop, brief for the worker — serve and lines rows, capabilities in declared message fields, the four servers rewritten
- Step 19: what program 4 found, brief for the worker — freeing finished processes, the held-send deadlock, recipe conformance, mkdir, a fixed clock, diagnostics, each_line, mutation tests
- Step 18: the outside review’s no-compat fixes, brief for the worker — invariant polarity, handles as authority, capture, recursion, grouped patterns, equality, cache key, faults that stop
- Step 17: the round 3 follow-ups, brief for the worker —
any(T)under refinements,NotText, a fold over lines, six diagnostics reworded - Step 16: HTTP in the stdlib, brief for the worker —
HttpoverNet, server and client, fixture, both runtimes, differential - Step 15: processes and Net in the C backend, brief for the worker — the scheduler and sockets in C, kv and echo native, differential
- Step 14: the follow-ups from round 2 and the C backend, brief for the worker — contracts on in every build, three suspected panics, formatter shapes, four stdlib rows, housekeeping
- Step 13: the C backend, brief for the worker — C runtime, emitter, mo build, differential tests against the interpreter
- Step 12b: two ratified defaults, undone, brief for the worker — memoization out of the reference interpreter; every never runs on every test
- Step 12: the runtime under real programs, brief for the worker — program discovery, hashed maps, in-place state, per-request freeing, file writes, three language decisions, fmt fuzz
- Program 5: agent in Mo, brief for the worker — the agent harness: permissions as narrowed capabilities, a run’s budget as one
Deadline, retries, a scripted mock model, the surface as the operator’s view - Program 1: jobq in Mo, brief for the worker — the founding premise’s first real test: a durable lease-based job queue over HTTP on the store recipe
- Program 4: notes in Mo, brief for the worker — the first program over HTTP, built from two recipes
- Program 3: kv in Mo, brief for the worker — the second real program, a TCP key-value store
- Step 11: Net, a TCP capability, brief for the worker — processes under mo run, sockets, direct style over blocking calls, Net.fixture
- Step 10: the verified sidecar, mo fix, the error catalog, the README, brief for the worker — four tooling promises from chapters 5 and 7
- Step 9: Mo.Sim with seeds and fault injection, brief for the worker — seeded scheduling, injected failures, never over Type.all, sim (N runs)
- Step 8: the stdlib, brief for the worker — strings, lists, maps, sets, time, fs listing, JSON; 09-stdlib.md; logstat rewritten
- Step 7: programs of many modules, brief for the worker — use imports functions, program root, multi-file corpus programs, push in place, interpreter speed
- The control run, round 4: logstat after steps 17–20, the timing round — same spec, same model, fresh sessions; the laws re-evaluated against it
- The control run, round 3: logstat after the formatter fixes and HTTP — same spec, same model, fresh sessions, after steps 14–16
- The control run, round 5: pre-registered — three predictions written before the run; loops by cause; wrote-the-language-directly
- The control run, round 2: logstat again on today’s toolchain — same spec, same model, fresh sessions, after steps 7–12b
- The control run: logstat in Go and Python, brief for the worker — same spec, same model, chapter 8’s null hypothesis
- Program 2: logstat in Mo, brief for the worker — the first real program, written from a spec, the founding-premise experiment
- Step 6: main and Mo.Server, brief for the worker — main in the language, the real platform over std.Io, mo run, three programs with expected output
- Step 5: the formatter, brief for the worker — FORMAT.md rules, mo fmt, the loop rule as MO0501, for _, MO0319, corpus formatted
- Interpreter step 4: processes and supervisors, brief for the worker — Mo.Sim scheduler, update as a transaction, invariants, mailbox bounds, supervisors, the refund queue test
- Interpreter step 3: run the tests, brief for the worker — refund module joins the corpus, bytecode, VM, tier-2 contracts, test runner, verified line
- Interpreter step 2: the tier-1 checker, brief for the worker — prelude, names and types, the laws, capabilities, rejects/ fails by code
- Interpreter step 1: lexer and parser, brief for the worker — corpus catches up with the Session 5 decisions, then lexer, parser, corpus test, bench rows
- Model bake-off: Opus vs Grok vs Codex as workers — same corpus brief to three models, one rubric, Robert picks
- Corpus: brief for the worker session — 50 tiny programs in examples/, one construct each, plus rejects/ that must not compile
- Comparison pass: brief for the worker session — template, tools, and the 13 briefs for the Opus worker
- Program menu: what we build to put Mo through its paces — seven programs of different kinds, and what each measures
- Roadmap: now, next, later — the board: what is in flight, what comes next in order, what waits on Robert, what just landed; then the phases and every step’s history
Sessions
- overnight-harness-2026-09-19 — recovery acceptance and remote application routing
- Session 6 — 13 Sep 2026 (evening, ingestion) — six deep-research runs and three adjacent runs ingested into raw/; new prompts-mo-parallel-tracks page; no decisions changed
- Session 5 — 12–15 Sep 2026 — review closed, corpus and toolchain begun, bake-off, build-first process, gap decisions
- Session 1 — 12 Sep 2026 (night) — the first design conversation: the directions, the premise, the first syntax
- Session 2 — 12 Sep 2026 — the open questions walked one at a time, Robert’s answers, the syntax picks
- Session 3 — 12 Sep 2026 — tensions 1–7, Q17, aube, recipes and the ecosystem (d31–d35), design-v0 folder
- Session 4 — 12 Sep 2026 — expose line replaces pub, use A.B{X}, every for closes with end, loops vs combinators rule
Research
-
Mo vs Bend2 — protected law/proof workflow, release-matched learning, evidence status and selective ownership; pinned source inspection and local checks, with GPU/proof caveats
-
agent-native-research-synthesis — four reports reviewed with the oracle; selective source checks, four additional strategic reviews and the agreed calibration-to-useful-workload sequence; implementation paused
-
agent-native-independent-review-prompt — self-contained web-enabled review brief; challenge everything, including a new language/runtime; comparable independent responses
-
Mo vs Elixir — comparison: inference-first gradual types, OTP supervision shapes vs Q7, typed processes
-
Mo vs Go — comparison: simplicity by tooling, error-syntax post-mortem, goroutine bugs, module supply chain
-
Mo vs Rust — comparison: what Mo keeps (enums, matching, small traits) and drops (lifetimes); compile-time and LLM evidence
-
Mo vs Roc — comparison: how a platform is built, purity by arrow, static dispatch, Perceus, the Zig rewrite numbers
-
Mo vs Koka — comparison: effect types and handlers vs capabilities, the closure-capture gap in d15, Perceus, fip
-
Mo vs Austral — comparison: linear capabilities from a root, unsafe modules, crash-on-contract-violation, what linearity would buy Mo
-
Mo vs Hylo — comparison: mutable value semantics precisely, parameter conventions, projections, a coherence rule, colorless concurrency
-
Mo vs Unison — comparison: hash-identified definitions, never-invalidated caches, no dependency conflicts, the cost of dropping text
-
Mo vs MoonBit — comparison: the shipping AI-native toolchain (Pilot, sampler, SeekMoon), its language, and the no-resource LLM evidence
-
Mo vs Bosque — comparison: design by removal, no loops, escape-free lambdas, validation levels, small-model verification, why it slowed
-
Mo vs SPARK Ada and Dafny — comparison: contracts that run and prove, assurance levels, contract shapes LLMs discharge, loop invariants
-
Mo vs the agent-native cluster — comparison: 13 agent-first languages in short entries, and what 42 catalogued attempts converged on
-
Mo vs aube — comparison: the Node package manager’s security defaults (trust no-downgrade, age gates, reputation signals, jail) and the seven things Mo takes
-
Mo vs Verse — comparison: failure as control flow, transactional rollback, structured concurrency; transactions vs crash-and-restart
-
Comparison synthesis (draft) — ⚠️ tensions across the 13 comparisons, top ten steals, open questions for Robert; draft for Fable
-
Supply-chain defenses — Q17 input: defenses that exist, the 2024–26 incident record (20 of 47) with impact/trend ranking, Mo mapped against it, six package-system design options (no recommendation)
-
Landscape, second lane — what Robert’s three landscape research runs add or dispute vs Claude’s survey; shortlist arguments
-
Mo vs Motoko — comparison: actor isolation, trap-reverts-to-commit-point, upgrade-safe persistence, the ‘designed for AI agents’ claim (Caffeine)
-
The case against new languages — the null hypothesis the v0 design doc must answer: Quasar, CodeAct, SynCode, token sugar, cold start, ilo, Aether, BHC/hx
-
Capability module lineage — Newspeak, Joe-E, Wyvern, Limbo, E’s confused deputy, each mapped to pick 13 / Q16 / Q17
-
Language landscape: which languages deserve a deep comparison — 40+ languages in seven groups with the idea to steal from each, plus a 13-entry shortlist for the comparison pass
-
Research prompts: the language landscape — three prompts for Robert’s deep-research tools
-
Research prompts: Q17 supply-chain security and package management — three prompts for Robert’s deep-research tools
-
Research prompts: Mo’s three parallel research tracks — empirical validation, ecosystem depth, agent-authoring frontier; each brief paired with its Perplexity deep run
-
The PL landscape circa 2026 — what’s alive, growing, fading, and where the interesting design work is happening; extends language-landscape
Language surveys (history + design + Mo lesson)
- C — Ritchie 1972, Unix’s portable assembler, why it won and what it cost; what Mo takes and rejects
- Lisp / Scheme / Common Lisp — McCarthy 1958, homoiconicity, macros, why it never dominated; what Mo takes
- Smalltalk — Kay/Ingalls/Goldberg, pure message-passing OO, image-based dev; why Mo is d06-never-oop but respects the insight
- ML / Standard ML / OCaml — Milner 1973, Hindley-Milner, ADTs, functors; what Mo takes
- Haskell — 1990 committee, laziness, monads, type classes; why Mo is d07-elixir-flavored-functional not Haskell-pure
- Erlang / BEAM — Armstrong 1986, actor model, let-it-crash; the model behind d08-beam-qualities-without-the-beam
- C++ — Stroustrup 1985, RAII and templates, the complexity lesson Mo rejects
- Java — Gosling 1995, JVM, generics-via-erasure, the ecosystem-wins lesson
- Python — van Rossum 1991, indentation, Python 2→3 and PyPI supply-chain lessons
- JavaScript / TypeScript — Eich’s 10 days, gradual typing win, npm as the negative example for d30-supply-chain-security
- Go (survey) — Pike/Thompson/Griesemer, simplicity discipline, gofmt culture, MVS, mandatory checksums (see also Mo vs Go)
- Zig — Kelley 2016, comptime, no hidden control flow, the raw-C-hazard lesson; toolchain choice for d24-compile-to-c-via-zig
- Dependent types: Lean 4, Idris 2, Agda — the case for and against dependent types in general-purpose languages; where Mo’s q08-verification-tiers fits
- Research agenda 2026-09: papers, authors, manifestos — six runs (R1–R6) with prompts; R1, R3, R6 executed 2026-09-13 via Perplexity Computer, R2/R4/R5 ready to run
- Empirical validation plan: how Mo gets judged — the seven experiments against the control runs; round 5 pre-registered, tokens counted, baselines with checks
- Ecosystem strategy: the stdlib, kits, and the registry — Q11 answered against the day-one list; TLS and crypto as the gating bricks; recipes as kits
- Agents and verification: the 2025–2026 evidence — R1: verifier automation beats model choice (82/44/27%), specs not proofs are the bottleneck, 0% contract satisfaction at 75–82% pass@1, composition frontier, diagnostics exchange rate for agents
- Language design for LLMs: what the evidence says — R1: what measured results say about strictness, shape laws, low-resource syntax, structured edits, and error messages; where Mo’s laws have evidence for and against
- Author: Ken Thompson (Unix, C, Go) — R3: Trusting Trust vs source-first supply chain; taste, deletion, and what he refused to add
- Author: Dennis Ritchie (C) — R3: C as a portable assembler by intent; what he called mistakes; the cost of trusting the programmer
- Author: Brian Kernighan (Unix, AWK, style) — R3: Elements of Programming Style and the Practice of Programming as the human ancestor of Mo’s laws
- Author: Rob Pike (Plan 9, Go) — R3: simplicity as a tooling and social property, gofmt, less is exponentially more, Go’s error and generics decisions
- Author: Tony Hoare (CSP, axiomatic semantics) — R3: axiomatic contracts, null as the billion-dollar mistake, the Turing lecture on simplicity
- Author: Edsger Dijkstra (structured programming) — R3: goto, testing shows presence not absence, against mechanical translation of bans, simplicity is not systematic
- Author: Niklaus Wirth (Pascal, Modula, Oberon) — R3: a feature’s cost must be known before release, compiler self-hosting speed rule, design by removal
- Author: Joe Armstrong (Erlang) — R3: the six requirements R1–R6, let it crash, restart is not storage, failed type retrofits, do away with modules
- Safety-critical coding standards — R6: Power of 10, JPL C, MISRA, CERT, DO-178C, Ravenscar, SPARK and others compared; three rule categories, deviation records, the loop-annotation convergence
- Reliability and testing philosophies — R6: FoundationDB, Antithesis sometimes-assertions, Jepsen, SQLite coverage, let-it-crash restart intensity, QuickCheck shrinking, SRE error budgets, mutation testing
Research monitoring
-
hermes-daily-2026-09-19 — OTP timeout/late-response semantics and the boundary between duplicate refusal and safe replay.
-
hermes-daily-2026-09-18 — TLS state-sequence coverage, harness limitations, and versioned EOF semantics.
-
hermes-research-monitoring — the plan of the Hermes lane: an independent daily evidence scan and Monday synthesis, wiki-only, reviewed through a research PR before merging
-
hermes-daily-2026-09-17 — Crash-consistency fault models, capability API confinement boundaries, and daily validation.
-
hermes-daily-2026-09-16 — Versioned restart-budget defaults, error-path coverage evidence, and daily scan validation.
-
07b-redis-subset-revision-2 — program 7’s spec, revision 2: persistence out of Redis’s suite, expiries on rewrite, one size cap, the lead’s skip list, RC2’s core operation, R2 to R7 pinned, a package behind
/metrics; sealed 18 Sep