T01 · authoring
Docs and authoring: the docs describe code Rune doesn't have, examples skip the fast patterns, and a view edit takes about 8 s to show
54 issuesphases 0-46 existing issues
PLAN.md, the READMEs, the site and WEB.md describe a render thread, a rope, a native IME protocol and Slug text that the code at HEAD doesn't have, so authors design against parts that don't exist. Doc examples aren't compiled, 19 of the 30 examples have no headless test, and a saved view edit takes about 8 s to reach pixels. Closing this theme gives an app author docs that a script keeps true, compiled examples that teach the fast patterns, one prelude per crate, misuse errors that name the author's own line, and a view edit that shows in about a second.
Done when
Phase 0
rg -n 'render thread|command channel|sum_tree|rope|Slug' over PLAN.md, README.md, the crate READMEs and Cargo.toml descriptions, crates/rune-motion/src, site/src and WEB.md returns only lines labelled Target or stated as future. PLAN section 3 states the presenter gate: build a presenter only if main-thread-busy drops stay above 0.5% of motion frames in a flagship workload after the named stalls are fixed. The 1% figure in the perf and architecture notes is brought in line in the same PR.- Every README Measured number names its rev, date, backend and machine, and scripts/measure-readme reproduces it. Unmeasured PLAN section 8 rows say they are unmeasured. PLAN's Mac memory target is hello at or below 30 MiB phys_footprint, with private-working-set and PSS targets for Windows and Linux. Every PLAN guarantee and hot-reload row has a status: done, partial, or planned with an issue.
- scripts/doc-claims runs from scripts/file-size.sh in under 5 s. It covers PLAN sections 1-3, README Differences and Measured, crate descriptions, the site architecture pages and WEB.md, and every canary fails as expected. 0 claims stay pending after their phase-0 issue closes. ARCHITECTURE.md is under 300 lines, and a probe checks its owner and thread tables. The Text input, Layout and CSS, and examples index pages are published.
- A public targets page defines every target the roadmap cites, with its threshold, hardware, lane and the issues that prove it. Where two sources give different numbers for one target, the stricter number governs and any looser number is labelled interim.
Phase 1
- rune, rune-kit and rune-motion have 0 ignore fences, and README.md, the crate READMEs and the guide pages have 0 uncompiled Rust blocks. A temporary ignore has a reason and sits under a ceiling that only goes down, to 0. T1 extracts the site snippets whenever a file they read changes, and a missing_docs ratchet runs in T1 and the platform lanes.
- All 30 examples are listed in examples/README.md and compile in T1. Each has a sibling headless test that asserts an interaction or state change, and the examples-check list of untested examples is empty. T1 runs every headless command the index lists, and app-audit --strict has 0 unsuppressed findings, each suppression with a reason. No example parses Rune's flags itself, and hello imports only the preludes and follows the system appearance.
scripts/rune-dev hello patches a view edit on a fresh machine with only the documented prerequisites, building locally by default, and no machine names remain in scripts/. A smoke test patches hello and an outside fixture app on macOS, Linux and Windows, keeping state and scroll. A patched poll, key or IME handler that panics is not retried with the original code; it reports the panic and follows the failure policy.
Phase 2
- Every example and kit-gallery view compiles with rune::prelude::* and rune_kit::prelude::* plus at most one more rune or rune_kit use line. Each prelude holds 40 names or fewer and shares no name with the other prelude or with std's. Every same-named type pair is renamed with a deprecated alias, or listed in docs/api-map.md with a one-line distinction, and the API map regenerates with no diff. No guide page is over 500 lines. missing_docs is denied with a count of 0 on macOS, Windows, Linux and wasm32, and each example builds in every platform lane its index row declares.
- api/panic-inventory.txt has 0 unclassified entries. In debug builds, every app-misuse entry has a test whose message names the app's file:line and the fix; in release builds the same mistake warns once and does not panic. A handler, on_edit accessor or virtual_rows row typed for another state warns at commit with its call site, before any input. Inserting at the front of an unkeyed dynamic list warns with the .children call site. Uncoloured text meets 4.5:1 contrast in both appearances. Compile-fail cases with fix text pin the 10 most frequent Rune-Bench compile failures.
- The hot-reload output line carries per-stage stamps, and a weekly lane publishes per-stage and total p50 and p95 on macOS, Linux and Windows over a committed corpus of 30 edits.
Phase 3
- On an Apple-silicon Mac, save-to-presented-frame p95 for a view edit is at most 1 s. Linux and Windows reach a median of at most 2 s. 100% of measured edits keep state and scroll, and an edit to an impl method body patches without a restart.
- Rune-Bench (at least 40 tasks, a pinned model, 3 runs per task) and its SwiftUI port are committed with 95% intervals and run at each changelog fold. A fold is blocked when either first-try rate drops by more than 5 points and the interval excludes 0.
Phase 4
- Rune-Bench first tries compile in at least 85% of tasks and match the expected tree in at least 75%, each at least the same model's SwiftUI rate, for three folds in a row. Import errors cause at most 2% of compile failures, and every failure class above 3% of tasks has a linked issue.
T02 · merge-gate
CI: no required check gates dev, so broken builds and unannounced API breaks reach the revs apps pin
47 issuesphases 0-35 existing issues
No required check gates dev. At a9da7e3e the documented test command fails 7 rune-kit tests and no CI job runs it, so a red build or a removed public item can reach the revs that apps pin, and apps have no tagged release to install. Closing this theme means every dev commit passed one required pre-merge verdict, called T1 in these issues, that agents and CI share. A public API break can't land without a Breaking fragment and a migration, and apps can install tagged 0.x releases.
Done when
Phase 0
- A Stability page, linked from README and AGENTS.md, defines a stable tier and an unstable tier. It says how a break is announced (a Breaking fragment), that a deprecated stable name stays for at least one changelog fold and 30 days, and what the MSRV policy is. Each rule names the check that enforces it.
- cargo test -p rune -p rune-kit --features rune-kit/markdown exits 0 at dev HEAD on macOS and Linux, and no test was deleted, ignored or weakened to get there.
- A readiness ledger gives every prerequisite outside the code (hardware, accounts, certificates, the registry name, the accessibility audit and upstream changes) an owner role, a start-by phase, a proof that it is ready and a fallback. It is reviewed at each phase exit.
Phase 1
- dev advances only through the merge queue, with the T1 jobs required in the ruleset. 100% of dev commits carry a green T1 verdict, with 0 direct pushes over 30 days. Every admin bypass gets a green T1 run on its SHA within 2 h, and scripts/verify audit-dev, run weekly, reports 0 uncovered SHAs.
- Over the first 50 warm runs on hosted runners, T1 has a p50 of at most 15 min and a p95 of at most 25 min.
- T1 runs scripts/verify t1 with nextest. It covers the whole headless suite on Linux lavapipe with 0 GPU skips, the macOS suites on Metal with 0 skips, the Windows unit tests, the 4 scripts/ suites, the accessibility unit tests and the Kit accessibility goldens. It reports 0 inventory targets unrun, including feature-gated and harness = false targets.
- Every row of scripts/ci-matrix.toml is checked on every PR and merge group: 10 target triples with default and no-default features, plus hot, each feature and the web-hello wasm build. The webgl and rune-fx wasm32 jobs become required within one merge after #115 and #119 close.
- These are required T1 checks: semver-checks for rune, rune-kit, rune-motion and themes/opencode on 4 targets with default, all and no-default features, against a named baseline; committed per-target API snapshots; frozen exhaustive-literal tests for 100% of api/literal-types.list; and a canary app and a frozen legacy app that build in their own workspace with their own lockfile.
- Each of these fixture PRs fails T1: one that removes or changes a public item without a Breaking fragment and a compiling migration, and one that drops a deprecated alias before its window ends. The fragment backlog is folded, every folded entry carries its rev, and running the fold twice changes nothing.
- taffy is pinned to =0.15.0 and winit to =0.30.13 in every manifest that relies on their internals, and a test covers every CompactLength variant through Taffy's public API.
- Merge-queue candidates on the self-hosted Mac run as a user with no credentials, with caches split by trust level and reset between levels. Promotion, signing and issue filing run only on hosted jobs that validate the artifacts they read. A hardening drill with a malicious merge-group candidate reaches no secret and no cache that later dev jobs use.
Phase 2
- semver-checks attributes each PR's own breaks against its merge-queue parent, and checks the range from the verified rev to the candidate against merged Breaking fragments. A fixture with two queued PRs blames only the PR that made the break. Until this lands, the baseline stays the merge base.
- T1 fails on growth in clippy (at -D warnings for every matrix row, with the 3 relaxed lints back at deny), cargo fmt --check for every crate, crate-deps, duplicate dependency versions, file-size (soft-cap warnings under a ceiling that ends at 8 or fewer, any test file over 1,000 lines, any folder over 40 files) and arch-ratchet.
- Every skip goes through skip_unless!, and its count is reported. At most 10 flaky tests are quarantined, each for at most 14 days, and flaky runs stay at or below 0.1% of executions. Changing a protected path, removing a test or raising a ceiling without an evidence trailer fails. actionlint and zizmor report 0 high findings, 100% of actions are pinned by SHA, and a drill shows that no self-hosted job can be reached from pull_request events.
- Every rev records the stripped hello size, the brotli wasm and cold-load sizes, and the package and duplicate counts, and T1 fails a rise without a fragment or trailer (above 3% for brotli sizes). A fixed runner records clean build time per rev, and that lane fails a rise above 10%.
Phase 3
- Every crate in the publication closure declares and inherits rust-version, is green on the MSRV lane on 4 targets, and passes cargo publish --dry-run and a docs.rs-equivalent doc build. A tagged 0.x release cut from the verified branch installs with cargo add and builds hello on macOS, Windows and Linux, and releases ship at most 31 days apart while dev changes.
T03 · platform-lanes
CI: nothing runs Rune's own tests on macOS, Windows, Linux GPUs, browsers or iOS after merge, so apps pin revs no platform lane checked
43 issuesphases 1-329 existing issues
The macOS GUI tests are opt-in, and no job runs Rune on a Windows or Linux GPU, in a browser or on the iOS simulator after merge. A regression in pacing, pixels or a platform API ships in the revs apps pin, and no one learns which commit caused it. Closing this theme gives apps a verified branch that moves only to a SHA every lane passed, a named culprit for every red lane, and reserved hardware that enforces the latency and wall-clock targets.
Done when
Phase 1
- The 19 macOS GUI tests and the Windows, Linux and browser GUI jobs run on every push to dev and report within 2 h. No job may fail, and 0 tests are quarantined. Until the report broker lands, a red lane opens at most one issue per culprit range, with metadata only.
- The reserved ProMotion Mac lane reports input-to-present p50 and p95 and missed presents for every candidate rev.
Phase 2
- All 5 platforms and their variants run on every push to dev with 0 skips for declared resources under RUNE_TEST_STRICT=1. Each desktop lane runs its accessibility-API test (roles, names, an action, focus and a state change), and the web lane asserts the DOM mirror.
- A committed capacity model gives each reserved machine its service times and reserved slots, and sizes batches so that the promoted SHA itself is still tested. One committed lane manifest names every machine, including a UHD 620-class low-end reference. The verified branch and both bisectors schedule through it before the 3 h lag below is promised.
- The verified branch moves only by fast-forward, to a SHA whose own artifacts passed every lane, and apps pin it. Dev-to-verified lag p95 is at most 3 h over 30 days. A red lane is classified, bisected to a culprit and reported within 3 h.
- One report broker files every lane, bisector, fuzzer and speech-lane failure. It keys incidents by signature and culprit, aggregates lanes, keeps infrastructure failures apart and rate-limits repeats. Public issues carry only allowlisted fields, and raw evidence stays in restricted artifacts.
- The renderer lanes for native Metal and wgpu Metal, DX12, lavapipe on X11 and Wayland, WebGPU and WebGL2 in Chromium and WebKit, Safari and the iOS simulator are green on every verified rev, with 0 skipped GPU tests and the expected adapter in each manifest. Native Metal output matches wgpu Metal.
- Lanes show that a hidden window gives its memory back on macOS, Windows, X11 and Wayland, and that a covered or minimised window presents 0 frames. The first-use suite runs cold and warm every night.
- A scene lays out with identical rect digests on all 5 targets at equal scale.
- Every platform's lanes stay green for 30 consecutive days of merges, with oldest-version lanes run weekly and before each changelog fold.
Phase 3
- Lanes on real NVIDIA, AMD and Intel GPUs join, so 11 of 11 renderer lanes are green on every verified rev. Canonical scenes agree within 2/255 across backends and vendors.
- Wall-clock suites run nightly on macOS, Windows, Linux, the web and iOS, and weekly on the low-end lane, pooled over at least 5 paired runs. Every number records rev, backend, device and date, and a paired regression is bisected and reported.
- Input-to-present latency and cadence are measured on Windows and Linux on all three GPU vendors and on a hybrid-GPU laptop.
- The photon rig calibrates key-to-photon latency within 0.5 ms each quarter. Native-peer baselines give every 'matches native' row a number, and live-resize capture shows 0 frames the native peer would not show.
T04 · headless-verification
Verification: headless runs use five frame loops, goldens are machine-bound, and no count budget or motion finding fails a merge
73 issuesphases 1-310 existing issues
Headless runs go through five frame loops and two script dispatchers that drift apart. Goldens hold on one machine only, frame cost has no exact counters, and no motion-audit finding fails a merge. A regression in work per frame or in motion can pass CI, and a coding agent can't trust what a headless run shows. Closing this theme gives one headless driver that behaves the same in every mode, one golden set on every OS, count budgets and the motion audit as required checks, and a session that drives, inspects and replays a running UI.
Done when
Phase 1
- Counters exist for view runs, layout passes, pipeline creations and GPU bytes. The motion audit fails on a finding. A committed budget matrix maps every PLAN section 8 target to a scene, a probe and a check.
- --native --script replays a script in a macOS window, with OS-injected input stamped into the frame record. Every input and IME recorder drops secure-field content and length, home paths and tokens, and a T1 check covers the committed fixtures.
Phase 2
- Every runner uses one HeadlessHost that drives frames through SurfaceHost. Every script event and flag behaves the same in single-window and --desktop runs, and no flag is accepted and then ignored. A mid-run error keeps the outputs already flushed, and machine output is structured and schema-checked.
- Count budgets on at least 12 canonical and worst-case scenes are required in T1, and a seeded regression in each counter family fails. Every host kind makes 0 frames, submissions and self-wakes over 10 s of settled idle, and soak overhead stays flat.
- Every motion-audit scenario runs as a test on every merge under one Rust rule set, with rate-jitter, reduced-motion, idle and first-use passes. A finding fails unless a bounded allow row with a reason covers it, and debug and release builds record the same commits.
- One golden set is byte-identical on macOS, Linux, Windows and wasm32 in the CPU-only canonical lane. Every artifact carries a provenance envelope outside its payload hash, and normalized spring traces are bit-identical across aarch64, x86-64 and wasm32.
- Work started in setup is deterministic in the canonical lane. A canonical scripted run of live-values gives byte-identical payloads across 20 runs, also with a 50 ms delay injected in its producer. A wake from an unmanaged setup thread fails the run and names the setup function, and no example parses argv to decide whether it is headless.
- Every subsystem in the oracle matrix is differential-tested on generated inputs on every merge.
- Every rect change in a story, eligible example or scripted interaction is caught at merge and needs a changelog fragment, and CI never writes goldens.
- The Markdown streaming differential runs at least 256 generated documents per T1 run with random UTF-8 split points. At every checkpoint the incremental stream state matches a from-scratch streaming parse of the same prefix, and the final tree, find matches and selection match a one-shot render. Growing single-paragraph, long-fence, table and late-reference fixtures are included, and the test fails on the parent of the #190 fix.
Phase 3
- 14 of 14 instance kinds and 2 of 2 blend modes have rune-ref oracle arms, and a new KIND_* constant without one fails. Mutation scores and Miri runs are published nightly.
- A coding agent loads a scene, sends input, steps the clock and queries the tree through a versioned session without relaunching, and every script event and flag behaves the same in session runs as in single-window runs. 100% of keyed nodes carry file:line. Recorded replays match at every checkpoint, rebuilt from a scene name or AppSpec init plus recorded external results, with no serialization bound on app state. --check runs the layout lint, motion gate, app-audit and golden diffs and prints one structured result.
T05 · failure-and-trust
Failure: a lost GPU, a refused surface, a panic or hostile content can end or freeze a shipped app, and no diagnostics channel lets an app read the failure
39 issuesphases 1-310 existing issues
A refused surface configure or a Lost surface can panic, a lost GPU device can end the app, and an SVG or Markdown bomb can hang it or make it read local files. Errors go to stderr, which an app launched from Finder or as a Windows GUI app never shows. Closing this theme gives every failure class one defined outcome and one report path, recovery from device and surface loss without a restart on every backend, and one trust boundary with byte, count, depth and time budgets for untrusted content.
Done when
Phase 1
- A refused configure, a lost surface, and an SVG or Markdown bomb no longer panic, hang or read local files. Failures reach a diagnostics channel that apps launched from Finder and Windows GUI apps can see. The failure-model page records today's outcome for every callback family, including the non-unwinding extern callbacks that still abort until the FFI guard lands.
Phase 2
- On the 6 configurations other than the two iOS LayerHost backends and Safari WebGPU, an injected device loss gives 0 panics, 0 unresponsive windows and a correct frame within 500 ms native and 1,000 ms on the web. State, scroll and focus are unchanged, and 3 losses in a row recover.
- No acquire or configure result ends the app. A recreated surface draws within 2 frames of a restoration event, and after 3 failed tries it retries at most once a second. No surface call or GPU wait blocks the main thread for longer than one refresh.
- Each failure class has its documented outcome, one report path and a passing injection test, run in a child process, on macOS, Windows, Linux, the web and LayerHost. Every lock taken in a callback or Drop either has a stated reason its data stays valid after a partial update, or invalidates its owner when poisoned. There are 0 production eprintln! calls outside the diagnostics module and 0 allocation expect calls in native Metal.
- Every rendering fallback emits one diagnostic and increments a counter.
- Every link sink classifies URLs through rune::trust with its own policy. Every untrusted input has a budget and an adversarial test that fails in under 100 ms. Release builds ignore dev argv and an ambient OTEL endpoint, and control channels bind to loopback and check Host.
- fuzz/README.md maps every input in the trust inventory to a target. At least 12 targets run nightly: Markdown streamed and whole, DiffView, Mermaid, highlighting and TextEdit driven through Runtime commit and layout, SVG to pixels, HTML paste, RTF paste, CF_HTML, URLs and script JSON. Each runs for a time set from its measured rate, to reach 10 million cases per target per week in debug and in release, with executions and coverage logged. A crash issue older than 7 days fails the job, the target of zero release panics counts as met only while no crash issue is open, and every fixed crash becomes a corpus case that T1 replays.
- No content path depends on catch_unwind on wasm32. A 10,000-source Mermaid fuzz finds 0 panics in under 60 s, and the wasm smoke test draws each source that crashed before as code while the page stays alive.
Phase 3
- The two iOS LayerHost backends and Safari WebGPU meet the same device-loss bar, so 9 of 9 configurations recover.
- In debug builds, native Metal returns validation errors of the kind wgpu reports instead of panicking.
T06 · runtime-core
Runtime: one 255-field struct generic over app state holds every subsystem, frames scan every node, and kit memory lives in thread_locals
36 issuesphases 1-45 existing issues
Runtime<S> is one struct of 255 fields, 28 of them pub, and it is generic over app state. Every subsystem can reach every other, apps read its fields directly, and a new state type adds codegen for the whole runtime. Per-frame bookkeeping scans the whole node tree, and kit components keep memory in thread_locals, so two windows share and evict each other's state. Closing this theme gives a thin wrapper over a non-generic core of owned subsystems with private state, per-feature index lists, and component memory that belongs to the runtime that drew it.
Done when
Phase 1
- When the focused control is removed, focus moves to the neighbouring stop, while focus_return and modal restore still win. Disabled beats focus and press in either builder order, read-only fields refuse SetValue and ReplaceSelectedText, and a modal opened mid-drag delivers exactly one cancelled Phase::Up. Each has a test in the merge gate.
- scripts/compile-budget gives identical rune-owned LLVM-line counts on reruns, T1 fails above the ceiling, the macOS lane records the incremental-rebuild median, and the numbers are posted on #124.
Phase 2
- No kit thread_local holds mutable per-surface state; the arch-ratchet kit count covers only listed immutable constants. Two windows with the same keys keep independent RollingText, ScrollBar and Markdown and syntax state, and a 300-area test keeps a bar mid-drag. Each store evicts on its own runtime's generation, holds entry and byte limits, reports its bytes, and reads 0 after its runtime drops.
- rune-kit references 0 doc(hidden) rune items, with a ratchet ceiling of 0. cached, digest, snapshot and component::with_store are documented and in the API snapshot.
- In the gated board and table scenes, nodes visited per animating frame stay at or below changed plus visible. The debug path-scan counter reads 0 for key, hit, gesture and secondary events on a 10,000-node tree, and a hover move visits at most both hit chains plus the group members it enters or leaves. Loops, sticky, flights, drawn rects, visible rows and scroll viewports iterate their own lists, each checked against a full scan by a debug assert.
- No two nodes share a path, including keys that contain '/', '#' or '%' (fuzzed). A bare key that matches more than one node warns in debug with both paths and call sites, and release resolves it to the documented first match. Two SplitViews and two rows with menus each resolve to their own nodes through the scoped forms, and the gallery and examples emit no ambiguity warnings.
- Tooltips from El::help, Kit Tooltip and HoverCard show on keyboard focus and stay while hovered, and Escape dismisses them without moving focus.
- A scripted live-only scenario gives identical FrameStats commits, view runs and instance streams in debug and release. Debug checks are counted separately in live_only_checks, and a check leaves memo, stores, virtual ranges and the request queue unchanged.
- The Pointer, Focus and TextInput, drag-out and clipboard, Motion, Paint and Reports, and Tree families have left struct Runtime, with field ceilings lowered in arch-ratchet. The has_* post-apply pass is gone in release, and stub invariants run in every debug commit. frame_step is a set of named phase methods of at most 80 lines each, with tests that record their order. Every pub field except state has an accessor and is deprecated, reduced_motion has a working setter, and no code in the repo reads a deprecated field.
Phase 3
- Runtime<S> has at most 8 fields, 0 pub(crate) fields and 1 pub field (state). At most 15 non-test files hold impl<S> Runtime<S>. Every subsystem that owns state has only private fields and a compile_fail doctest.
- A second state type adds at most 5% of rune-owned LLVM lines, and the incremental rebuild after a one-line view edit has a median of at most 1.2 s on the reference Mac. If it misses, a decision on a wider crate split is opened with the measured numbers.
- runtime/frame.rs, runtime/commit* and runtime/input/* mention the playground 0 times, and hello builds with dev tools off. ARCHITECTURE.md classifies every production thread_local in crates/rune, with 0 per-surface entries and scopes that a guard restores.
- After a real or simulated memory-pressure warning on each desktop OS and on iOS, reclaimable bytes (text caches, component stores and transient GPU pools) return to their baseline within 1 s, with no frame over 8.3 ms during or after the trim.
Phase 4
- A go or no-go for each candidate crate split (rune-text, rune-shell, rune-tooling) is recorded with compile-budget numbers in research/ and on #124.
T07 · commit-and-layout
Layout: one commit can run the view dozens of times and mount every row, and grid beyond equal columns, baselines and right-to-left are missing
59 issuesphases 1-34 existing issues
One commit can run the view dozens of times, a virtual list can mount every row, and nothing proves that incremental layout equals a fresh layout. Grid templates, baseline alignment, sticky on every edge and right-to-left layout are missing, so an app that needs them can't match CSS or SwiftUI. Closing this theme makes each commit cost what changed, makes elision the default, keeps a 1M-row list inside its frame budget, and ships the CSS and SwiftUI feature matrix with right-to-left layout.
Done when
Phase 1
- 0 incremental-vs-fresh layout mismatches in at least 2,000 fuzz sequences per T1 run and 100,000 nightly. Miri runs clean on rune-taffy, and 0 safe calls read unchecked memory.
Phase 2
- No commit runs the view more than 3 times, and code enforces the cap. At least 99% of commits in each scene run it at most once, 0 re-runs are needed to fill a virtual window, and nothing mounts a whole list.
- Resize and virtual scroll relayout with 0 root view runs when the retained structure is unchanged, with images and fitted overlays on screen. md-resize layout is at most 2 ms p95.
- A 1M-row list with fixed or variable heights scrolls at CPU p95 at or below 1 ms (fixed) and 2 ms (variable). Its first viewport takes at most 100 ms, it realizes at most 200 rows, and appends are O(1).
- In examples/feed a keystroke or a streamed token runs the view at most once, and no memo version is computed by hand. The sampled cache differential check finds 0 stale hits, and every Fast apps rule in docs/fast-rules.toml maps to a line in the example that examples-check verifies.
- On a generated corpus of at least 500 trees, every element matches Chromium within 0.01 pt or falls in one of at most 10 documented deviation classes, and the static export equals the live layout.
- Tree explain, the layout lint and 5 misuse rules cover every gallery scene. The rules flag 50 of 50 seeded mistakes and 0 of 50 correct layouts, and no misuse panics a release build.
Phase 3
- A 100,000-column list meets the same budgets as the 1M-row list.
- The layout debug overlay covers every gallery scene.
- All 14 features of the layout matrix ship with builders and examples, right-to-left included. Sticky works on all edges and anchoring on both axes. A localized change costs only its dependency closure, and a tree 8,192 levels deep never crashes a release build.
T08 · text-engine
Text: typing reshapes and copies the whole field, undo loses its depth, and fonts and glyph atlases are rebuilt per window
48 issuesphases 1-417 existing issues
Each keystroke reshapes and copies the whole field, undo history loses depth, and each window builds its own fonts and glyph atlas. Typing slows as a note grows, and a second window pays again for the same glyphs. Closing this theme keeps typing inside one frame up to 1 MB, gives caret and selection each platform's rules, shares one font store per process and one glyph core per device, and matches each platform's text rendering.
Done when
Phase 1
- Flying text and resting text use the same coverage exponent.
Phase 2
- long_note type_mid keystroke and preedit p95 is at or below 2 ms at 50 KB, plain and rich, with AccessKit on (--profile perf, reserved Mac). 2 ms is interim: the full target, 1 ms at 50 KB, closes in phase 3. Bytes shaped per keystroke are at most the edited paragraph plus 1 KB, and at 1 MB a keystroke makes at most one whole-text copy and one whole-text scan under the T1 count budget.
- Typing event-to-present p95 is at or below 16.7 ms and p50 at or below 8.3 ms at 50 KB on the 120 Hz Mac, readable from --tree and procwatch, and p95 is no more than one refresh behind the native field.
- 100 of 100 undo steps are kept at 1 MB. History bytes per step are at most 2 x (changed text bytes + 32 B per changed formatting record) + 256 B, and recording an edit allocates nothing per existing history step.
- 100% of a sourced caret corpus of at least 300 cases (bidi, complex scripts, CJK, emoji, Backspace and Delete) passes under the Mac, Windows and Linux mappings. KeyPlatform is detected at run time in every build: Windows in a browser on Windows, Mac in a browser on an Apple device, and Mac on iOS.
- 0 font discovery operations run on the main thread before the first frame. Each process has one font collection with each file mapped once, and a cold fallback face costs at most 2 ms on the main thread. Every text cache stays within its entry and byte bounds in the 20,000-frame stress gate, and release builds show 0 aliased spans or layouts.
- On the desktops, the coverage lane reports 0 missing clusters where the OS has coverage, 100% family agreement for the four Han locales, every RGI emoji in colour except VS15, all four colour formats in colour, and a visible box for every uncovered cluster.
- The pristine fast path, max length, input filters and caret blink (with the system rate and the off setting) pass their contracts in rune, and #125-#129, #173 and #180 are each closed by a reproducing test.
Phase 3
- Keystroke p95 is at or below 1 ms at 50 KB and 2 ms at 200 KB with AccessKit on, on the reserved Mac.
- Keystroke p95 is at or below 4 ms at 1 MB, plain and rich with AccessKit on, and in each of the three 200 KB single-paragraph cases. A 100 KB paste and a select-all delete at 1 MB each take at most 8 ms. The composite differential passes 10,000 seeded cases on every merge.
- Key-to-photon p95 for typing at 50 KB is at or below 35 ms on the photon rig.
- Glyph pages are shared per device, so a glyph shown in two windows rasterizes once. An extra overlay adds at most 1 MiB of text memory, a text-free overlay adds no atlas page, and no first-mount frame spends over 4 ms of text work on the main thread.
- The coverage lane meets the desktop coverage bar on the web and iOS.
- Per-platform parity goldens are committed with pinned manifests for macOS, iOS, Windows, Linux and the web, and each lane fails outside an ink ratio of 0.97-1.03 or above an MAE of 0.5 levels, at every scale and theme.
- The large-file note records 10 MB and 100 MB numbers and the decision on the Document type.
Phase 4
- A 100 MB file shows its first usable viewport at p95 at or below 250 ms, with peak extra memory at most 2.5x the file size, whatever the Document decision. Typing stays at or below 4 ms p95 at 10 MB, in text_input or in the Document type if it is built.
T09 · text-input
Text input: input methods ride winit's four-event stream, so overlays and system text services get no document context
33 issuesphases 1-37 existing issues
Input methods reach Rune through winit's four-event IME stream, which carries no document context. A candidate window can't read the text around the caret, reconversion and press-and-hold don't work, and winit-backed overlays can't compose or claim secure input. System text services such as spell check and Writing Tools have nothing to read. Closing this theme puts every desktop and web input method and text service on one Rune-owned TextInputClient over TextEdit, so composition, undo grouping and services behave as the platform's native field does.
Done when
Phase 1
- TextInputClient is specified, checked against NSTextInputClient, ITextStoreACP2, text-input-v3, EditContext and UITextInput, and implemented once over TextEdit, and the winit and web paths run on it. A test shows that a request with a stale revision or a defocused field id changes nothing. text_in never returns more than 4,096 UTF-16 units.
- At least 40 replay fixtures (ja, zh-Hans, zh-Hant, ko, vi, dead keys, press-and-hold, emoji picker, dictation and secure fields) pass headless in T1 in under 30 s. IME commits, dead keys, dictation and emoji inserts match the recorded macOS and Windows undo grouping in at least 6 scenarios each.
- A winit-backed overlay field composes Japanese with the candidate window within 2 pt of the caret. A secure overlay field keeps a balanced secure-input claim across 100 show and hide cycles. The web input sink sits within 1 CSS px of the caret during composition, and on the field rect otherwise, in Chromium, Firefox and WebKit. The autofill repro in #109 leaves exactly the 13 filled characters.
Phase 2
- On the macOS real-IME lane (Kotoeri, Pinyin, Zhuyin, 2-Set Korean and Telex at four scales), press-and-hold, reconversion, emoji replacement, dictation and Look Up pass through RuneTextView in a window and in a non-activating panel, with menu and shortcut tests unchanged. RuneTextView becomes the default only after 14 consecutive days of green lane runs. The web bridge and app-drawn editors pass the same replay scenarios, and the browser lane runs at least 15 scenarios on Chromium and WebKit on every push to dev.
- On the web, the focused input sink carries the field's own name, description, and required, invalid, read-only and multi-line state, checked by a Playwright snapshot, VoiceOver with Safari and NVDA with Chrome. Screen-reader line moves reach the end of a 1 MB field, and every input purpose sets the documented sink attributes.
Phase 3
- 100% of headless conformance scenarios pass for the macOS, TSF, Wayland, X11, web textarea, EditContext, overlay and app-drawn-editor adapters. 100,000 seeded fuzz sequences per T1 run finish with 0 invariant violations, and removing the stale-request guard makes the fuzz fail.
- The anchor rect each adapter reports is within 1 pt of the drawn caret at 100, 125, 150 and 200% scale. On a 1 MB field with a 900 KB selection, each query reads at most 4,096 units beyond its range and answers in under 1 ms on the reference Mac.
- Every desktop and web cell of the text-services matrix (spell check, autocorrect and text replacements, dictation, Writing Tools, emoji picker, Look Up, purpose and AutoFill, secure entry, the edit menu and text drag) is filled from an executed test or lane step, or names a platform limit. macOS password and one-time-code AutoFill pass a native comparison fixture. Where Apple offers custom views no API, the issue ends in a proposed change to the target that names the missing API, not a closed issue. Voice Control and Voice Access select and correct words on the desktops.
- The real-IME lanes on Windows and Linux pass 100% of scenarios at every release cut, at all four scales and on pinned OS and IME versions, and the macOS lane keeps passing. Every failure becomes a committed replay fixture before the cut.
T10 · motion-and-scroll
Motion: scroll, growth and flights step outside the traced scene, and scrolling doesn't move as each platform's own views do
33 issuesphases 2-31 existing issues
Scroll offsets, height growth and flights step outside the traced motion scene, so their velocity can jump and they can land in different places at 60 and 120 Hz. Touch flings, trackpad momentum, rubber-banding and wheel glides don't follow each platform's own scroll views, and the motion docs give wrong test counts and defaults. Closing this theme makes every presented motion one traced source with continuous velocity at any refresh rate, and makes scrolling match the native toolkit for touch, trackpad and wheel.
Done when
Phase 0
- Every motion doc statement listed in the motion docs issue (test counts, defaults and missing features) matches the code.
Phase 1
- The site has a Motion page in its nav, with a SwiftUI parity data file for the fixed list of SwiftUI animation features, and a test fails when a row's API path, example or gate scenario does not exist.
Phase 2
- The travel-X lane, screen-path lead, presence draw lane and hard-coded spring bugs are fixed, each with its test. Per-lane screen-path progress is within 1e-4 of its own curve, every Fx lane differs by less than 1e-6 across remove and revive, and each lane settles on the element's own LayoutAnim and class epsilon.
- A fuzz test over NaN, +/-inf, 0 and 1e9 s durations, 1e8 pt offsets and 1,000 retargets a second finds 0 non-finite presented values and 0 release-build panics through the store, Scene, scroll and the Spring::try_ constructors. Every non-looping track settles within MAX_SETTLE.
- store.rs, scene.rs and commit/apply.rs are each under 800 non-test lines, and the gate traces carry a Reason for every instant layout change.
- The retarget audit covers 100% of the committed source and operation inventory, and velocity-snap is in RULES at 0.001 pt/s analytic, 0.5 pt/s stepped and 1e-4/s for opacity. Every intended discontinuity carries a cut reason.
- On at least 40 recorded UIScrollView flings, touch fling distance and duration are within 2%. Velocity estimator error is at most 5% median and 15% p95 (with a floor of 20 pt/s), with 0 releases clamped from coalesced events. Edge overshoot is within 0.5 pt of the 960 Hz reference at 30-144 Hz with +/-4 ms jitter, and the rubber band is within 0.5 pt of the viewport-dimension formula.
- In replay, content under a dragged pointer or finger lags it by at most 1 refresh. Drag releases at 150, 600 and 2,400 pt/s start their spring within max(2%, 10 pt/s) of the hand speed, and a catch jumps at most 0.5 pt.
- An animating frame visits at most 2 x changed + viewport and watcher list + 64 Scene and runtime nodes for presentation and scroll, and that count is within 5% between the 10,000- and 100,000-node trees.
Phase 3
- Every source in the inventory (scroll offsets, momentum, glides, growth, content slides, and launched, matched and text flights) is traced, audited and visible to rest, with 0 finite-difference velocity estimates. The same scenario at 60 and 120 Hz, with jitter, a rate switch and a 100 ms gap, lands within 1/64 device px for tracks and 0.5 pt for scroll, growth and flights, with no allow rows.
- A macOS trackpad push past an edge rubber-bands within 2 pt per frame of NSScrollView and returns within 0.5 s of momentum end, with 0 jump findings. A whole wheel notch moves at most 35% per frame at 120 Hz, lands in 150 ms +/- 1 frame, and is within 10% per frame of Chromium on Windows and GTK4 on Linux, with lines-per-notch applied once. Precise deltas are never glided.
- Windows precision touchpads and Linux Wayland trackpads coast within 10% of Chromium's and GTK4's distance on the survey fixtures. Mouse wheels never coast, and a new touch stops a coast within one frame.
- Paged and child-snapped scroll views land on a snap point at the release velocity within max(2%, 10 pt/s), with 0 overshoot findings at bounce 0. Scroll-linked headers run 0 app callbacks per scrolled frame, and on_landed fires once, at its defined time, in every listed case.
- Every row of the fixed SwiftUI animation list, including PhaseAnimator, KeyframeAnimator, completion, paging and scroll-linked effects, has a working El example and a gate scenario linked from the site's Motion page. No physics constant is defined in both rune and rune-motion.
- The input-resampling measurement is committed. If resampling ships, constant-speed drags have a step spread within 10% of the ideal step at every input and display rate pair, with at most 5 ms of added latency and at most 1 pt of overshoot.
T11 · frame-core
Frames: four hosts copy the frame loop in winit types, nothing measures input-to-present, and paint walks the whole tree every frame
51 issuesphases 1-47 existing issues
The window, overlay, web and LayerHost hosts each copy the frame loop in winit types, so a fix such as the quiet-frame skip reaches some hosts and not others. FrameEncoded::presents_at() reports the scheduled refresh rather than the real present time (#175), so nothing measures input-to-present, and paint walks the whole tree each frame. Closing this theme gives one SurfaceHost frame core behind a Rune-owned event and request boundary, real present times on every platform, retained paint patched in proportion to what changed, and a presenter thread only where telemetry shows it is needed.
Done when
Phase 1
- On the ProMotion reference Mac, every window's FrameRecord ring reports input-to-present p50 and p95 and missed presents from Metal presented times, without --trace. Present times agree with the presentDrawable swizzle within 0.5 ms and missed counts within 1%, and recording allocates nothing. A present-source note names the real present source, or none, for every backend and browser (#175).
- Glass windows present at least 97% of frames one refresh after the previous one at 120 Hz, toward a 99% target. A synthetic 5 ms CPU scene misses fewer than 0.1% of presents, and the 60 Hz one-period share does not regress (#204).
- GPU time is recorded on 100% of presented frames where the device has TIMESTAMP_QUERY, including the last frame before idle, with 0 allocations and at most 0.05 ms of CPU per frame.
- An idle web app and a 30 Hz wake_after LayerHost present 0 frames a second, and the overlay and web compositors read marks aligned index for index with instances (#166, #167).
Phase 2
- Window, overlay, web, LayerHost, desktop and headless hosts drive frames through SurfaceHost, with 0 non-test calls to FrameClock::advance, Runtime::frame or frame_split outside the core. The Backing parity suite passes the idle, live change, starved callback (poll and timers within one period plus 16 ms after 10 s without callbacks), refused, Lost and hidden scenarios (#139).
- Hosts read 0 runtime request or platform fields, with an arch-ratchet ceiling of 0. Every side effect is a HostRequest drained after every event and timer callback, and headless tests assert the request streams, including for a hidden window with no frame presented. Runtime code and the public API name 0 winit types.
- Windows, Linux (Wayland and X11) and iOS in the simulator record real present times and OS input timestamps; iPhone device numbers follow with the iPhone perf lane in phase 3. The frame record keeps actual, predicted and proxy present times in separate fields. The web records a labelled proxy that counts toward no input-to-present target, so the web's targets need an external present source or a recorded change to the target. Motion is sampled at the frame target, with sample-to-present p95 at most 1 ms on native hosts and sample-to-rAF-target p95 at most 0.5 ms on the web, and a stale source falls back within 2 frames with 0 jump findings.
- Overlays scroll with wheel and trackpad, take IME and secure input, and get the secondary click on macOS, Windows, X11 and layer-shell.
Phase 3
- The paint differential harness shows identical resolved geometry, marks, hits, resource updates and scope balance on all suites. Fallbacks are under 1% of frames, entries visited are at most 2x entries changed in the pinned scroll workloads, and Board long-card scroll p95 is under 8.3 ms on the reference Mac. 8.3 ms is interim: the full target, 4 ms p95 with 0 frames over 8.3 ms, closes in phase 4.
- PaintList: Send and FramePacket: Send + 'static are asserted at compile time, and Renderer::prepare takes only &FramePacket. After a deprecation window of one changelog fold and 30 days, with examples/lab and cursed-settings moved to the queued state-write replacement, Frame exposes no &mut Runtime.
- Stall markers name the first-use work behind every frame over one refresh, and the first-use suite shows 0 Rune-caused main-thread tasks over 8.3 ms after the first frame on macOS, Windows and Linux.
- On Windows and Linux, the event-loop thread spends at most 0.2 ms p95 per frame in acquire, present and worker waits, or a recorded note shows the present worker is not needed. A surface whose present blocks costs other windows at most 1 refresh (#169).
Phase 4
- Flagship scroll scenes reach CPU p95 at or below 4 ms with 0 frames over 8.3 ms on the reference Mac.
- The presenter go or no-go is recorded from main-thread-busy telemetry on flagship workloads, with no injected stall, against 0.5% of motion frames on the reference Mac, Windows and Linux lanes. On go, presenter windows follow the written eligibility contract (a compositor stays on the main thread unless it adopts a Send, data-only contract), the concurrency model tests pass, and a deliberately stalled 30 ms commit drops 0 frames of running animation and momentum on opted-in windows on the reference Mac and Windows machine. Every host makes 0 idle submissions.
T12 · renderer
Render: some GPU pools never shrink, colour isn't managed end to end, effects ignore display settings, and pipelines compile on the UI thread
56 issuesphases 1-419 existing issues
Some GPU pools grow and never shrink, macOS loses the sRGB colour tag on some surface reconfigures, and images ignore their ICC profiles. Effects ignore Reduce Transparency and Increase Contrast, and the first fade, blur or backdrop compiles a pipeline on the UI thread, which can drop frames. Closing this theme bounds GPU memory in bytes, manages colour end to end with wide gamut and HDR where the platform supports them, makes effects follow display settings, and keeps pipeline compiles and GPU waits off the UI thread after the first frame.
Done when
Phase 2
- T1 count tests show 0 UI-thread pipeline creations after the first frame for the first fade, blur, backdrop, plus-lighter blend, video frame and each effect kind, faded and unfaded, on native Metal, wgpu Metal and DX12.
- Every built-in pipeline ships precompiled (metallib and DXBC), with a freshness test in the macOS and Windows lanes and one diagnostic on a runtime miss.
- After the first frame the UI-thread GPU-wait counter reads 0, except for pacing waits that each end within one refresh, and no scenario adds more than 2 ms of render work to the UI thread.
- kCGColorSpaceSRGB holds after 6 of 6 configure paths on both Apple backends and on iOS LayerHost. ICC-tagged image fixtures decode within 1/255 of Chromium, and native output equals web output within 1/255.
- Transient pools sit under one per-device budget and free within 2 s of last use by wall clock, with no frame drawn. 10 fade cycles allocate one target, and a 100-step live resize with a blur makes at most 12 backdrop allocations.
- rune-fx and rune-light pass 26 goldens within 2/255 in both blend modes on every native and WebGPU target. Every canonical scene is byte-identical over 20 runs on every lane. WEB.md has a WebGL2 feature matrix with capability-checked fallbacks, each emitting one diagnostic and never panicking.
Phase 3
- Every GPU pool is counted within 5% of allocator bytes. A hidden window frees at least 90% of its transient bytes within 2 s on macOS, Windows, X11 and Wayland. A hello window holds at most 8 MiB beyond its drawables, and a text-free overlay at most 1 MiB. A 50-cycle soak ends within 5% of cycle 1, and macOS overlay shows reuse one device.
- The colour fixture set renders within 1/255 of pinned Chromium in both blend modes on macOS, Windows, Linux and the web. A display-p3 swatch keeps its P3 value within 1/255. PQ, HLG and BT.2020 clips play with 0 errors within 3/255 of their references.
- EDR and HDR windows read back values of at least 2.0 on macOS, iOS and Windows, with SDR content within 2/255 of an SDR window and at most 25% more GPU time on the 1,000-quad scene.
- After a display move or a simulated display change, the next frame keeps the new scale and the sRGB tag, pacing moves within 2 frames, and an HDR window reads the new headroom within 1 frame.
- Every pinned kit story reaches a similarity of at least 99.5, with at most 0.5% of pixels off by more than 8/255 and no 32 px tile with a mean difference above 2/255, in light and dark, on 4 of 4 platforms. Gradient banding stays within Chromium's plus 10%, and a deliberate 3/255 shadow change fails the gate.
- Within one frame of the OS change, Reduce Transparency runs 0 backdrop-blur passes and draws materials and effect glass opaque, Increase Contrast draws the materials' high-contrast fill, and Reduce Motion freezes every effect on a still frame with 0 frame requests. Effect-clock increment error is at most 0.1 ms after 30 days of uptime.
- A static isolated layer redraws 0 times while unchanged, and a backdrop over static content runs its pyramid on 1 frame of 100. A steady frame makes 0 GPU allocations, layer encode visits at most 2x the plan entries plus surfaces, and GPU p99 is at most 4 ms on the 1,000-quad and effects scenes on the reference Mac.
- The instance ABI is defined once in rune-abi, with 0 cross-crate include_str! and a conformance test, and rune-render builds and tests without rune, with no change to public paths.
T13 · media
Media: video plays only on macOS, a playing clip presents at the display rate, and image loads stall the UI thread
24 issuesphases 1-49 existing issues
Video plays only on macOS. A playing clip presents at the display rate rather than its own, the completion thread polls every 1 ms, and image hashing and large uploads run on the UI thread. A surface waker that reads Player state can deadlock, and a web app that draws a video or a NativeSurface ends. Closing this theme plays and decodes media on every platform as the browser does, at the clip's own rate, with bounded memory and no UI-thread stalls.
Done when
Phase 1
- A surface waker that calls Player::state and Player::time on every frame plays 600 frames without hanging, and a debug assertion shows that no surface push_* call runs while a player lock is held.
Phase 2
- A Windows shared texture reused by name at a new size, or recreated under a new generation, is reopened or refused with a readable error and never copied with a mismatched descriptor, as the Windows lane checks.
- A web app that draws el().video() or an app-fed ByteFrame NativeSurface keeps running and taking input for 5 s with the placeholder drawn, and nothing traps or panics.
- With nothing else moving on a 120 Hz display, a 24 fps clip presents 24 +/- 1 frames a second and a 60 fps clip 60 +/- 1, with A/V drift at most 40 ms. The completion thread wakes at most 2 times per presented frame, and a paused Recorder wakes 0 times a second.
- No frame uploads more than 4 MB of non-video image data, under a count budget. The frame that first shows a 5K image takes at most 2 ms more main-thread time than a steady frame. ImageCache load and rgba of a 256 MiB buffer, and Recorder stop and drop, return within 1 ms on the UI thread.
- A decode request dropped before it starts is decoded 0 times. Summed transient decode memory stays under its budget with four 8192 x 8192 images queued, and one 8192 x 8192 decode peaks at no more than 1.5 times its RGBA size, measured with the counting allocator.
Phase 3
- Scrolling 500 4K images keeps CPU and GPU image bytes each within budget, a poster holds 0 CPU bytes after upload, and a playing surface creates 0 GPU textures, buffers or bind groups per frame after a 10-frame warm-up.
- 5 of 5 platforms (macOS, iOS, Windows, Linux through #30, and the web) play every manifest fixture with 0 errors, A/V drift at most 40 ms and at most 1 dropped frame per minute at the clip rate, with 0 CPU copies per frame where the platform offers GPU import.
- Every WebP, GIF and AVIF fixture that Chromium decodes also decodes natively, within 1/255 of the web build. On WebGPU, loading an 8192 x 8192 image does no getImageData and peaks at no more than 1.5 times its RGBA size.
Phase 4
- Recorder start, stop and drop record a complete file on macOS, Linux, Windows and iOS, and permission denial and interruptions give readable errors. HLG and PQ fixtures play with 0 errors on Windows and in Chromium, within 3/255 of the CPU tone-map reference on SDR targets.
T14 · platform-shells
Platform: Windows, Linux and the web lack native shell pieces, services and packaging, and iOS and Android have no shell
60 issuesphases 1-419 existing issues
Windows and Linux lack shell pieces that winit doesn't provide, such as full drag and drop, pop-up menus and title bars, and the app services and signed packaging an Electron replacement needs. The macOS shell depends on trampolines, a KVO swap and swizzles on winit's objects, the web host lags the desktop, and iOS and Android have no shell. Closing this theme gives each OS the shell pieces Rune owns, opt-in services in a rune-app crate, signed packages on three desktops, a UIKit shell for iOS and an Android shell, with every platform claim generated from a checked capability registry.
Done when
Phase 1
- winit's requirement starts with '=', which a Cargo.toml test checks. The T1 hook scan finds 0 call sites missing from the inventory, and the canary fails in the macOS, Windows and Linux GUI lanes when any inventoried hook is skipped or fails its behaviour check.
- capabilities() covers every app service and media capability on all seven platforms, with feature gates, session probes and minimum OS and browser versions. The generated tables in README.md, crates/rune/README.md, WEB.md and the site differ from the registry by 0 lines, the lint finds 0 support claims outside generated blocks, every Native cell names a test that passed in its OS's latest lane, and the stated minimum versions equal the ones the weekly oldest-version lanes run.
- On the web, on_window and on_ready each run once at their documented time, on_frame_encoded and on_frame_drawn run on every drawn frame, and a T1 test fails when an App hook has no stated web behaviour. A two-finger pinch zooms a generated page in iOS Safari, and the static export keeps every width.
Phase 2
- Showing and hiding a Wayland layer overlay 100 times costs 0 UI-thread roundtrips after the first show, keeps a constant thread count, and never hangs on a compositor that does not configure. Five startup shortcuts do not delay the first frame on Wayland, Prefs::set on a 64 KB file returns in under 50 µs, and the Windows pointer hook is reinstalled after an injected stall.
Phase 3
- The rune-www and default-features web-hello .wasm files are each at most 1.5 MB with brotli -q 11, the cold load is at most 2.2 MB brotli, and text goldens pass after any font-stack change.
- The services ship in the opt-in rune-app crate. Single instance (ten parallel launches leave one owner and deliver ten argument sets), deep links and opened files, and notifications work on Windows, X11 and Wayland. Every service cell on macOS, Windows and Linux is Native, with a fake test and a lane smoke test, or Unsupported, with a named OS or desktop limit.
- Windows drag and drop (positions, images, virtual files and drag_out), Linux pop-up menus, Linux title bars and Wayland dialog parents pass on the Windows 11, GNOME, KDE, sway and X11 lanes, and every cell that fails carries a protocol limit in the registry.
- On each push to dev, CI builds, installs, upgrades and uninstalls a .app and .dmg, an MSIX, and an AppImage and Flatpak of examples/hello, with an empty before-and-after system diff. Every production push notarizes or signs and verifies its artifacts, and fails when secrets are missing.
- The Android spike records emulator and device numbers and a recommended shell in research/40, and files the shell's work as estimated issues.
Phase 4
- The owned macOS shell (RunePanel, RuneWindow and the app delegate) is the default, the class-change canary sees 0 changes to winit's classes and objects, and the winit fallback is removed one release later.
- Two Rune apps run on one page sharing one GPU device, App::window opens a second canvas, and the page makes 0 submits at rest.
- Every iOS simulator case passes on each push to dev. A backgrounded app encodes 0 command buffers, and after a memory warning the gauges fall to their launch values. The scroll scene reaches at least 99% one-period frames at 120 Hz on an iPhone Pro. The UITextInput adapter passes the desktop text-input conformance cases, and Writing Tools, password AutoFill and one-time codes pass a native comparison fixture, or end in a proposed change to the target that names the API Apple does not offer custom views. performAccessibilityAudit reports 0 issues, VoiceOver reaches and activates every Kit component, Dynamic Type matches SwiftUI within 1 pt from xSmall to AX5, and iOS settings apply within one frame.
- The Android shell passes the kit gallery's IME, TalkBack, back, lifecycle, rotation and restoration cases on API 29 and the current API, on every push. The device reaches at least 99% one-period frames with 0 presents while stopped, and the template builds an APK and an AAB in CI. Until it does, the platform area does not meet its target.
T15 · accessibility
Accessibility: no lane runs a screen reader, most system settings aren't read, and long lists and fields are out of a reader's reach
40 issuesphases 0-39 existing issues
No lane runs a real screen reader, so nothing shows that VoiceOver, NVDA, Narrator or Orca can use a Rune app. Most system settings, such as text size, contrast and Reduce Transparency, aren't read, a reader can't reach virtual-list rows past the mounted range, and secure fields leak their text into accessibility text runs. Closing this theme gives one cheap AccessKit tree on every desktop and the web, settings that apply live, speech lanes that drive Rune, and a WCAG 2.2 AA matrix with no failure caused by Rune or Kit on desktop and web.
Done when
Phase 1
- Secure fields expose nothing beyond the platform's native secure field, with no plaintext and no length in text runs. An unknown role string warns in debug, and a box with only hover or drag handlers is no longer announced as a button.
Phase 2
- One AccessKit tree feeds the macOS, Windows and Linux platform trees for windows, overlays, layer surfaces and embedded hosts. The fault tests (reader restart, refused adapter, subclassed macOS view, nested UIA update and feature off) show 0 panics, and every refusal appears as a warning and in --tree.
- With a reader attached, incremental update p95 is at most 1 ms and scroll-only updates at most 0.1 ms, frame p95 stays within 10% of the run without a client, and a keystroke in a 200 KB field costs at most 0.3 ms extra.
- The AX, UIA, AT-SPI and browser accessibility-tree lanes run after every merge to dev and are green. The caret rect each platform's text API reports is within 1 pt of the drawn caret, and 1 px for the web input sink, in single-line, multiline, scrolled and off-origin cases.
- Reduce Motion and Reduce Transparency are read on every desktop and web target and apply live within one frame, including to motion already running, and Cx::reduced_transparency() has a reader test per target.
Phase 3
- Text size, contrast and forced colours, web text spacing and zoom are read on every desktop and web target and apply live within one frame.
- The web platform tree moves onto the same AccessKit tree (#118).
- On macOS, Windows, Linux and the web, each reader's own reading cursor (VoiceOver, NVDA, Narrator, Orca and the 3 browser pairs), not only ScrollIntoView, walks to row 10,000 of a virtual list and back with the correct set size for focusable and plain rows. It reads every line of a 1 MB field and runs row actions as custom actions, and status changes are heard without moving focus. iOS follows in phase 4.
- Every field exposes its name, purpose, required and invalid states with an error relation, and a language, on macOS, Windows, Linux and the web, or has an n/a cell with a reason. iOS follows with the iOS shell in phase 4.
- The scene and reflow sweeps find 0 clipped, overlapping or unreachable items at 320 pt width, 200% text and pseudo-locales, outside an allowlist that only shrinks. Composited contrast has 0 failures with no allowlist, Reduce Transparency included.
- The VoiceOver, Narrator, NVDA and Orca speech lanes and the 3 browser pairs pass every critical scenario on each of the last 14 nights, and every accessibility suite is a required check on dev. The WCAG 2.2 A and AA matrix shows no criterion failing because of Rune on desktop or web, each row names its test, and the support matrix lists only combinations whose lanes meet this bar.
T16 · kit
Kit: standard controls are missing, components bypass theme tokens and states, and streaming Markdown rebuilds the whole reply
52 issuesphases 1-311 existing issues
rune-kit lacks standard controls such as Tabs, Sheet, Stepper and date and colour pickers. Some components use raw values instead of theme tokens and miss focus rings, invalid states or keyboard paths, and each streamed Markdown token reparses and rebuilds the whole reply. Closing this theme gives apps the standard desktop controls with one build shape, theme tokens, translatable strings, complete states and keyboard paths, and content components whose cost grows with the new text, not with the whole document.
Done when
Phase 1
- Each of these has an accessibility golden and passes the keyboard walk: the Checkbox ring draws border_focus, and the inline Select shows a ring on keyboard focus only. An indeterminate Checkbox draws a dash. Menu radio items expose menuitemradio, and H1 to H6 report their own level. Field clear and copy buttons and the sidebar row close button are reachable by keyboard. Every kit control with an error look sets invalid and draws a text or icon cue.
- The keyboard walk runs over 100% of kit-gallery stories in T1, with any allowlist checked in.
Phase 2
- Escape closes a plain Popover and returns focus to the trigger, and Tab from every overlay trigger reaches its open content next. Popover, Menu, Select and Dialog take the same Dismiss options, and a dismissible(false) Dialog renders without on_close.
- A streamed token into a 200 KB Markdown reply with code, diff and Mermaid blocks costs at most the new bytes, plus the open block's last line, plus 1 KB of parse and highlight work per commit, including while a code fence, table or list grows. An open paragraph needs carried delimiter state or a recorded change to the target. Completed blocks are rebuilt 0 times unless something invalidates them, and the output is identical to a full parse and render at every commit.
- perf/budgets/feed.toml gates in T1. A plain-text token into a 50 KB reply with on_link, images and three code fences builds only the last two blocks and parses at most 2 KB. Prose that says 'mermaid' is cached, and a 5,000-line diff fence builds at most 4 El nodes.
- Every kit content cache (Markdown parse and stream, syntax, diff chunks and Mermaid scenes) is bounded in entries and bytes, recent entries included, and a stress test shows it.
- 0 non-deprecated public kit APIs take &mut Vec<El>, and kit-gallery uses 0. The shape test passes with only the listed exceptions: build(self, &Kit) -> El, on_change, on_press, on_<action>, and bool setters that clear.
- scripts/kit-tokens reports 0 findings outside an allowlist with reasons. The string inventory has 0 strings without an override. Two SplitViews in one window work independently. Equal Select labels show one checked option, and on_choose receives the id. A fixture that adds a Palette or Type token keeps a ..base theme compiling.
- The keyboard walk has 0 failures over every kit story with an empty allowlist. No on_drag node lacks a keyboard path. Every enabled pointer target is at least 24 pt or meets the spacing exception. The token-pair contrast test has 0 failing meaningful pairs for neutral light and dark and for 32 from_palette seeds.
- TextInput, TextArea and TextField forward on_paste. A view run with an unchanged 200 KB field copies no text, and a secure field holds exactly one copy, zeroed on drop. A typed character in a 10,000-option Combobox builds at most 40 rows and filters once.
Phase 3
- components.toml resolves 100% of the standard desktop controls list, and each implemented entry passes its scene, its golden for each listed state and its keyboard test. Slider (#149), Tabs, Sheet, Stepper, Chips, CommandPalette, Avatar, DatePicker and ColorPicker exist. The parity lane runs without an OpenCode checkout, with at most 0.5% of pixels over 8/255 per component and state.
- Opening a 50 KB Markdown document takes at most 6 ms and a 200 KB one at most 8 ms headless, in paired runs, and no frame is over 8.3 ms while scrolling the 200 KB document.
- Every kit-gallery scene passes the RTL mirror gate, with directional icon goldens and arrow-key tests in tab strips, segmented controls, sliders and menus, apart from a documented list of elements that stay physical.