Log — UI Frameworks Wiki

Append-only history. Each entry starts with ## [YYYY-MM-DD] <op> | <title> where <op> is ingest, query, lint, or split, so grep "^## \[" log.md | tail -5 works.

[2026-07-10] split | ui-frameworks-wiki created from _inbox (2 sources)

Spun out at the human's approval to give application-level UI frameworks / component libraries / design systems a home — a class repeatedly held out of dev-tooling (Ky boundary: runtime UI lib ≠ build infra) and agentic-tooling (OpenTUI precedent: a UI toolkit an agent builds with ≠ agent-building tool). Seeded with the two parked UI-library strays: opentui (SST; Zig-core terminal-UI framework) and astryx (Meta; web design system). Ky stayed parked (js-libraries — an HTTP client, not UI). Founding pages: sources opentui/astryx; concepts ui-framework (umbrella), design-system, terminal-ui, agent-ready-ui (the cross-cutting thread); Organizations sst + cross-wiki meta. Synthesis thesis: one architecture (declarative components over a rendering core) across surfaces (terminal↔web), converging on agent-ready design. _inbox/opentui.md + _inbox/astryx.md deleted.

[2026-07-10] ingest | OpenTUI (SST terminal-UI core)

Founding ingest. opentui (SoftwareSourceCode, T2): native Zig core + C ABI, TypeScript bindings, React & SolidJS reconcilers, Three.js WebGPU browser renderer; MIT ~12.4k★; production at OpenCode/terminal.shop; ships AI-agent skill support. Seeded terminal-ui, ui-framework, agent-ready-ui, maker sst.

[2026-07-10] ingest | Astryx (Meta web design system)

Founding ingest. astryx (SoftwareSourceCode, T2): open-source design system powering 13k+ Meta internal apps — 150+ React components, design tokens, seven CSS-variable themes, StyleX, framework-agnostic styling; "fully customizable" + "agent-ready". Seeded design-system, reinforced ui-framework/agent-ready-ui; maker cross-linked meta (../business-messaging-wiki).

[2026-07-16] ingest | I Spent 200 Hours Optimizing My Flutter App (Medium, hub-routed, Telegram)

Ingested a Flutter app-performance practitioner post (Chirag Prajapati) → source flutter-performance-200-hours (TechArticle, T4 — Medium member-only; partial ingest: even via the author's free friend-link only the intro + technique §1 were recoverable, later sections behind the paywall). Recovered substance: thesis = profile before optimizing, fix real bottlenecks not imagined ones, don't over-optimize; §1 = reduce unnecessary widget rebuilds (rebuilds are how Flutter works; cut the needless ones). Routed here because Flutter is a UI framework and its widget-rebuild model is rendering-internals — the spoke's core theme. Created the canonical flutter node (SoftwareApplication): Google's cross-platform UI framework, a textbook rendering-core→reconciler→framework instance (immutable widget tree + persistent element tree = the reconciler, like opentui's), notable for owning the canvas (Skia/Impeller renders every pixel) — the extreme of the surface-as-swappable-back-end thesis, and the wiki's first native/mobile framework + first UI-performance source. Reused cross-wiki google (maker); cross-linked dart (dev-tooling, Flutter's language) + flame-engine (game-engines, built on Flutter) — Flutter as a 3-spoke graph hub. Author (Chirag Prajapati) deferred (thin T4). Synthesis: Flutter fills the middle rung + native surface + opens UI-performance-as-subject. avoid-ai-writing self-pass (clean). +2 pages, 3 spine files updated.

[2026-07-26] ingest | PeopleInSpace — John O'Reilly's Kotlin Multiplatform sample (github.com/joreilly/PeopleInSpace)

Routed here by the hub. T1 (the project's own repo), Apache-2.0, ~3.4k★, and cited in JetBrains' KMP docs plus Google's Dev Library — a personal repo doing a platform vendor's reference-implementation job. New: people-in-space (source), compose-multiplatform (Thing), john-oreilly (entity). Updated: ui-framework (new section — a second axis: how far up the stack sharing goes), flutter (the contrast: framework-property sharing vs per-platform choice), synthesis §1 + the surface-independence open question. The finding: six targets over one shared Kotlin core, Compose Multiplatform on four of them (Android/Wear/desktop/Kotlin-Wasm web) — and SwiftUI by hand on iOS. The repo that best demonstrates surface-independence declines it on one platform. That reframes the spoke's standing question: the first ceiling on "one description, many surfaces" wasn't a rendering constraint, it was a platform idiom worth keeping. Dedup: flutter was the nearest page and stays distinct — Flutter owns the canvas everywhere; Compose Multiplatform here shares selectively. No Compose/KMP page existed. Weakness recorded on the page: it's a demo, not a deployment. No cost is reported for either strategy, and the repo evidences Compose Multiplatform's targets, not its internals — so the page can't yet be placed on the rendering-core → reconciler → framework stack. That's the next source to want. Verify deferred per hub policy (content-only). avoid-ai-writing run.

[2026-07-28] ingest | What's new in Flutter 3.44 (flutter.dev/blog/whats-new-in-flutter-3-44)

Routed here by the hub. T3 — a first-party release announcement, promotional in framing (leads with download counts and a "500% growth" figure) but authoritative on what shipped. First release-level source in the spoke; dedup found flutter already paged, so this is a new source summary plus a refresh of that node, not a duplicate. New: flutter-3-44 (source, BlogPosting, freshness: volatile). Updated: flutter (two new sections — what the canvas bet costs; agent access to the running app), agent-ready-ui (past-docs section — the standing open question gets a partial answer), design-system (the bundled-design-system counter-case, now unbundling), synthesis §1 + new §1b + §2 + the agent-ready open question, index. Two findings worth the ingest. Material and Cupertino are frozen at their final in-framework versions and move to standalone material_ui/cupertino_ui packages — Flutter was the one source here shipping framework and design system fused, so the spoke's rendering-core→reconciler→framework→ design-system model gets confirmed by the outlier splitting along exactly that seam. And agent-ready UI acquires mechanism: Agentic Hot Reload hands a coding agent the running app (the inner loop, not the source tree), the MCP tool definitions were consolidated to cut agent token cost, and Dart/Flutter Agent Skills land — the same unit opentui ships, so two independent toolkits now converge on skills. Gap-relevance: answers part of the spoke's oldest open question. Recorded limit: still no measurement that any of it beats plain docs; the claims are all the vendor's. Cross-spoke context, not fragmented: GenUI (agents composing UI at runtime, A2UI protocol) belongs to ../agentic-tooling-wiki's generative-UI-output corner; Genkit Dart / flutter_gemma / LiteRT-LM are model plumbing (llm-providers, llm-inference); the SwiftPM + Gradle 9 toolchain shifts touch dev-tooling via dart. All noted inside the source page rather than split into other spokes. Canonical (new lead maintainer of the Linux/Windows/macOS embedders) mentioned in prose, not paged — third party, not this source's author/publisher/owner. Verify deferred per hub policy (content-only, no page moves). avoid-ai-writing run.

[2026-08-15] ingest | React — the baseline the spoke kept measuring against without holding

Quality cycle, weakest-tiered-base first: this spoke had n=5 tiered pages across 13 pages on 2026-08-13, the thinnest floor in the corpus, and coverage edge 4 named the reason — not one of React, Vue, Svelte, Solid or Angular was paged. astryx is a design system on a reconciler and opentui ships one for the terminal; both were being described against a norm the corpus did not contain. react added from react.dev (T1).

What it supplies. The render/commit model in the docs' own words — "Rendering is React calling your components," a pure calculation, with commit touching the DOM only "if there's a difference between renders." That is the cost model every reconciler here is a variation on, and the one flutter-performance-200-hours describes from the practitioner side: calling components is cheap, touching the surface is not.

The unexpectedly useful half is "Thinking in React," which gives two mechanical procedures rather than principles: three disqualifying tests for what counts as state (unchanged over time / passed in via props / computable → not state), and an algorithm for where it lives (every component that reads it → closest common parent → put it there or above, and invent a component to own it if none fits).

Recorded as a cross-spoke tension, not duplicated: React places state by read set, while ../frontend-architecture-wiki argues features own their state and that ownership boundaries are what large applications fail on. The closest common parent of everything reading a value is often in a different feature from the one that conceptually owns it — two answers to one question, and the spoke should not assume they agree.

Coverage edge 4 one-fifth closed; a second framework is what turns a baseline into a comparison. Tier floor T1 1 → 2.

[2026-08-18] ingest | shadcn/ui — the code-distribution answer

Routed by the hub from Telegram. https://github.com/shadcn-ui/ui — MIT, TypeScript, 121,529★, 9,887 forks, first commit 2023-01-04, CLI shadcn@4.18.0 (2026-08-13). T1 (first-party repo + docs), freshness: volatile. Read: the README, ui.shadcn.com/docs, the changelog, and the GitHub API for the counts.

New pages: shadcn-ui (source), shadcn (Person). vercel linked cross-wiki to ../cloud-wiki — entity-index "Vercel" said "create new" and was wrong again, the third recorded instance; ls */wiki/vercel*.md found it in one command. Updated: design-system, agent-ready-ui, synthesis, index.

Three things it changes here.

A third way to package a design system. design-system had bundled-in-framework (flutter) and standalone-package (astryx). shadcn/ui copies component source into the consumer's repository and leaves it there — no package, no version, no upgrade path. Added as a table on that page.
The spoke's first internal contradiction. Astryx reaches 13,000+ apps because they all import the same package; shadcn/ui's 121k stars are for the opposite arrangement. Both are right about their own goal and cannot both be followed. Recorded in synthesis → Contradictions, with new growth edge 8 naming the missing evidence: what either choice costs a year later.
A fourth agent-ready mechanism, structural rather than documentary. The other three (runtime access, token-costed tool surface, packaged skills) shape a toolkit's surface. This one moves the code into the repository the agent is already reading, and adds a registry that answers q/limit/offset search plus an MCP server. Growth edge 1 is untouched — still no measurement from anyone.

Also noted: the component base is now a --base flag (Radix · Base UI · React Aria Components, the last promoted to first-class in July 2026), which makes the spoke's rendering-core → reconciler → framework → design-system stack leak a little — a rung chosen at install time.

What it does not close. Coverage edge 5 (the CSS layer) stays open: Tailwind is underneath shadcn/ui but is not paged, and one project's dependency is not a source on the utility-class argument. Coverage edge 4 stays open too — this is not Vue, Svelte, Solid or Angular.

Tier honesty. Everything is the project's own account. The star count measures adoption, not quality, and "AI-Ready" is a docs bullet with nothing behind it.

[2026-08-22] ingest | Svelte (via quality cycle)

svelte — svelte.dev docs plus repository metadata (sveltejs/svelte, MIT, 87,975★/5,210 forks/1,073 open issues, pushed 2026-08-21, v5.56.10 on npm). T1 under tier by the claim: the page rests on the artifact's own mechanism and API — the compiler model, the seven runes, the $state proxy semantics and their stated limits — all checkable against the software. The one performance claim in the docs ("lean, tightly optimized JavaScript") carries no number and is flagged in the prose rather than graded.

Coverage edge 4 goes from one-fifth to two-fifths closed, and the second member did what the edge said it would: turned a baseline into a comparison. The finding is that the comparison has no common ground. react renders by calling components and diffing the result; Svelte has no reconciler — the compiler resolves state-to-DOM dependencies at build time and emits update code. So the vocabulary this spoke has used for opentui, astryx and flutter — reconciler, render, rebuild — is React's vocabulary rather than the field's, which is recorded as a new spine section.

The second departure is where the API lives. Runes are compiler keywords, not functions: not importable, not assignable to a variable, valid only in certain syntactic positions. React's hooks are ordinary functions policed by convention and a linter. Every other toolkit in this corpus is a library you call; this one is a dialect you compile. The docs' own caveats are the bill — class instances are not proxied, $state.raw trades mutation for shallow reactivity, $state.snapshot exists because the proxy leaks, and reassignable exported state cannot cross a module boundary because the compiler works one file at a time.

Also folded in: a second compile-first framework beside flutter (same instinct, opposite surface, only one ships a rendering engine), and the middle-of-the-stack open question amended — two members of that rung now exist and share no mechanism.

Edge 4's residue is now precise: both members are the vendor describing itself, and an independent write-up is the whole of what the edge still wants. No dedup collision — "svelte" appeared in five spokes as a passing mention (Astro islands, Cloudflare Workers, TypeScript 7) and nowhere as a page.

[2026-09-01] ingest | Mitosis — compile the component into somebody else's framework

github.com/BuilderIO/mitosis — MIT, TypeScript, 14,055★ / 647 forks / 176 open issues / 94 watchers, created 2020-11-06, 1,909 commits, npm @builder.io/mitosis v0.14.0 across 389 versions. Read today from the repository, the docs overview and the npm registry. Routed here by the hub; runner-up ../dev-tooling-wiki (it is literally a compiler), declined on this spoke's own precedent that the UI/component layer lives here and build infrastructure lives there. T1. New pages: mitosis, builder-io.

What it adds to the thesis. A third answer to where the sharing stops. flutter shares at runtime by owning the canvas; compose-multiplatform shares at runtime per platform; Mitosis shares at build time and nowhere else — a static JSX subset parsed to "a simple JSON structure", then serialized into native Angular/React/Qwik/Vue/Svelte/Solid/React Native source with nothing of itself left in the artifact. On the who owns the pixels axis it is the first entry that owns none and never runs, and it reads as svelte's compile-away move taken one step further: compiling not to DOM operations but to another framework's source.

Coverage edge 6 is half-filled, from the wrong side. The spoke wanted the web-components story and never had it. Mitosis supplies the prosecution — no native SSR, no real integration with framework features such as React context, and "their own rendering libraries and dependencies" — in its own marketing. The edge now asks specifically for the defence.

The distribution tension gets a third position. astryx ships a package, shadcn-ui copies source into your repo, Mitosis generates the copies from one source. Same conclusion as shadcn/ui about what a developer should receive, same conclusion as Astryx about a single source of truth, and a different bill: not upgrade path, not escape hatch, but expressiveness — the shared dialect can only hold what every target supports. Recorded in synthesis.md under the existing tension rather than as a new one.

Maintenance, recorded because the marketing does not show it. 11 commits in the three months to today, last on 2026-07-21. Top contributors are Builder.io's own (steve8708 721, samijaber 487, mhevery 74 — the creator of Qwik, one of the compile targets). But four of the last five human commits are mfranzke, Maximilian Franzke, UX Engineering Lead of the DB UX Design System and its top human contributor with 2,673 commits there; nmerget is in both projects' contributor lists too. The README asks openly for contributors. So the recent upkeep of a 14k-star compiler comes partly from the downstream consumer the README cites as its example. Held as an observation with its sample size stated, not as a diagnosis.

Not evidenced: no per-target maturity labels anywhere in the docs, no benchmark, and nothing comparing generated React to hand-written React.

[2026-09-03] ingest | js-framework-benchmark — the measurement edge 9 asked for

Source: https://github.com/krausest/js-framework-benchmark (T2, Dataset). Research pass, quality cycle. Selected because this spoke had never been hunted — the hub's new least-recently-hunted ordering put it first on its first day of use.

Read from the published result set (webdriver-ts-results/src/results.ts), not the interactive page, which builds its tables in the browser and returns an empty shell to a fetch. Extracted the keyed entries for Svelte 5.42.1, React 19.2.0 hooks, React 19.0.0 compiler-hooks, Vue 3.5.39 and vanilla JS, taking the median of each benchmark's published runs.

The finding, and it cuts both ways. Svelte ships 9.7 KB brotli against React's 51.4 — 5.3×, where the compile-away framing implies far more, and vanilla JS at 2.5 KB shows how much of the 9.7 is still framework. Eight of the nine timing benchmarks separate the two by under 1.7×. The ninth, swap two rows, separates them by 7× (12.6 ms against 89.9), which is precisely the case where a diffing reconciler must establish that almost nothing changed. react-compiler-hooks measures 90.4 ms on the same swap, so the React Compiler memoises components without removing the cost the reconciler is — which contradicts the trade write-ups saying it "significantly narrows the gap."

Retraction. svelte has carried since ingest that "nobody has measured a Svelte application against a React one." Somebody has, for years. Retracted in place with the date and the numbers, and claims-checked: recorded. The claim was written without being checked.

Growth edge 9 half closed; residue written as edge 9a — the benchmark is a table, not an application, and the missing source is a team that shipped one product on both. avoid-ai-writing run. Verify deferred to the cycle's single end-of-run gate per hub policy.

[2026-09-27] quality | quality cycle

flutter-3-44 regraded stable (dated release post). Scorecard in the hub quality-log.md.

[2026-10-05] ingest | Strawberry: rewriting 130K lines from React to Svelte (via research pass)

strawberry-react-to-svelte (T3, Dendrite Systems' own blog, 2026-03-09). Hunted for Most wanted #34 / edge 9a. The first team in the spoke that shipped one product on both frameworks: new-tab FCP 300 → 124 ms, re-renders during token streams cut 10×, no method stated for any figure. Edge 9a half closed; residue written as 9b. Inbound links from svelte and react. No entity pages: the company and its CEO appear once in the corpus, and nothing was found to verify a same-as:.

[2026-10-05] quality | quality cycle

svelte refreshed (stale past its 30-day window): v5.57.1, 88,284★, overview unchanged. Scorecard in the hub quality-log.md.