Pseudo could say what a procedure computes only up to INTEGER and FLOAT, so it could not state what a Mojo or Python program with Int32, UInt8 or Float32 values will compute, and it had no words for rounding itself. - lang/parse: INT8..INT64, UINT8..UINT64, FLOAT32, FLOAT64 as types (INTEGER or FLOAT with a width, so every "whole number" rule accepts them); conversions written as Mojo writes them, INT32(X), FLOAT32(X); 1_000_000, 0xFF and 0b1010 literals; a type name as an argument (MAX_VALUE(INT8)); the USE line (USE IEEE now, library modules next). - check: widths and precisions never mix silently (mixed-width, mixed-precision); a literal takes the type of the sized value beside it, as in Mojo, and one that does not fit is an error before any run (literal-range); typing for every new built-in. - interp: a sized result, store, parameter, RETURN or conversion that does not fit stops the run (kind overflow), WRAP(X, T) wraps on purpose; FLOAT32 results are rounded to single precision; USE IEEE lets NaN and infinities flow. - numeric.js: exact helpers: FMA rounded once, EXACT(X) with every digit a FLOAT holds, ULP and NEXT_AFTER for both precisions, bit operations in two's complement. - Built-ins: ASIN ACOS ATAN SINH COSH TANH HYPOT POW CBRT EXPM1 LOG1P E TRUNC SIGN COPYSIGN CLAMP FMA IS_NAN IS_INF IS_FINITE INF NAN ULP NEXT_AFTER IS_CLOSE EXACT MAX_VALUE MIN_VALUE EPSILON GCD LCM BIT_AND BIT_OR BIT_XOR BIT_NOT SHIFT_LEFT SHIFT_RIGHT WRAP. They stay usable as names (a variable E, a FUNCTION GCD): the program's own wins. - vcgen: an overflow obligation on every sized result, then the range as a fact (also for sized parameters and loop-cut variables); FLOAT32 arithmetic as its own uninterpreted functions, constants rounded exactly, TOFLOAT32(v) otherwise; argument obligations for SQRT, the logarithms, ASIN/ACOS, LOG1P, CLAMP and the shifts; nothing proved under USE IEEE. - testing: the fuzzer tries the edges of a sized type and generates FLOAT32 values. - pseudo-to-mojo: Int8..Float32, conversions, the new built-ins through std.math (each name in the harvested index), a note where Mojo wraps. - Tests: numeric.test.mjs; corpus 49-52; prover fixtures int8-overflow, float32-store, ieee-nan; the reference documents every new form. Gate: 324 pass (core). New Mojo uses std.math names the interpreter has not been verified on (listed in sync-mojo's KNOWN_GAPS); they need pixi run mojo-verify on the network before the interpreter runs them. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01FgvbRdoEheAHqsRmr2WuKZ
pplus-core
pplus-core is the part of Programming+ that has to be right: the languages, the translators between them, the Mojo checker and interpreter, the prover, the fuzzer, the x86-64 machine model, and the stored answers of the real tools that everything it says rests on. It has no DOM. pplus-web (the site, the editor, the views and the Quarto extension) and the course site use it as a pinned dependency.
- Languages: pseudo (parser, checker, interpreter, the English reader for lingo), matho (equations in LaTeX), speco (specifications), Mojo (a checker and an interpreter held to the real compiler), x86-64 on a model machine with caches, a pipeline and an out-of-order core.
- Translators: pseudo to Mojo, lingo, matho and speco, with line maps and located refusals, and the hub that keeps the linked languages in step (
src/sync/). - Verification: the prover (
src/engines/pseudo/logic.ts,solver.ts,vcgen.ts), sound and held to it by tests; the fuzzer (src/common/fuzz.ts); and a pinned Dafny (scripts/dafny.py). - Stored answers: the Mojo corpus (
mojo/): material harvested from Modular's repositories at pinned commits, our own probes and programs, and godbolt's answers for every one of them (mojo/golden/). - A workspace:
src/common/workspace.tsis one piece of work and everything its sources mean. pplus-web's session extends it. - A command line:
pixi run cli check|run|prove|fuzz|translate <file>.
Everything it says about Mojo is pinned to Mojo 1.1.0 and checked against the real compiler on Compiler Explorer.
Quick start
With pixi (it brings the pinned Mojo, Node and Python):
pixi run test # build, then every test
pixi run ci # the gate: every test, and no Mojo program of ours failing
pixi run cli prove tests/corpus/27-quantifiers.pseudo
pixi run dafny-fetch # once: the pinned Dafny, into .tools/
Without pixi, with Node 20 or later (and python3 for the pipelines' tests):
npm install && npm test
Commands
Every command is a pixi task (pixi task list shows them with their descriptions). tests/tasks.test.mjs fails if this table and pixi.toml disagree.
| Task | What it does |
|---|---|
| Build and test | |
install |
Install TypeScript, the only npm dependency |
build |
Compile src/ to dist/, with type declarations for pplus-web |
watch |
Rebuild dist/ on every change |
check |
Type-check only |
test |
Build, then run every test, the pipelines' Python tests included |
cli |
pplus check|run|prove|fuzz|translate <file>: core without a browser (scripts/cli.mjs) |
engines-diff <static> |
Show what a course checkout has not taken yet from the engines (docs/engines.md) |
engines-export <static> |
Copy the engines into a course checkout, TypeScript modules as built (docs/engines.md) |
| Dafny, pinned (scripts/dafny.py) | |
dafny-fetch |
Download the pinned Dafny into .tools/, checked by SHA-256 (network, once) |
dafny |
Run the pinned Dafny with the arguments given, e.g. pixi run dafny verify file.dfy |
| Write content | |
new-exercise <id> |
Start an exercise whose Mojo lives in mojo/local/<id>.mojo (docs/exercises.md) |
new-probe <name> <question> |
Start mojo/probes/<name>.mojo: one question about the compiler (docs/mojo-corpus.md) |
new-stress <name> <about> |
Start mojo/stress/<name>.mojo: realistic Mojo that tests the interpreter |
play <name> |
For mojo/local/<name>.mojo: run, verify on godbolt, build, list the assembly, test |
play-watch <name> |
The same, again on every save (tests off) |
| The Mojo corpus (docs/mojo-corpus.md) | |
mojo-verify |
Ask godbolt about every program with no answer yet (network) |
mojo-verify-item <id> |
Ask again about one item, e.g. 'probes/life-*' (network) |
mojo-verify-dry |
Show what mojo-verify would send; send nothing |
mojo-verify-diagnostics |
Also check the compiler's own diagnostic tests (opt-in; network) |
mojo-status |
Judge every item from the stored answers, offline; writes mojo/golden/STATUS.md |
mojo-status-strict |
The same, and fail if a program we wrote fails |
mojo-harvest |
After editing mojo/pin.json: fetch Modular's sources, process, regenerate (network) |
mojo-harvest-local [dir] |
Harvest, with zips standing in for sources the pin leaves unresolved |
mojo-harvest-offline [dir] |
Harvest from zips only, no network |
mojo-fetch |
Re-resolve every ref in the pin and rewrite the lock (network) |
mojo-emit |
Regenerate src/mojo/generated/ and syntax/mojo.xml from the pin and corpus, offline |
mojo-test |
The corpus pipeline's own tests |
mojo-run <file> |
Run one Mojo file on the pinned local compiler |
mojo-probes-local |
Run every probe on the local compiler (a quick look) |
mojo-update |
After editing the pin: harvest, verify, status, test |
| Ship | |
ci |
What CI runs: every test, and no program of ours failing |
package |
Zip what git tracks, and nothing it ignores, into package/ for sharing |
Where things are
AGENTS.md rules for changing core (read first)
src/
common/ the workspace, the problem catalog, the fuzzer, the run view's data, the language
reference, the machine presets, the shared types
engines/pseudo/ the pseudo language and the prover (logic, solver, vcgen in TypeScript), and the course's
page widgets for it (excluded from the build; see docs/engines.md)
engines/asm86/ the x86-64 model machine, and the course's widgets that draw it (views, hwviews)
engines/shared/ text helpers, and the course's DOM helpers
services/ one adapter per language behind LanguageService; the compiler request and backend
sync/ the translators and the hub that keeps the linked languages in step
mojo/ the Mojo checker, interpreter, lifetimes, practices, AT&T-to-Intel; generated/ from the corpus
exercises/ one file per catalog problem
curriculum/ a lesson corpus kept as an interpreter fixture
syntax/mojo.xml the Mojo words as a KDE syntax for Pandoc (generated; pplus-web copies it)
tests/ node --test against dist/; corpus/ (pseudo programs), prover/ (soundness regressions)
mojo/ the Mojo corpus: the pin and lock, harvested material, our programs, godbolt's answers
scripts/ the tasks above; scripts/mojo/ is the corpus pipeline; dafny.py the Dafny pin; cli.mjs
docs/ the documents below
Read next
| Document | For |
|---|---|
| AGENTS.md | Rules for anyone changing core, coding agents included: the gate, what not to edit, conventions |
| docs/engines.md | The engines, the prover and its soundness, and how the course takes them |
| docs/trust.md | Every verdict core produces: which tool earns it, what it means, and what it does not mean |
| docs/mojo-corpus.md | Writing Mojo of our own and moving to a new Mojo version |
| docs/exercises.md | Adding a catalog problem |
| docs/sync-coverage.md | What each translator can say, written by the tests |
| docs/asm-coverage.md | Which instructions compiled Mojo uses, against what the machine models |