alexm 3c5097d9d0 A UX pass over the workspace, and two defects it turned up
Walking the site as a student (desktop, a phone-width screen, dark) found
these. Each is small; together they are what got in the way.

Defects:

- Opening a problem in the Bridge saved the generated Mojo over the
  exercise's own program. The workspace fills every pane's editor as it
  opens, the editor reported that as typing, and the Bridge's read-only
  Mojo pane holds the generated text. Developer then showed generated
  Mojo labeled "your edits", and the problem counted as edited. The
  value setter now marks its change as a load, the change listener
  leaves loads out, and a Bridge session refuses a Mojo edit.
- A page opened at #/#problems or #/#reference stopped about 45px past
  the heading: the fonts arrived after the place was computed. A page
  built this moment goes straight to its section and finds it again
  when the fonts are in; a page already on screen still scrolls there.

The workspace:

- With no run to step, the Run view said "Nothing to run yet." It and
  the stepper now give one reason (src/core/norun.ts): how many problems
  the stepped pane has and the first with its line, with a button to the
  line and the Problems list; or that the pane is empty.
- In the Bridge the dock starts at about a quarter of the height (it
  holds a call, a line of output, a short list), so the code and the run
  get the room. Developer keeps a third for the compiler's answer. A
  double-click on a divider returns to the area's default, not to the
  student's last position.
- The reason a pane is not in step wraps instead of ending in an
  ellipsis, and a button in the pane's head keeps its words on one line.
- A problem that does not exist keeps the site's navigation and links
  the problem list.
- Help, the theme switch and the stepper's first, back, step and last
  buttons have names a screen reader can say.

A phone-width screen:

- The toolbar is three rows in every area and on every tab (it was four
  or five): the mark, the area, help and the theme; the problem,
  Versions and Reset; the actions. About 30px more of the code shows.
  An embedded workspace keeps its own toolbar.
- The Share dialog puts each row's name above what it holds (a note had
  been squeezed to a word per line), and the Versions menu opens across
  the screen instead of running off its right edge.
- The stepper's speed label stays with its slider.

Checked by hand, in headless Chromium at 1440x900, 1366x768, 390x844 and
320x640, light and dark: each state above before and after; the editor
has line numbers and highlighting; the stepper steps; embeds
(playground, trace, Developer) are unchanged; 31 smoke scenarios clean
but the ones that err on purpose.
2026-11-13 06:27:00 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00
2026-11-12 22:24:02 -05:00

Programming+ (pplus-web)

Programming+ takes a procedure from an idea to Mojo to the machine. It is built for a world where writing code is easy and knowing what it does is the job. It has three areas (src/core/areas.ts):

  • Bridge: write the procedure as plain-English steps (lingo), equations written in LaTeX (matho), pseudocode precise enough to run, prove and translate (pseudo), or a specification you prove against (speco); the others follow as you type, and Mojo is generated from the pseudo, always labeled as generated.
  • Developer: Mojo only. The checker's advice as you type; every step and every value of the Mojo that Programming+'s interpreter reads (a subset of the language: it says why when it declines a program) in one Run view; a fuzzer that lists what it tried; and the real Mojo compiler's answer, from godbolt.org.
  • Hardware: the code beside a board you arrange, on a model machine: registers, memory, the stack, cache lines, the caches, virtual memory, the pipeline and the out-of-order core, with Mojo and its x86-64 as tabs, linked line by line. Its cycle counts are a teaching model, not a measurement of a real processor.

A library of verified routines (statistics, numerics, sequence alignment, molecular simulation, sequences, special functions; #/library) comes with it, each one usable by name with USE and open to step through, and so does a catalog of worked problems, each opening in every area it has something to show in, and any view can be shared as a link or embedded in a page. With Quarto, a page can also run a program kept beside it while the page renders, and show the run, a stepper, the flowchart, the proof and the rest without an iframe, down to the machine itself (registers, caches, the pipeline, the core, stepped). The With Quarto page (#/quarto) is a gallery of every shortcode.

It is a static single-page app: TypeScript compiled by tsc, no bundler, no framework, and no npm runtime dependency (CodeMirror 6 is vendored as one built module, src/vendor/). The site serves its own fonts and asks no other host for anything, except that Compile & run sends the Mojo pane and its input to godbolt.org, after asking the first time. This repository is the site; what programs mean (the languages, the translators, the Mojo checker and interpreter, the prover, the fuzzer, the machine model, and the stored answers of the real tools) is pplus-core, a project of its own, kept here as the git submodule core/ and imported as #core/... (core/README.md). Everything it says about Mojo is pinned to Mojo 1.2.0: core's checker and interpreter are held to the real compiler's answers (Compiler Explorer) on every program in core's corpus, and Compile & run asks the compiler about any other.

Quick start

Clone with the submodule (git clone --recurse-submodules, or git submodule update --init in an existing clone). With pixi (it brings the pinned Mojo, Node and Python):

pixi run dev      # build, then serve on http://localhost:4173
pixi run test     # build, then every test

Without pixi, with Node (pixi pins 26; package.json asks for 20 or later, which nothing tests), python3 for npm run dev's server, and pandoc 3 for the Quarto extension's tests (without it they are skipped and say so):

npm install && npm test
npm run dev

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. Core's own commands (the Mojo corpus, play, the CLI, the pinned Dafny) are in core/README.md and run with pixi run --manifest-path core/pixi.toml <task>.

Task What it does
Build and test the site
install Install TypeScript, the only npm dependency
core-build Build pplus-core (core/) into core/dist/, which the site imports as #core/
core-test Run pplus-core's own tests at the pinned commit, before moving the pointer (the deploy job does not run them)
core-status Core's mojo-status-strict at the pinned commit: no Mojo program of ours fails (offline)
build Build core, then compile src/ to dist/
watch Rebuild dist/ on every change
check Type-check only
dev Build, then serve on http://localhost:4173
test Build, then run every test of the site
check-pages <dir> Run every program embedded in the Quarto pages under a folder (quarto/README.md)
Quarto
quarto-export <name> <dir> Copy a core/library/mojo/local/ program, its x86-64 and setup beside a Quarto page, and print the shortcode
quarto-css Regenerate the extension's generated files (a test fails while they are out of date)
quarto-engine <dir> Copy a built Programming+ and core into a site's _extensions/pplus/engine, for the rendered views (quarto/README.md)
quarto-example Render the example site in quarto/example, every shortcode on real pages (needs Quarto)
Ship (docs/deploy.md)
ci What the deploy job runs before it publishes: every test of the site, and core's mojo-status-strict at the pinned commit
release-check Is the chain web → core → library consistent: each pointer checked out, clean and on its pushed branch, generated files current, Mojo pinned alike
release-bump After a change in core/library or core: move the pointers bottom up, regenerate, run each gate, print what to push in order (--commit commits; nothing pushes)
site Test, then assemble site/
caddy-check Serve the assembled site/ with a real Caddy under docs/Caddyfile and hold its headers, caching and missing-path answers
package Zip what git tracks, and nothing it ignores, into package/ for sharing
deploy [slug] [target] Publish site/ to /srv/www/<slug>, optionally over SSH

Where things are

AGENTS.md                rules for changing the site (read first)
index.html, styles.css   the page (with the import map that points #core/ at core/dist/) and the app's stylesheet
core/                    pplus-core, a git submodule: languages, translators, prover, corpus, and the library
                         (pplus-library, its own submodule core/library) (core/README.md)
src/
  main.ts                the hash router
  core/                  the app's state and its URL codec, the session (a core Workspace with storage, versions,
                         compiles and the helper), the catalog with areas, the areas, saved versions, preferences
  ui/                    the shell (one per area), the home page, the library, the "With Quarto" gallery, the editor, the embeds, the views
  ui/hw/                 the Hardware area's machine board, over the course's x86-64 views (from core)
  quarto/                the Quarto extension's rendered views: a program run and drawn by the views, as HTML (render.ts),
                         the small document they draw into outside a browser (dom.ts), the shortcode list (shortcodes.ts)
  vendor/                CodeMirror 6 as one built module; scripts/vendor/ rebuilds it
styles/course/           the course site's widget stylesheets, copied unchanged (and bridge.css, ours)
tests/                   node --test against dist/ (and core/dist/)
scripts/                 the tasks above
quarto/                  the Quarto extension (_extensions/pplus) and an example site using every shortcode (example/)
docs/                    the documents below, and the Caddy site block
scratch/                 ignored by git: a place for experiments
Document For
AGENTS.md Rules for anyone changing the site, coding agents included: the gate, what not to edit, conventions
docs/app.md What the app does: the three areas, translation between languages, its links, and how embeds behave
docs/deploy.md Building the site and publishing it to the droplet
quarto/README.md Embedding views in a Quarto site
core/README.md pplus-core: the engines, the prover, the Mojo corpus, the CLI, the pinned Dafny, and their docs
core/docs/trust.md Every badge and verdict the app shows: what earns it, what it means, and what it does not mean

License

Copyright 2026 Scientific Computing Studio, LLC, under the Apache License 2.0 (LICENSE.md); NOTICE.md has the notices and a disclaimer of affiliation with Modular, and THIRD_PARTY.md lists what is not ours and its licenses.

S
Description
No description provided
https://pplus.scient.ing/
Readme Cite this repository
5.5 MiB
0 Stars 1 Watchers 0 Forks
Languages
TypeScript 48.6%
JavaScript 24.8%
CSS 22%
Lua 3.6%
Shell 0.3%
Other 0.6%