# franken_manim — Technical Due-Diligence Assessment

**The hook:** A 325,255-line, **unsafe-free** Rust rewrite of manim — whose README opens by warning you it's written in the future tense, and whose own status docs then count the 93 placeholders it still ships.

*Hook audit:* every clause was checked at the pinned HEAD. "Unsafe-free" holds as a design posture: 23 of 24 authoritative crate roots carry `#![forbid(unsafe_code)]`; the sole exception is `fmn-python`, whose `unsafe` is confined to the PyO3/CPython buffer and method-cache boundary (FFI by necessity, not by choice). The "future tense" warning is the README's own second paragraph. The "93 placeholders" is the repo's own 2026-09-09 reality-check count — dated in the audit because the ledger has since grown by exactly one row. Nothing in the line is mine.

**Tier legend (Rulebook §1):** **[Verified]** direct inspection of the pinned clone or a live page read by the analyst — flavors **[Counted]** (I ran the count), **[Git-observed]** (git metadata), **[Code-verified]** (source read). **[CI-observed]** is Tier 2 (seen executing on live CI pages — attests the suite *runs*, not that it is green). **[Maintainer claim]** asserted in README/docs, not independently executed. **[External]** independent sources. **[Inference]** analyst judgment, always labeled. Confidence: **High** / **Medium** / **Low**.

## TL;DR

franken_manim is a genuinely substantial, pre-1.0 clean-room reimplementation of 3b1b's manim in pure Rust: 24 workspace crates plus 2 G0 spikes (325,255 lines of Rust across 460 files), 3,312 `#[test]` occurrences, real rendered scenes, four prereleases (v0.1.0–v0.4.0), and the two load-bearing novel components — the analytic Bézier renderer (Lumen) and the clean-room TeX-math engine (fmd-math, upstreamed into franken_markdown) — implemented and tested within bounded evidence. The asupersync dependency question is settled and the answer is *peripheral*: a batch-farm/scheduler dependency, never in the frame loop [Verified, High]. The headline claims must be read through the author's own explicit disclaimer: **the README is written in present tense as if the 1.0 design were fully realized; it is a spec of the target, not a description of the present** [Verified, High]. The honest current-state document is the repo's own `docs/IMPLEMENTATION_STATUS.md` (2026-09-09): "a substantial prerelease engine with working native and Python rendering, but incomplete compatibility, interactive composition, release qualification and performance proof." Convergence gates G2, G3, G4a, G4b, G5 remain open (G1 passed); a runtime compatibility audit found **93 placeholder symbols** among 2,036 reviewed API rows; performance at the promised scale is **unproven**; there is no stable release and no package-index distribution. **TRL 5. NODUS ring: Explore.** Strongest strength: the evidence discipline — a README that disclaims itself, a reality-check status audit, bit-locked self-goldens as merge blockers, a 642-record issue tracker, and release notes that reject their own bad artifacts. Strongest ceiling: the manimlib compatibility long-tail (93 placeholders), zero qualified performance evidence, bus factor 1 with outside contributions explicitly refused, and a non-OSI MIT+OpenAI/Anthropic-rider license that withholds even benchmarking rights from the two leading AI labs.

## Quick Links

- Repository: https://github.com/Dicklesworthstone/franken_manim
- README (with the tense disclaimer at the top): https://github.com/dicklesworthstone/franken_manim/blob/HEAD/README.md
- AGENTS.md (engineering doctrine, determinism contract): https://github.com/dicklesworthstone/franken_manim/blob/HEAD/AGENTS.md
- Design plan (Revision 4, the normative spec): https://github.com/dicklesworthstone/franken_manim/blob/HEAD/COMPREHENSIVE_PLAN_FOR_THE_DESIGN_OF_FRANKEN_MANIM.md
- CHANGELOG (evidence-bounded): https://github.com/dicklesworthstone/franken_manim/blob/HEAD/CHANGELOG.md
- License (MIT + OpenAI/Anthropic Rider, read verbatim): https://github.com/dicklesworthstone/franken_manim/blob/HEAD/LICENSE
- Releases (v0.1.0–v0.4.0 prereleases with artifacts): https://github.com/Dicklesworthstone/franken_manim/releases
- v0.1.0 release (scope boundaries): https://github.com/Dicklesworthstone/franken_manim/releases/tag/v0.1.0
- CI — main workflow (1,500 runs): https://github.com/Dicklesworthstone/franken_manim/actions/workflows/ci.yml
- The owned-codec commit (GIF/y4m/WAV/deterministic parallel PNG): https://github.com/dicklesworthstone/franken_manim/commit/306faa84e6ba74513c8b88fc99e1ecbf345b323a
- The honest current-state document (2026-09-09 reality check): https://github.com/dicklesworthstone/franken_manim/blob/HEAD/docs/IMPLEMENTATION_STATUS.md

## Did you know?

The v0.3.0 release notes document that the release tooling — DSR, the project's own release-build pipeline (the acronym is never expanded in the repo; the v0.1.0 notes say builds are done "natively with DSR … without GitHub Actions") — "incorrectly summarized a stale 0.2.0 Windows binary as successful. That artifact was rejected and is not attached. The manifest records both run identifiers and the rejection." A release process that publishes, in the release notes, the artifact it refused to ship [Verified on the releases page, High].

## Franken-worthy next steps

These are research directions, not engineering tickets: each is novel, specific, falsifiable, and backed by rigor this project has already demonstrated.

1. **fmd-math vs KaTeX/Typst on a shared occurrence corpus.** fmd-math is already the suite's largest upstream contribution, living in franken_markdown with a public coverage ratchet (99.797% occurrence-weighted parse+layout on 17,711 frozen occurrences) and Appendix-G parameter conformance. Run the identical frozen corpus through KaTeX and Typst, measure occurrence-weighted parse+layout coverage on the same construct set, and blind-judge side-by-side rendering. **Falsification:** if fmd-math's coverage trails KaTeX by more than 2 percentage points on the shared corpus, or its Appendix-G parameter conformance diverges from TeX's published parameters where KaTeX's does not, the "KaTeX/Typst-class" claim dies. The corpus harvest, ratchet machinery, and honest tiering already exist — this is the project's own method turned outward.
2. **The input closure as portable provenance for generated media.** The content-hashed input closure (sources, engine and suite commits, toolchain, config bytes, seeds, font hashes, backend identities, locale) plus its sidecar manifest is the closest thing in this research program to portable, verifiable provenance for a generated artifact — the render-pipeline equivalent of a reproducible build, per the README. **Falsification:** hand a render plus its closure manifest to an independent party holding only the pinned toolchain; if they cannot reproduce bit-identical frames, or if any uncontrolled input (locale, fontconfig, timestamp, thread count) leaks into the bits undetected, the closure model fails. The thread-count-invariance smoke (1/4/16 threads, one scene) is the pilot of exactly this experiment.
3. **Analytic rasterizer vs the incumbent stack, on shared ground.** Lumen's analytic nonzero-winding fill and true curve-distance strokes make a strong claim: exact curve math beats GPU-workaround approximations while keeping the 3b1b look. Test it on neutral ground — a curve-heavy SVG corpus rendered by Lumen, resvg, and Skia, scored with SSIM and edge-distance metrics plus 1080p throughput. **Falsification:** if the analytic renderer cannot match resvg at ≥0.95 SSIM-equivalence on the shared corpus, or is more than 3× slower at 1080p with no compensating quality win (thresholds are the analyst's, not the project's [Inference, Medium]), the "analytic beats approximation" thesis weakens. The Look Gallery and engine-equivalence suite are the in-house version of this comparison.
4. **Export the parity-ledger method.** The symbol-granular Parity Ledger (2,483 rows), the 103-site fail-closed refusal inventory, and the runtime truth gate (`fmn-python --audit-parity`, which self-audits the wheel's embedded overlay bytes) are a conformance method, not just a test suite. **Falsification is pass/fail:** point the ledger machinery at a *different* API surface (Manim Community Edition's API against this engine, or a second clean-room reimplementation) and publish the divergence report within one focused workstream (≤2 weeks of agent-assisted labor); if the apparatus cannot be decoupled from the manimlib schema within that bound — zero manimlib-specific code paths remaining — it is product scaffolding, not a method.
5. **Agent-generated animation with certified bits.** The WASM fixed-scene renderer, the FMTL/1 serialized-timeline bundle player (FMTL — the bundle format magic; `docs/FMNT1_TIMELINE_BUNDLE.md`), and the deterministic codecs could turn AI-generated explainer video into verifiable, hash-chained artifacts: generate a scene, render it, publish the input-closure manifest, and let anyone re-derive the bits. **Falsification:** build an agent loop that generates, renders, and publishes a non-toy scene (a 60-second 1080p scene with ≥3 Tex formulas and one SVG import) end-to-end; if a third party cannot reproduce bit-identical frames from the published manifest, or the WASM/player path cannot carry the closure through, the thesis fails. This is the agent-era workload the deterministic architecture was built for.

---
## 4.1 Header

| Field | Value |
|---|---|
| Repository | https://github.com/Dicklesworthstone/franken_manim |
| Pinned revision | `d3a8090e6950a440876f5eb389b6b9fbb5f910d4` — 2026-09-22 10:59:17 -0400 (14:59:17 UTC) [Verified, High] |
| Assessment date | 2026-09-22 |
| Language / toolchain | Rust, edition 2024, pinned `nightly-2026-08-31` (`rust-toolchain.toml`; wasm32 target listed) [Verified, High] |
| Workspace version | 0.4.0 (workspace `Cargo.toml`) [Verified, High] |
| License | MIT License **with OpenAI/Anthropic Rider** — NOT OSI open source; full text read verbatim, rider scope quoted in §4.8 [Verified, High] |
| Scale | 24 workspace crates + 2 G0 spikes (26 members); 325,255 Rust lines / 460 files in `crates/`; spikes 11,798 lines / 28 files; 3,312 `#[test]` occurrences (3,299 distinct fn names; 1,699 in `src/`, 1,613 in `tests/`) [Verified, High] |
| Stars / forks | 9 stars / 2 forks (GitHub API, 2026-09-22) [External, High] |
| Releases / tags | v0.1.0 (2026-08-15) through v0.4.0 (2026-08-18), all marked pre-release, with signed-checksum artifacts for Linux x86-64 / macOS arm64 / Windows x86-64; no stable release; no package-index publication [Verified, High] |
| Last push | HEAD commit 2026-09-22 14:59:58 UTC; CI run #1500 pending at fetch time [Verified/API + CI-observed, High] |
| Maintainer | Single: Dicklesworthstone (Jeffrey Emanuel, per LICENSE copyright) — bus factor 1; outside contributions explicitly refused [Verified, High] |
| Inception | 2026-07-20 per CHANGELOG [Maintainer claim, High] |

**Analyst method.** Fresh shallow clone of HEAD (`--depth 50`; 54 commits visible in the window, all dated 2026-09-21 — one day of this tree's extreme velocity) to `~/workspace/.scratch/frankenmanim-verify/`. Read: README (full), AGENTS.md (full), LICENSE (verbatim), CHANGELOG (release timeline + evidence boundaries), `docs/IMPLEMENTATION_STATUS.md` (the 2026-09-09 reality-check audit), `docs/api/ledger.tsv` (row counts/statuses), `UPSTREAM_LEDGER.md` (13 rows), workspace and per-crate `Cargo.toml` (members, pins, asupersync usage), `rust-toolchain.toml`, `.beads/issues.jsonl` (status counts). Grep-verified: crate members, Rust line/file counts, `#[test]` occurrences, `forbid(unsafe_code)` per crate root with classification of every residual `unsafe` hit, behavior-note count (27), CI workflow count (87), ledger statuses, Scribe coverage figures, determinism evidence wording. Fetched and confirmed resolution of every Quick Link; read the releases page (v0.1.0–v0.4.0 notes). Web-searched for independent coverage (found none — all hits are the repo's own pages or the maintainer's profile). GitHub API for stars/forks/push date. **Not done:** did not compile, run tests, execute a render, reproduce any measurement, or audit manim's source; the 2026-09-21-only window means authorship/branch archaeology beyond one day is from docs, not git. CI per-run pass/fail is not fully legible from text scraping — reported as "executes; greenness unknown per run."
## 4.2 Executive verdict

franken_manim is a **genuinely substantial, pre-1.0 clean-room Rust reimplementation of manim** [Inference, High] — not vaporware: a shallow clone of HEAD confirms 24 workspace crates and 325,255 lines of first-party Rust [Verified, High], real scenes rendered natively and through the `fmn-python` portal [Maintainer claim with retained receipts, Medium], four prereleases with checksum-published multi-platform artifacts [Verified, High], a 2,483-row machine-readable Parity Ledger with a fail-closed runtime self-audit [Verified, High], bit-locked self-goldens as merge blockers [Maintainer claim, Medium], and 3,312 test occurrences across unit and integration suites [Verified, High]. Its two load-bearing novel components are real: the analytic Bézier renderer (Lumen — nonzero-winding coverage evaluated analytically on the curves, true curve-distance strokes) [Verified code-volume + design docs, High; behavioral quality Maintainer claim, Medium] and the clean-room TeX-math layout engine (fmd-math — atom classes, spacing table, Appendix-G placement rules 11/12/13/13a/15/18/19, extensible delimiters) [Verified upstream ledger + pin, High], which this program contributed upstream into franken_markdown and which the ledger calls "the largest upstream contribution in suite history." **But:** the README is explicitly a 1.0-target spec, not a current description [Verified disclaimer, High]; the repo's own status audit counts 93 placeholder symbols among 2,036 reviewed API rows, leaves gates G2/G3/G4a/G4b/G5 open, labels performance observations "host-unqualified," and certifies determinism on exactly one circle scene on one Linux build; the bus factor is 1 with outside contributions explicitly refused; and the license rider withholds even benchmarking rights from OpenAI and Anthropic [all Verified, High]. **TRL 5. NODUS: Explore. Wardley: custom-built math-animation engine approaching early product, with the analytic renderer and TeX engine as the genesis-stage novel elements.** The asupersync question — the dependency every sibling packet asks — resolves here to *peripheral*: a batch-farm/scheduler tool, never the frame loop. The most durable contribution today may be the **evidence machinery** (parity ledger, fail-closed refusals, the reality-check audit cadence), not the engine [Inference, Medium].

## 4.3 Claim inventory: demonstrated vs aspirational

Status values: *demonstrated* / *partially demonstrated* / *aspirational* / *disproven* / *stale*. The README's own tense disclaimer (L25) governs every headline claim: they describe the 1.0 target state.

| # | Claim | Status | Evidence |
|---|---|---|---|
| 1 | Native TeX math typesetting, no LaTeX/Pango/system fonts anywhere | **Demonstrated (bounded)** | [Verified, High] — fmd-math pinned as git dep at rev `82588865…` (franken_markdown); `fmn-tex` 1,980 lines consumes it; Scribe reports 99.797% occurrence-weighted parse+layout on a 17,711-occurrence frozen corpus [Maintainer claim, Medium — "not all TeX"]; the long tail (`\substack`, exotic environments) is explicitly tiered out |
| 2 | Analytic Bézier renderer: nonzero-winding coverage on real curves, true curve-distance strokes | **Demonstrated (bounded)** | [Verified design + volume, High] — `fmn-render` 36,907 lines (largest crate); G0-8b analytic-fill ratification; Look Gallery judges against Reference imagery [behavioral quality Maintainer claim, Medium] |
| 3 | `--reproducible`: bit-identical renders "across the certified platform matrix, at any thread count" | **Mostly aspirational** | [Maintainer claim, Medium] — demonstrated narrowly: circle scene 160×90 @8fps, identical PNG bytes + digests at 1/4/16 threads, one Linux build. The status doc's own caveat: "This is one scene on one Linux build, not full cross-platform or high-core certification." Python `--reproducible` fails closed with capability exit 4 by design. G4b open |
| 4 | `fmn-python` runs existing manim scenes "source-unedited" | **Partially demonstrated** | [Maintainer claim, Medium] — real scenes render (square-to-circle, Tex formulas); all three installed acceptance suites pass on fresh wheels. But the runtime parity audit rejects **93 placeholder symbols** among 2,036 reviewed rows [Verified in the repo's own 2026-09-09 status doc, High]. "Source-unedited" holds for covered scenes, not the whole surface |
| 5 | One binary; ffmpeg the only external tool | **Demonstrated** | [Verified, High] — native y4m/PNG/GIF outputs exist; owned codecs (deterministic PNG, GIF89a, y4m, WAV); ffmpeg invoked sandboxed and optional; no LaTeX/Pango/fontconfig on any path |
| 6 | `#![forbid(unsafe_code)]` in every authoritative crate (PyO3 binding crate the sole exception) | **Demonstrated** | [Verified, High] — 23/24 crate roots carry the attribute; `fmn-python` is the exception with a handful of `unsafe` sites (buffer protocol, method cache); every other `unsafe`-word hit in the tree is prose or string literals; ADR-0016 routes SIMD through `std::simd` in crate-wide build tiers rather than per-call unsafe dispatch |
| 7 | Performance: 96-core saturation, 60fps 1080p, SIMD tiers, ≤0.5× Reference wall-clock | **Aspirational / unproven** | [Verified, High] — these are PG-1…PG-8 *gate targets* in the plan; `PERFORMANCE_GATES.md` "explicitly labels committed observations host-unqualified"; no qualified measurement published. SIMD build tiers exist as mechanism (`std::simd`, crate-wide tiers per ADR-0016) |
| 8 | Installable releases on all platforms | **Partial** | [Verified, High] — real prerelease archives + CPython 3.13 wheels for v0.1.0–v0.4.0 (Linux x86-64, macOS arm64, Windows x86-64), checksum-published but unsigned; no stable release — `/releases/latest` resolves to the releases index, not a release (all marked pre-release); no package-index publication: the `franken-manim` PyPI JSON and simple endpoints return 404 (checked live 2026-09-22; the repo's own 2026-09-09 status doc confirms both), and "the npm package is verified as a tarball but is not published to npm" |
| 9 | 161-class mobject library; 663-name `manimlib` namespace in the wheel | **Demonstrated (bounded)** | [Verified counts in docs, High] — AGENTS.md: "the 161-class mobject library"; v0.2.0 release notes: "the exact 663-name root namespace." Namespace presence is verified; per-symbol behavioral parity is the 93-placeholder gap in claim 4 |
| 10 | Deterministic owned codecs (PNG/GIF/y4m/WAV), cross-validated against independent oracles | **Demonstrated** | [Verified commit + docs, High] — owned GIF89a encoder (ImageMagick and ffmpeg accept output; in-test LZW decoder oracle); WAV cross-validated against CPython-generated fixture matrix; PNG sequences bit-identical at {1,4,16} threads ("the load-bearing PG-5 property") [Maintainer claim on execution, Medium] |
| 11 | asupersync powers the runtime | **Disproven (as a runtime claim)** | [Verified, High] — asupersync is a pinned workspace dep, but per-crate manifests show: `fmn-cli` optional behind the `batch` feature, `fmn-platform` optional (non-wasm), `fmn-runtime` **dev-dependency only** ("asupersync never enters the frame loop"; production uses std scoped threads). It serves multi-scene `batch` farms and the scheduler lab, not the frame loop |
| 12 | Certified platform matrix (linux-x86-64, linux-aarch64, macos-aarch64) bit-identity | **Aspirational** | [Verified, High] — the matrix is *defined* (README/AGENTS.md determinism contract; Windows excluded by ADR-0019 "until bit-identity is measured on native Windows hardware"); no cross-platform bit-identity measurement published. v0.4.0 notes: "Pinned bare-metal PG measurements, full cross-platform certified closure… remain open work" |
| 13 | Studio: crash-isolated live iteration, scrubbing, inspection | **Partially demonstrated** | [Maintainer claim, Medium] — browser-tested embedded UI, real worker/socket routes, journal replay; but the shipped native Studio worker "still rejects live input" (`fm-ffj.72`, G3-blocking) [Verified in status doc, High]. Python Studio/reload/embed is further along |

**"Certified bit-reproducible" scrutiny:** the certification story is the project's weakest headline. What exists is a serious *mechanism* (content-hashed input closures, rational clock, one seeded NumPy-bit-compatible RNG, owned deterministic codecs with bit-locked goldens) plus *narrow* evidence (thread-invariance on one scene/one host). What does not exist is the certified platform matrix itself. The status doc grades it "Implemented; full certification UNPROVEN" and leaves it to gate G4b. **Verdict: the determinism architecture is real and unusually serious; "certified" is a 1.0-target claim, not a current fact.**

## 4.4 Architecture (reconstructed, not summarized)

[Verified from the clone; README/AGENTS.md diagrams treated as claims where noted]

**Crate topology (24 workspace members + 2 G0 spikes, `Cargo.toml`):** the ten named subsystems use the project's own names — **Substrate** (`fmn-core/dmath/hash/config/platform`), **Chisel** (`fmn-geom`, 16,082 lines: shared-anchor quad paths, one error-bounded cubic→quad converter, true arc length with inverse-arclength LUT, path booleans, SVG processor), **Marionette** (`fmn-mobject`, 10,749 lines: Stage arena, generational handles, CoW snapshots, RecordBuffer, view protocol), **Choreo** (`fmn-anim`, 9,103 lines: Animation contract, RationalFrameClock, six-step frame order, FramePacket freeze), **Lumen** (`fmn-render`, 36,907 lines, largest crate: tiled scanline analytic nonzero-winding fill, true curve-distance strokes, retained render IR with per-resource revisions, feature-gated `metal.rs` via frankentorch's gateway), **Scribe** (`fmn-text`, `fmn-tex` 1,980 lines: native shaping/layout over pinned `fmd-font`/`fmd-math`, native span maps), **Menagerie + Atlas** (`fmn-library`, 36,608 lines: the 161-class mobject library), **Proscenium** (`fmn-scene`, `fmn-studio` 17,815 lines, `fmn-cli` 11,441 lines), **Reel** (`fmn-output` 9,296 lines, `fmn-frame`, `fmn-codec`, `fmn-cache`: owned deterministic PNG/GIF/y4m/WAV codecs, ordered async emitter, negotiated ffmpeg boundary), **Gauntlet** (`fmn-conformance`, 33,907 lines: Parity Ledger, API schema, self-goldens, Look Gallery, e2e scenarios, fuzz targets). Plus `fmn` (the native Rust API crate), `fmn-python` (19,985 lines: the PyO3 portal), `fmn-wasm` (fixed-scene renderer + FMTL timeline player), and `fmn-runtime` — a scheduling seam (ExecutionPlan from HardwareTopology, bounded FramePipeline) implementing "the scheduler is free, the semantics are sacred."

**Data flow:** scene definition (Rust API or `fmn-python` portal) → Proscenium scene runtime → Choreo timeline (rational clock, frozen FramePackets) → Marionette mobject records → Lumen retained render IR → Reel codecs/emitter → PNG/GIF/y4m/WAV or sandboxed ffmpeg. The Studio runs as supervisor + isolated scene-worker subprocess with journal replay.

**Memory-safety posture** [Verified, High]: 23 of 24 crate roots carry `#![forbid(unsafe_code)]` (both `lib.rs` and `main.rs` in `fmn-cli`). The sole exception is `fmn-python` (PyO3 expansion), where the `unsafe` sites are the buffer-protocol impls and one method-cache pointer read — a small, bounded FFI surface. Every other `unsafe`-word occurrence in the tree is prose ("unsafe component", "unsafe thermal path") or test string literals. This is the strongest unsafe posture in the assessed program.

**The G0 spikes as evidence structure:** before the interfaces froze, the project ran "G0: The Laws of the Machine" spikes to retire load-bearing unknowns — ratified docs live in `docs/g0/`. G0-8b ratified analytic fill (closed-form quadratic roots, winding-deposited tiles); G0-6 (determinism) and G0-8 (accelerator) defined the constraints the production crates then had to satisfy; G0-8 found frankentorch's GPU gateway couldn't serve custom kernels and the fix landed upstream (see strength 5). The spikes are how the project de-risked its two novel components before building them [Verified in docs/g0 + UPSTREAM_LEDGER.md, High].

**Dependency posture:** the governed closure (D1) — workspace `Cargo.toml` pins sibling FrankenSuite crates as git dependencies by exact rev (`asupersync`, `fmd-font`/`fmd-math` from franken_markdown, `fnp-*` from franken_numpy, `fsci-*` from frankenscipy, `fnx-*` from franken_networkx, `fp-*` from frankenpandas, `ft-kernel-metal` from frankentorch), with `governed_closure.rs` enforcing rev == `SUITE.lock` and `SUITE_ALLOWLIST.tsv` gating the transitive closure; CI fails on unlisted packages [Verified in manifest, High]. Dependency edges point strictly downward (lower subsystems never depend on higher ones — the plan's §19 and the clone's AGENTS.md); the workspace lists all 26 members (24 product crates + 2 spikes) with no `default-members` override [Verified, High]. **Asupersync: present but peripheral** — optional behind features or dev-only; never in the frame loop. This is the notable asupersync finding of this packet: the suite's async runtime is a batch-farm and scheduler-lab tool here, not the engine's heartbeat.

**README-vs-code drift (governance signal):** remarkably little. The one material mismatch is the license: `Cargo.toml` declares `license = "MIT"` while LICENSE is MIT **with the OpenAI/Anthropic rider** — the manifest understates the restriction [Verified, High]. The ledger is nearly exact: status doc cites 2,482 generated rows (2,071 same / 170 improved / 99 tiered / 142 excluded); HEAD counts 2,483 rows (2,071 same / **171** improved / 99 tiered / 142 excluded) — one row of drift, honestly attributable to a moving tree. The README's present-tense spec style is itself the largest "drift" risk, which is why the tense disclaimer exists and why the packet grades against the status doc, not the README.

## 4.5 Benchmark and conformance audit

### Maintainer-produced numbers

This project publishes no comparative benchmark table — its performance story is a set of *gate targets* (PG-1…PG-8), not results. That absence is itself a finding: there are no numbers to misread.

| Claim (depth) | Status | Method controls | Would it survive independent rerun? |
|---|---|---|---|
| PG-1: `OpeningManimExample`-class scenes, 1080p export ≤ 0.5× the Python Reference's wall-clock at G2, ≤ 0.35× at G4 | **Target, unmeasured** | Pinned bare-metal profiles defined in plan §17 | No measurement exists to rerun; the status doc says committed observations are "host-unqualified" |
| PG-3: ≥ 60 fps 1080p interactive preview; ≥ 30 fps 4K export | **Target, unmeasured** | Same | Same — target only |
| PG-5: bit-identical raw frames at {1,4,16} threads per commit, {32,96}+ weekly | **Partially demonstrated** | PNG-sequence encode bit-identical at {1,4,16} threads; the retained Sept-9 smoke receipt (RCH-built `b59efae5`, SHA-256 `9377c453…`): circle scene 160×90 @8fps, PNG bytes + artifact digest + closure digest match at 1/4/16 threads, one Linux build | The thread-sweep mechanism dates to the 2026-07-23 owned-codec commit and is rerunnable; the committed evidence is one scene on one host |
| PG-8: builtin timing overhead ≤ 1.10× budget | **Target; historical measurement adverse** | Historical builtins measured 3.55× versus the 1.10× budget on an older unqualified ABI/build | Risk evidence, not a current timing verdict [Maintainer claim in status doc, Medium] |
| 96-core workstation saturates on a single scene | **Target, unmeasured** | Topology-aware render teams (fmn-runtime ExecutionPlan) | No measurement published |
| Scribe: 99.797% occurrence-weighted parse+layout on 17,711 frozen occurrences; 99.994% parse-only | **Demonstrated (bounded)** | Frozen corpus from the G0 harvest of the real 3b1b video tree; public ratchet | [Maintainer claim, Medium] — "not all TeX"; "neither universal TeX support nor a fresh run in this audit" |
| Zero steady-state per-frame heap allocations (PG gate) | **Target** | Profiler lanes in fmn-runtime | Unmeasured in published evidence |

**The honest disavowal, quoted:** `PERFORMANCE_GATES.md` "explicitly labels committed observations host-unqualified," and the CHANGELOG's evidence boundaries list "pinned-host performance-gate receipts" and "platform-native SIMD and certified bit-identity matrices" as *not established*. A packet must never cite the 96-core/60fps language as a result.

**Reproduction cost (honest):** pinned `nightly-2026-08-31` toolchain with the wasm32 target, the exact `SUITE.lock` rev pins across seven sibling repos, RCH (Remote Compilation Helper) remote-execution for the sanctioned gates, and a tree that absorbed 54 commits in the visible depth-50 window, all dated 2026-09-21 — an independent rerun is hours of setup before the first measurement, and the tree may have moved underneath you.

### Conformance evidence

- **Parity Ledger:** 2,483 machine rows (2,071 same / 171 improved / 99 tiered / 142 excluded) generated from one API schema shared by both front doors; the authored Python overlay has 2,275 rows; the refusal inventory counts 103 sites (63 explicit `NotImplementedError`, 40 `_refuse_unrouted`) [Verified counts, High]. The runtime truth gate (`fmn-python --audit-parity`) makes `same`/`improved` rows mechanically falsifiable: exit 0 only if every reviewed row resolves to a real non-placeholder runtime value [Verified mechanism exists, High].
- **Self-goldens:** bit-locked merge blockers on the project's own outputs (geometry snapshots, frame hashes) [Maintainer claim, Medium].
- **Look Gallery:** side-by-side renders vs captured Reference imagery, human-judged (at-least-as-good / different-but-fine / regression) with SSIM/edge-distance smoke alarms [Maintainer claim, Medium].
- **Acceptance suites:** all three installed acceptance suites pass on fresh CPython 3.13 wheels (with SHA-256'd wheel identities and raw receipts) [Maintainer claim with receipts, Medium].
- **Fuzzing:** SVG, TTF, YAML-subset, TeX strings, PNG/JPEG with resource-budget assertions; "sanitizer replay of the repaired SVG fuzz input" is listed as not established [Maintainer claim, Medium].
- **CI:** 87 workflow files (many with bead-scoped names) [Verified count, High; the name-pattern read is Medium]; the main `ci.yml` shows 1,500 runs with per-commit execution; per-run pass/fail not fully legible from text scraping — "CI executes; greenness unknown per run" [CI-observed, High].

### Independent numbers

**None found.** Web search returns only the repository itself, its docs/commit pages, and the maintainer's profile README (which itself cites the project's 14-day activity: 493 commits, +44,147/−3,984 lines) [External, Medium within recall caveats]. No third-party benchmark, code review, or production deployment found. **Independent validation: zero.**
## 4.6 Comparison: who owns the lane

**The incumbent** is manim itself — in two dialects: Grant Sanderson's `3b1b/manim` (the engine behind the actual 3Blue1Brown videos, pinned here as the Reference at `6199a00d4c1b1127ebe45cb629c3f22538b10e13`) and the community-maintained Manim Community Edition, which owns the broader user base, documentation, plugin ecosystem, and Stack Overflow answer corpus [External, Medium]. **Why the incumbent wins today, in one paragraph:** the switching cost for a creative tool is the ecosystem, not the engine — CE and manimlib have years of tutorials, plugins, and answered questions; franken_manim has 9 stars, no community, 93 placeholder symbols in its compatibility surface, and a Python portal whose certified mode fails closed by design. Nobody re-renders their courseware on a 0.4.0-prerelease single-maintainer binary to get a rational clock. And the manim community already has the standard determinism workaround — containers and pinned environments — which is good enough for the users who care, leaving "bit-reproducible" as a feature with no buyer attached [Inference, Medium]. The project's own FAQ concedes the relationship question explicitly: with Community Edition, "None, deliberately."

**Adjacent lanes:** **KaTeX / Typst** (own the "math on screen without LaTeX" lane for the web and documents — the quality bar fmd-math explicitly targets: "side-by-side indistinguishable at a glance from LaTeX"); **resvg / Skia / Cairo** (own 2D vector rasterization — the throughput/quality baseline Lumen is implicitly measured against); **Remotion / Motion Canvas** (own the programmatic-video lane outside the math niche — no determinism promise, no math typesetting); **Blender's Python API** (owns scripted 3D animation generally). None of them competes on the deterministic-bits axis, which is why the lane below is unoccupied rather than contested.

**The genuinely unoccupied lane [Inference, Medium]:** *deterministic, dependency-free math animation* — one binary, no LaTeX, bit-reproducible frames, a content-hashed input closure as provenance.

**The genuinely unoccupied lane [Inference, Medium]:** *deterministic, dependency-free math animation* — one binary, no LaTeX, bit-reproducible frames, a content-hashed input closure as provenance. Nobody owns it: the manim dialects can't do it (LaTeX+Pango+GPU drivers+float drift are load-bearing in their pipelines), KaTeX/Typst don't animate, and the programmatic-video tools don't promise bits. It is a small lane — math animation is a niche, and "small" here is an inference from the absence of any market sizing, not a measurement [Inference, Medium] — but it is real, and it sharpens as agent-generated explainer video and reproducible scientific publishing grow. The lane's existence does not imply its size.

## 4.7 Technical merit and adversarial review

**Strengths:**
1. **Evidence discipline without peer in this program.** The README's tense disclaimer, the 2026-09-09 reality-check status audit that grades its own determinism "Implemented; full certification UNPROVEN," bit-locked self-goldens as merge blockers, a 642-record issue tracker as the task authority, the G0 "Laws of the Machine" spikes that retired load-bearing unknowns as ratified docs *before* the interfaces froze (spike-before-interface as a portable method — see 4.4), release notes that disclaim the README's 1.0 claims ("This is an early preview, not the README's 1.0 target-state claim") and even publish a rejected artifact with both run identifiers — this is the methodology-export lens made concrete: if the engine fails, the conformance-and-honesty apparatus survives as a transferable artifact [Verified, High].
2. **Real technical content in the hard parts.** The analytic fill (closed-form quadratic roots, winding-deposited tiles) and stroke (signed-distance, arc-length-parameterized) designs are documented with the defects found along the way; the TeX engine implements real TeX semantics (eight atom classes, the spacing table, Appendix-G placement rules 11/12/13/13a/15/18/19, extensible delimiters, span provenance) with 99%+ occurrence-weighted coverage on frozen corpora; the owned codecs were cross-validated against independent oracles (ImageMagick, ffmpeg, CPython fixtures) [Verified volume + docs, High; behavioral quality Maintainer claim, Medium].
3. **The unsafe posture is the strongest in the program.** 23 of 24 crate roots `forbid(unsafe_code)`; the only exception is the PyO3 binding crate; every other `unsafe` token in the tree is prose. SIMD goes through `std::simd` in crate-wide build tiers with per-call unsafe dispatch explicitly forbidden by ADR-0016 [Verified, High].
4. **Fail-closed is a culture, not a slogan.** The refusal inventory (103 sites), capability exit codes, the Python `--reproducible` refusal (exit 4), the runtime parity auditor that fails closed on placeholder rows, and the ADR-0019 Windows exclusion ("renders functionally, never bit-certifiably… until bit-identity is measured on native Windows hardware") — the project would rather refuse than overclaim, repeatedly [Verified, High].
5. **Upstream citizenship.** fmd-math — "the largest upstream contribution in suite history" — was built for this project and landed in franken_markdown (core + Appendix-G placement pinned; extensions in flight); the G0-8 accelerator spike found frankentorch's GPU gateway couldn't serve custom kernels and closed the gap *upstream* (generic Metal compute gateway, pinned) rather than working around it locally; it drove franken_numpy's dependency-free PCG64DXSM core. The project improves its dependencies instead of forking around them [Verified in UPSTREAM_LEDGER.md, High].

**Weaknesses:**
1. **Compatibility is the long pole, and the ledger measures existence, not behavior.** 93 placeholder symbols among 2,036 reviewed rows; the runtime audit "catches missing values and placeholder markers; it does not execute every method. A callable returning the wrong geometry may satisfy an existence audit." The eight locked seed scenes "do not represent the entire public method surface." Full manimlib semantic compatibility is a long tail, and the tail is where users live [Verified, High].
2. **Performance is asserted as targets, not measured as results.** Every 96-core/60fps/≤0.5× number is a PG gate target; committed observations are "host-unqualified"; pinned-host receipts, SIMD matrices, and certified bit-identity matrices are all listed as not established. The one historical timing measurement on record — PG-8 builtins at 3.55× versus a 1.10× budget on an older unqualified ABI/build — is explicitly labeled risk evidence, not a verdict [Verified in status doc, Medium]. The engine's speed is currently a matter of architectural argument (retained IR, glyph instancing, frame parallelism), not evidence [Verified, High].
3. **Bus factor 1, structurally.** One human (plus agent sessions per the ledger's "W6 sessions" conventions), 54 commits visible in the depth-50 window, all dated 2026-09-21, 9 stars / 2 forks, zero external contributors — and the README's "About Contributions" section explicitly refuses outside contributions: "I do not accept outside contributions for any of my projects… it's the only way I can move at this velocity and keep my sanity." Velocity and review depth cannot both survive this; succession is not a plan, it's a hope [Verified, High].
4. **The interactive story is half-built.** The shipped native Studio worker still rejects live input (`fm-ffj.72`, G3-blocking); the e2e Studio scenario "does not itself start a worker or open a socket despite its surrounding boundary language." The Studio is the flagship "extra manim never had," and its flagship interaction doesn't work natively yet [Verified in status doc, High].
5. **Distribution is prerelease-grade.** Four prereleases, checksum-published but unsigned ("no release signing key is configured"); no `/releases/latest`; PyPI and npm return 404 ("the npm package is verified as a tarball but is not published to npm because this release host has no npm registry credentials"); no Linux arm64 artifact ("no proven native Linux arm64 certification host is available") [Verified, High].
6. **The license is a strategic own-goal for the mission.** The rider withholds *all* rights — including benchmarking, testing, and analyzing — from OpenAI, Anthropic, affiliates, and anyone acting for them, with automatic termination and injunctive relief reserved to Jeffrey Emanuel. For a project whose sharpest future is agent-generated video, legally excluding the frontier labs (and chilling any enterprise downstream of them) sabotages exactly the adoption path the technology would need — and the breadth (even *benchmarking* is forbidden) helps explain why independent validation is zero: no restricted party can legally evaluate it [Verified, High]. A note on this packet's own footing: writing an assessment is "analyzing" under the rider's use definition — this assessment proceeds on the basis that the analyst is not a restricted party; a restricted party could not legally perform it [Inference, High].

**Steelman of the bear case:** franken_manim is a magnificent answer to a question the market isn't asking at a price nobody will pay. Math animation is a niche owned by two free incumbents with ecosystems; the pain points it fixes (LaTeX installs, cross-machine nondeterminism) are annoyances, not blockers — manim's users have containers and pinned environments. The novel components are the wrong shape for adoption: fmd-math competes with KaTeX and Typst, which already won "math without LaTeX"; an analytic CPU rasterizer competes with Skia and resvg, which already won 2D. "Certified bit-reproducible" is a feature no buyer has requested, measured on one circle scene. At 325,255 lines, bus factor 1, a pinned nightly, no outside contributions accepted, and a license that bars the AI labs most likely to build on it, the most likely terminal state is a brilliant, bit-rotting monument — with the consolation prize that its evidence methodology will outlive its engine. The README's tense disclaimer is honest; it's also a confession that the product being described doesn't exist yet.

**Hook audit (the packet grades its own hook):** "A 325,255-line, **unsafe-free** Rust rewrite of manim — whose README opens by warning you it's written in the future tense, and whose own status docs then count the 93 placeholders it still ships." Line count (325,255, crates/ only) and the unsafe posture (23/24 forbid; the sole `fmn-python` exception confined to the PyO3/CPython boundary) are verified; the tense disclaimer is quoted from README L25; the 93-placeholder count is from the repo's own 2026-09-09 status audit. "Warns you" is fair — the disclaimer is set as a blockquote labeled "read this first." The hook survives: every load-bearing word is verified, and the second clause is the project's own evidence turned into the lede.

## 4.8 License and governance (material, not boilerplate)

**License text, read verbatim** [Verified, High]: `LICENSE` is the MIT License **with an "ADDITIONAL RIDER / RESTRICTION (OpenAI / Anthropic)"** that is "part of the 'conditions' of this License" and "controls" in any conflict. Quoted scope: *"Restricted Parties" means OpenAI, L.L.C.; Anthropic, PBC; any of their respective Affiliates; and any person or entity acting directly or indirectly on behalf of, for the benefit of, or under the direction of any of the foregoing (including any officer, director, employee, contractor, agent, consultant, service provider, or representative).* *"Notwithstanding any other provision of this License, no rights are granted to any Restricted Party."* *"For purposes of this rider, 'use' includes, without limitation: copying, modifying, … benchmarking, testing, analyzing, indexing, or incorporating the Software or any Derivative Works into any dataset, training corpus, evaluation harness, or pipeline for machine learning or other automated systems."* Breach terminates all permissions automatically; injunctive relief and attorneys' fees reserved to Jeffrey Emanuel (copyright holder, 2026). **Classification: NOT OSI open source** — named-party discrimination with a use restriction covering even benchmarking and analysis. Source-available with a targeted exclusion.

**The rider as strategy:** defensively coherent (it prevents the two labs best positioned to absorb the work from training on it or benchmarking it without permission) and offensively self-sabotaging: the project's most credible future is agent-generated video infrastructure, the excluded parties *are* the agent-infrastructure builders, and the rider's breadth chills the independent validation the project most needs. Unlike some sibling packets' findings, the README's License section discloses the rider plainly ("The rider withholds all rights from OpenAI, Anthropic, their affiliates, and anyone acting on their behalf") — but `Cargo.toml` still declares `license = "MIT"`, understating the restriction to every tool that reads the manifest [Verified, High]. Adoption ceiling: hard.

**Governance:** owner-directed single maintainer; no outside contributions accepted by explicit policy ("I do not accept outside contributions for any of my projects… the only way I can move at this velocity"); no visible external contributors; 87 CI workflows with 1,500 main-workflow runs; the `.beads` tracker (642 records: 620 closed / 17 open / 5 in progress) is the planning surface, with a four-workstream activation cap and guarded claim tokens. Commit velocity is extreme (54 commits visible in the depth-50 window, all dated 2026-09-21; the maintainer's profile cites 493 commits / +44,147 −3,984 lines over 14 days [External, Medium]). Bus factor 1 [Inference, High]. **What breaks first if velocity decays:** review depth, then the tree — the status audit already documents the pattern ("the gap between a working lower-level mechanism and the whole public operation that promises to use it"), and 325k lines on a pinned nightly with no successor is bit-rot within quarters.
## 4.9 NODUS factsheet

| Criterion | Score (1–5) | One-line justification |
|---|---|---|
| Technology readiness (TRL 1–9) | **5** | Working prerelease: real scenes render natively and via the portal, four prereleases shipped, 3,312 test occurrences; the full 1.0 product (compat long-tail, Studio interactivity, certified determinism, qualified performance) is TRL 4–5, with G2–G5 open |
| Strategic relevance | **3** | High *within* the FrankenSuite (the "math on screen" keystone; driver of fmd-math/fmd-font); standalone, math animation is a genuine but small niche |
| Impact potential | **3** (4 if the certified-determinism lane proves out) | If completed: the only deterministic, dependency-free math-animation engine — real impact on reproducible scientific visualization and agent-generated video; second-order impact as the flagship proof of the FrankenSuite composition model |
| Implementation feasibility | **4** | The hard novel parts (analytic renderer, TeX engine, deterministic codecs) are built and tested within bounded evidence; remaining work is integration, the compatibility long-tail, and qualification — tractable at demonstrated velocity, with performance qualification the main feasibility risk |
| Time to mainstream | **2** | 1.0 with full manimlib semantics plausibly 6–12 months at current velocity; "mainstream" (stable release, indexed distribution, community) 12–24 months — and the rider caps even the best case by chilling adoption and independent evaluation; niche ceiling regardless |
| Collaboration potential | **1** | Single author, outside contributions explicitly refused, 9 stars/2 forks; the rider narrows the pool further; manimlib API compat is the only inbound lever |

**Ring: Explore.** The ring rules are decisive: *Pilot* requires a release artifact plus a bounded, real-workload fit (only prereleases exist; the compatibility surface is 93 placeholders short); *Invest* requires independent validation plus governance (independent validation is zero; governance is bus factor 1 with contributions refused). Explore is the default for substantive-but-unproven, and franken_manim is the definition of it. The **fmd-math TeX engine as a component** is arguably Pilot-grade for embedding. Revisit triggers: first stable release, G4a/G4b closure, a second maintainer (or a contributions policy), an independent benchmark or review, any change to the rider.

## 4.10 Wardley placement

- **manim-compatible API surface:** Product — 3b1b/manim and Community Edition own it; franken_manim free-rides on it for adoption and pays the compatibility long-tail as rent [External, Medium].
- **Deterministic native math-animation engine:** Custom-built → early Product — works in lab (real scenes, prereleases), pre-1.0, validated by its own apparatus but not by third parties; moves to Product with a stable release + G4a/G4b closure + independent validation [Inference, Medium].
- **Analytic Bézier renderer (Lumen) + clean-room TeX-math (fmd-math):** Genesis → early Custom-built — no incumbent ships this combination (KaTeX/Typst own web math, Skia/resvg own rasterization, neither does both natively in one pipeline); fmd-math moves right as it completes its upstream landing in franken_markdown [Inference, Medium].
- **Certified bit-reproducibility machinery (input closure, PG-5 sweeps, self-goldens, owned codecs):** Custom-built — novel as a packaged discipline for a creative tool; moves toward Product the moment a second project adopts the closure model [Inference, Medium].
- **Studio (browser-based inspection/iteration):** Custom-built, pre-Product — browser-tested embedded UI and journal replay exist, but the shipped native worker rejects live input (`fm-ffj.72`, G3-blocking); moves right only with the input path connected [Verified in status doc, High].
- **Evidence apparatus (parity ledger, fail-closed refusal inventory, runtime truth gate, reality-check audits):** Custom-built — the most transferable component; moves right if a second reimplementation project adopts the ledger method (see next step 4) [Inference, Medium].

**The decoupling lens:** franken_manim represents *platform-from-bits* — the certified path promises identical output regardless of thread count, scheduler, or machine (within the certified matrix), decoupling the artifact from the execution environment — and advances *provenance-from-artifact*: the content-hashed input closure plus sidecar manifest binds every render to its complete inputs, the render-pipeline equivalent of a reproducible build. That second decoupling is the project's only credible claim to a future the incumbents aren't already occupying, and it is still aspirational (G4b open).

## 4.11 Trajectory (12 / 24 / 60 months) — [Inference]

- **12 months:** continued extreme-velocity single-maintainer/agent work; the 93-placeholder backlog shrinks in coherent families (the `fm-5wq` workstream pattern); native Studio input lands or G3 stays blocked; the thread/platform determinism matrix gets its first real measurements (or G4b stays open); pinned-host PG receipts either appear (and the performance story becomes quotable) or don't (and the targets keep their asterisk); plausibly a 1.0 candidate if the remaining work is integration/qualification rather than new invention — the ledger suggests the invention phase (renderer, TeX engine, codecs) is largely done. Stays in Explore.
- **24 months:** bifurcation. Upside assumes the single-maintainer velocity is sustained and the compatibility long-tail is finite (a contributions-policy reversal would be required for anything beyond that): **Upside:** G4a/G4b close, a stable release ships with indexed distribution, the fmd-math component gets adopted outside the suite, and the input-closure model becomes the reference implementation of verifiable generated media — Pilot for reproducible scientific publishing and agent-generated video. **Decay:** velocity slows with no successor (contributions are refused, so there is no on-ramp); the pinned nightly ages; the 325k-line tree becomes unmaintainable; drifts to Monitor as a research artifact whose methodology outlives its engine.
- **60 months:** binary. Either a niche-but-real artifact — the deterministic, dependency-free substrate embedded in agent video infrastructure and reproducible publishing — or superseded: KaTeX/Typst absorb the "no-LaTeX math" conversation, resvg/Skia absorb the quality conversation, and manim's own ecosystem adds deterministic export. The verification methodology is the more likely survivor either way.

**Revisit triggers (concrete, observable):** first stable (non-pre-release) GitHub release; G4a or G4b gate closure; a published pinned-host performance measurement; a cross-platform bit-identity measurement; a contributions policy (or a second maintainer); any independent benchmark, code review, or production deployment; any change to the license rider; fmd-math adoption outside the FrankenSuite.

## 4.12 Limitations and open questions (mandatory)

**Not done:** did not compile the workspace, run any test, execute a render, reproduce any measurement, or verify replication of the determinism smoke — all behavioral and performance claims rest on maintainer evidence plus revision-bound documentation. Shallow clone with a 2026-09-21-only commit window (no history before that; authorship archaeology beyond one day is from docs, not git). CI per-run pass/fail not fully legible from text scraping. Star/fork counts from the GitHub API (live read). manim's source not audited — characterizations of the original are the author's, cross-checked only against general background knowledge (Medium). Web search for independent coverage carries the usual recall caveats. The packet inherits the status docs' proof boundaries and states them. **Done in round 1 of grading:** PyPI absence verified live (JSON + simple endpoints 404, 2026-09-22); `/releases/latest` verified to resolve to the releases index (no stable release); FMTL confirmed as the FMTL/1 serialized-timeline bundle format (`docs/FMNT1_TIMELINE_BUNDLE.md`) — the acronym's expansion is not spelled out in the repo and is not expanded here; DSR's expansion is likewise undocumented in the repo (described from the release notes' own usage).

**Open questions that would most change the verdict:** actual self-golden/Look-Gallery pass rates at HEAD; CI greenness over time (1,500 runs — what fraction green?); whether the 93-placeholder count has moved since the 2026-09-09 audit; whether PG-1…PG-8 will ever get pinned-host measurements; whether the nested-macro span-provenance bug (UPSTREAM_LEDGER row 13, proposed 2026-09-21) blocks the TeX quality bar; funding and succession intentions of the maintainer (the contributions refusal makes this existential); whether the WASM/FMTL path matures into the agent-video thesis; whether any enterprise has evaluated the rider's legal exposure; what happens to the tree when the nightly pin ages out.

## The eight deepening questions (one paragraph each)

1. **Provenance.** franken_manim records more about *what produced* an artifact than any peer in this program: the certified input closure content-hashes sources, engine and suite commits, toolchain, config bytes, seeds, font hashes, backend identities, and locale into a manifest, with a sidecar provenance manifest traveling alongside the render — and the six-step frame order, RNG substream states, and segment-purity classifications are journaled for replay [Verified mechanism documented, High; end-to-end execution Maintainer claim, Medium]. Making that attestation portable requires what the closure already gestures at: hash-chained, signed manifests verifiable by a third party holding only the pinned toolchain — but the closure is currently a self-description, not a tamper-evident attestation (a hostile builder could rewrite both artifact and manifest), and cross-platform bit-identity is unmeasured, so portability is designed, not demonstrated [Inference, Medium].

2. **The embeddable unit.** The smallest useful adoptable piece is `fmd-math` (the TeX-math layout engine) plus `fmd-font`, already upstreamed into franken_markdown and consumed here as pinned git deps — a KaTeX/Typst-class math layouter with bundled Computer Modern, Appendix-G placement, and span provenance, adoptable without the animation engine at all [Verified, High]. The adoption cost is real but bounded: nightly-only toolchain (pinned `nightly-2026-08-31`), git-dependency consumption (no registry publication), and the rider, which follows every derivative work and withholds rights from the restricted parties — so embedding means vendoring a rider-encumbered, nightly-pinned upstream [Verified, High].

3. **Unexercised option value.** The architecture holds at least four unused capabilities: the WASM fixed-scene renderer + FMTL timeline player is a browser-native animation distribution format waiting for a publisher; the retained render IR with content-addressed shape instancing is a frame-deduplication and caching story the current outputs don't fully exploit; the engine-equivalence suite (certified vs fast-CPU vs annex engines under a visual budget) is a general multi-backend conformance method currently aimed only at itself; and the batch farm (`fmn batch` over asupersync) plus fmn-runtime's ExecutionPlan (topology-aware scheduler) are farm infrastructure with no farm and no published farm-scale measurement yet [Verified existence, High]. What unlocks them is, respectively, a published WASM/FMTL consumer, a cache-eviction and invalidation policy, a documented decoupling from Lumen's IR, and a second machine — all product decisions, none blocked on research [Inference, Medium].

4. **Benchmark honesty.** The numbers most likely to survive an independent rerun are the *adverse* ones — the status doc's open admissions (93 placeholders, host-unqualified observations, one-scene determinism evidence, G2–G5 open) — because they are the maintainer's own published limits with exact denominators, and nobody publishes limits they can't defend [Inference, Medium]. There are no headline performance wins to disavow, which is itself the honest position: every 96-core/60fps/≤0.5× figure is labeled a gate target, and the CHANGELOG's evidence boundaries explicitly list the unmeasured matrices. The load-bearing numbers for the thesis are the *conformance* ones (ledger rows, placeholder counts, acceptance-suite passes), and those are the ones with machine-readable receipts [Verified, High].

5. **The governance path.** The credible route from one maintainer to an institution runs through a stable release and a contributions policy: a 1.0 creates users, users file issues against real deployments, and a second maintainer emerges — but the README currently *refuses* outside contributions outright, so the on-ramp doesn't exist and must be built deliberately (the refusal is framed as velocity protection, which is honest about the tradeoff) [Inference, Medium]. What breaks first if velocity decays is the integration surface: at 54 commits/day the status audit already documents flagship gaps between working mechanisms and the operations that promise to use them (native Studio input, the placeholder tail), so a slowdown without a successor doesn't stabilize the project — it strands 325,255 lines on a pinned nightly with nobody who understands the whole pipeline, and bit-rot sets in within quarters [Inference, High].

6. **The license as strategy.** The rider excludes exactly OpenAI, L.L.C., Anthropic, PBC, their affiliates, and anyone acting for, benefiting from, or under the direction of them — and it defines "use" to include benchmarking, testing, analyzing, indexing, and training-data incorporation, with automatic termination and injunctive relief reserved to Jeffrey Emanuel [Verified verbatim, High]. As strategy it is coherent defensively (it prevents the two labs best positioned to absorb the work from doing so without permission) and self-sabotaging offensively: the project's most credible future is agent-generated video infrastructure, the excluded parties *are* the agent-infrastructure builders, and the rider's breadth (even *benchmarking* is forbidden) chills the independent validation the project most needs — no restricted party can legally evaluate it, which helps explain why independent validation is zero [Inference, Medium].

7. **Agent-era fit.** The concrete workload that would pick franken_manim over manim is an agent pipeline generating explainer video that must be *verifiable*: a scene produced by a model, rendered by one binary with no LaTeX, with the input-closure manifest published alongside so any third party can re-derive bit-identical frames — reproducible scientific publishing and auditable agent-generated media, neither of which manim's LaTeX-and-GPU pipeline can offer [Inference, Medium]. What would have to become true first: G4b closure (the certified matrix measured, not defined), a stable release an agent platform can pin, the WASM/FMTL player mature enough to carry closures into the browser, and — unavoidably — a license an agent-platform company can actually sign [Inference, Medium].

8. **The kill test.** The single event that would falsify the core thesis — "deterministic, dependency-free math animation is worth building" — is manim itself (or Community Edition) shipping deterministic export: a `--reproducible` mode with pinned fonts, a fixed math layouter, and containerized LaTeX would commoditize the determinism half of the thesis while keeping the ecosystem, leaving franken_manim competing purely on implementation elegance at bus factor 1 with no stable release [Inference, Medium]. The experimental falsifications are nearly as decisive: a pinned-host PG measurement showing the retained-IR architecture can't reach its own 60fps/≤0.5× targets, or a third-party rerun of the input-closure reproduction failing on uncontrolled inputs — either would collapse the pillar (measured speed, trustworthy bits) the 1.0 spec stands on [Inference, Medium].

---

**Working notes:** fresh shallow clone at `~/workspace/.scratch/frankenmanim-verify/` (HEAD `d3a8090e6950a440876f5eb389b6b9fbb5f910d4`, 2026-09-22 14:59 UTC). No durable user-facing files created besides this assessment and its versioned intermediates. Nothing in the clone was modified (repo AGENTS.md house rules: read-only analysis).