1. Documentation index
  2. NUIF authored-interface interchange research manuscript
  3. Project
  4. NUIF — Neutral User Interface Format
  5. Research and implementation roadmap
  6. Developer beta scope and acceptance
  7. Standards-development roadmap
  8. Contributing
  9. Governance
  10. Security policy
  11. Code of conduct
  12. Documentation publication
  13. Architecture and whitepaper
  14. Host integration and vendor adoption
  15. SDK and language-binding boundary
  16. Diagnostic code registry
  17. Versioning and release operation
  18. NUIF foundation
  19. NUIF architecture thesis
  20. Layout and rendering research synthesis
  21. Protocol, portability and synchronization
  22. Serialization, collaboration and governance
  23. Prior-art comparison
  24. Implementation language and runtime choice
  25. Research limitations and implementation risks
  26. Governance and standardization strategy
  27. Naming and project identity
  28. Research coverage and evidence status
  29. Cross-industry patterns: evidence, adoption and rejection
  30. Resources, capture and model-neutral reconstruction
  31. Draft specification
  32. NUIF specification
  33. Conformance and fidelity
  34. Logical model
  35. 02 — Identity and properties
  36. 03 — Components and composition
  37. 04 — Layout
  38. 05 — Geometry, paint and text
  39. 06 — Operations, patches and merge
  40. 07 — Extensions and dialects
  41. 08 — Serialization and package format
  42. 09 — Provenance, correspondence and fidelity
  43. 10 — Collaboration profile
  44. 11 — Security and resource limits
  45. 12 — CLI, API and automation surface
  46. 13 — Semantics, accessibility and behavior
  47. 14 — Observation, capture and reconstruction
  48. RFCs and ADRs
  49. RFC process
  50. RFC 0001 — Multi-level document model
  51. RFC 0002 — Opaque extension preservation
  52. RFC 0003 — Authored state, resolved state and provenance
  53. RFC 0004 — Headless QA contract
  54. RFC 0005 — Deterministic numeric and string canonicalization
  55. RFC 0006 — Sibling order: canonical arrays and anchored operations
  56. RFC 0007 — Unknown entity kinds and opaque payloads
  57. RFC 0008 — Preserve numeric kinds and distinguish text/CBOR key order
  58. RFC 0009 — Bound profile-0 ingestion and semantic resources
  59. RFC 0010 — Portable resource and package profile
  60. RFC 0011 — Observation, reconstruction and inference provenance
  61. RFC 0012 — Behavior as a content-addressed package resource
  62. RFC 0013 — Variable TrueType resource profile
  63. ADR 0001: Rust for the reference core
  64. ADR 0002 — Use Taffy as initial CSS-family layout evaluator
  65. ADR 0003 — Renderer abstraction with Vello/wgpu experiment
  66. ADR 0004 — Encoding strategy
  67. ADR 0005 — Keep CRDT state out of canonical documents
  68. ADR 0006: Rust-native reference editor on Masonry, Vello and AccessKit; toolchain policy
  69. ADR 0007: Tag-driven native editor prereleases
  70. ADR 0008: Vendor products integrate through host adapters
  71. ADR 0009: Source-built developer installation
  72. ADR 0010: Bounded retentive Svelte source adapter
  73. ADR 0011: One byte-oriented SDK precedes foreign ABI stabilization
  74. ADR 0012: Prioritize Affinity interchange and Canva host adoption
  75. Conformance
  76. Conformance
  77. v0 hard experiment — responsive card
  78. Font oracle captures
  79. Penpot foreign fixture
  80. Profile-0 render fixtures
  81. Profile-0 text shaping fixtures
  82. Benchmark suite
  83. Test-harness architecture
  84. NUIF conformance kit
  85. Profile-zero performance methodology
  86. Conformance plan
  87. Noto Sans variable conformance subset
  88. Recursive variable conformance subset
  89. Roboto Flex MVAR conformance subset
  90. Reference editor
  91. Reference editor research preview
  92. Reference editor architecture
  93. Developer installation
  94. Native editor packaging
  95. AI/headless QA contract
  96. Reference test editor: user-interface specification
  97. Adapters
  98. Adapter inventory
  99. Adapters
  100. NUIF Canva review app
  101. NUIF Figma review shell
  102. Adapter implementation status
  103. Draft Affinity SVG bridge profile 0
  104. Draft Canva Design Editing profile 0
  105. Retentive DTCG flat scalar-token profile zero
  106. Draft Figma Plugin API profile 0
  107. Figma plug-in snapshot profile 0
  108. Web accessibility projection profile 0
  109. Web behavior projection profile 0
  110. Retentive HTML/CSS profile 0
  111. Retentive HTML/CSS v0 model profile
  112. Retentive Penpot v3 package profile zero
  113. nuif-react-jsx-0 profile
  114. nuif-svelte-static-0 profile
  115. Retentive SVG basic-shape profile zero
  116. Research register
  117. Research record index
  118. Research corpus
  119. Research audit and corrected base plan
  120. Continuous research roadmap
  121. Portable accessibility semantics, HTML lowering and foreign browser oracles
  122. AccessKit as a cross-platform accessibility tree and semantic UI test surface
  123. Adobe UXP host integration, permissions, mutation boundaries, and distribution
  124. Forward affine image-paint coordinates and inverse sampling
  125. Affinity interchange surface and NUIF adoption path
  126. Alembic as a baked, time-sampled, non-procedural interchange cache
  127. Tree differencing with moves (Chawathe et al. 1996, GumTree 2014) and structural merge/diff tools (Mergiraf, difftastic)
  128. Automerge and Yjs CRDT architectures
  129. Content-addressed behavior attachment without canonical-schema coupling
  130. Bounded portable behavior through deterministic state-machine traces
  131. Bidirectional evaluation with direct manipulation (evaluation update for a general-purpose functional language)
  132. Blender DNA/SDNA self-describing files, RNA/operators, memfile undo and headless regression testing
  133. Canonical serialization rules - JCS (RFC 8785), CBOR deterministic encoding (RFC 8949 s4.2, CDE, dCBOR) and lessons from XML C14N
  134. Canva Apps SDK and Connect API adoption surface
  135. Cargo workspace layout, xtask automation, dependency/API linting, reproducible builds and test determinism for engine + apps + tests + fuzz
  136. Cassius, VizAssert and Troika - SMT formalisation of CSS layout and machine-checkable visual assertions
  137. Cassowary incremental linear constraint solving for user interfaces
  138. CBOR integer/float identity and deterministic encoded-key ordering
  139. Chromium DevTools Protocol as a source-backed UI observation surface
  140. Undo models - Command and Memento patterns, event sourcing, and undo in Blender, Photoshop and Figma
  141. Community Specification license and repository governance
  142. Confidence calibration, risk coverage and explicit abstention
  143. Content-addressed Merkle DAGs for immutable resources and snapshots
  144. A highly-available move operation for replicated trees (Kleppmann, Mulligan, Gomes, Beresford)
  145. CSS Flexbox §9, Grid §12 and Box Sizing 3/4 - algorithm structure, phases and known implementation divergences
  146. CSS formatting tree, Flexbox and Grid algorithms
  147. Delta debugging and test-case reduction (ddmin, HDD, C-Reduce, Hypothesis choice-sequence shrinking, proptest shrinking)
  148. Direct dependency and implementation-subsystem alternatives audit
  149. Shared and vendor-specific layout conventions across design editors
  150. Design2Code real-world screenshot-to-code benchmark
  151. Deterministic CBOR profiles (CDE, draft-ietf-cbor-serialization, dCBOR) and numeric canonicalization for a binary and a text profile with one hash
  152. Deterministic simulation testing (FoundationDB, TigerBeetle VOPR, Antithesis)
  153. Profile-specific developer beta evidence and source workflow evaluation
  154. Source-built developer installation and operating-system trust boundaries
  155. Differential testing (McKeeman, Csmith) and browser-referenced layout oracles (Taffy and Yoga gentest, R2Z2, X-PERT, WPT)
  156. Design Tokens Format Module 2025.10
  157. Editor fork exit conditions and supported accessibility lookup
  158. egui, eframe, egui-wgpu and the egui_kittest headless harness
  159. Deterministic CBOR, Protobuf unknown fields and Kiwi schema evolution
  160. EPUB 3.3 OCF package and resource-manifest discipline
  161. Figma engineering on multiplayer synchronization, fractional indexing and the custom renderer
  162. Figma Plugin API and REST API as evidence for a programmable, testable editor surface
  163. Figma Design tools, keyboard shortcuts and canvas interactions relevant to a test editor
  164. Figma UI3 design editor layout, panels and Design-tab sections
  165. Figma public plugin/document node model
  166. FLIP perceptual difference evaluator for rendered images (LDR-FLIP, HDR-FLIP, NVIDIA reference implementation)
  167. Flutter box-constraint layout model
  168. Requested font identity, replacement resources and item-level fallback fidelity
  169. Fontations read-fonts and Skrifa OpenType stack
  170. Coverage-guided fuzzing of structured inputs (libFuzzer, AFL++, cargo-fuzz, arbitrary, grammar fuzzing, parser resource limits)
  171. GitBook bidirectional Git synchronization and content structure
  172. GitHub Pages publication through Actions artifacts
  173. GitHub prerelease delivery, artifact provenance, and desktop signing boundaries
  174. GitHub Wiki repository and indexing boundaries
  175. KHR_interactivity portable behavior graphs
  176. Khronos glTF Validator report format, sample-asset corpus and extension prefix registry as a conformance kit
  177. glTF core and extension registry model
  178. Godot text scene format, resource identity and missing-type preservation
  179. Golden-master (characterization) and snapshot testing with insta, Jest and deterministic rendering baselines
  180. Sources of nondeterminism in GPU rendering and determinism tiers for conformance
  181. HarfBuzz shaping and Unicode text algorithms
  182. Houdini procedural networks, cooking, dirty propagation and digital assets
  183. Hydra scene index, render delegate abstraction, dirty tracking and image-diff testing
  184. Rust GUI toolkits compared for a headless-testable native editor (iced, Slint, GPUI, Makepad, Floem, Dioxus Native, egui, Masonry)
  185. Industry Foundation Classes interoperability standard
  186. InferUI robust relational layout synthesis (OOPSLA 2018), with Scout (CHI 2020) and Rewire (CHI 2018)
  187. IPLD DAG-CBOR strictness rules and content identifiers as a hash-bearing CBOR profile
  188. Jetpack Compose constraint and single-pass layout model
  189. JSON Patch (RFC 6902), JSON Pointer (RFC 6901) and JSON Merge Patch (RFC 7396) versus identity-addressed operations
  190. Lens laws from Foster et al. (TOPLAS 2007) and Boomerang (POPL 2008) to symmetric, edit and delta lenses
  191. libtest-mimic, datatest-stable, trybuild, expect-test and directory-driven fixture conventions (resvg, Taffy, rust-analyzer, Slint)
  192. Sibling order representation for authored documents; fractional indexing, list CRDT positions and anchor-based operations compared
  193. Bounded live Chromium capture transport and executable baseline
  194. LoRA low-rank parameter adaptation
  195. Lottie and Rive portable animation/runtime models
  196. LPIPS learned perceptual image similarity
  197. macOS Metal dependency and Rust uninhabited-static future incompatibility
  198. Editor stack decision: Masonry on imaging with Vello and AccessKit, re-verified against the 0.4.0 release and the main branch
  199. Masonry, Xilem and the masonry_testing TestHarness
  200. MaterialX shader generation and render test suite across backends
  201. MaterialX open graph standard for cross-renderer content
  202. Stateless MCP agent adapter over the authoritative NUIF core
  203. mdBook static documentation and generated navigation
  204. Metamorphic testing and metamorphic relations for graphics, layout and round-trip oracles
  205. MLIR multi-level intermediate representation and dialect conversion
  206. Model-agnostic screenshot reconstruction, evaluation and adaptation plan
  207. Datasheets and model cards for reconstruction artifacts
  208. NUIF naming collision reconnaissance
  209. OCI content descriptors and verification-before-consumption
  210. OCR detection and recognition as separate reconstruction observations
  211. OmniParser screen-region detection and icon captioning
  212. W3C Open UI Community Group component anatomy research
  213. OpenFig reverse engineering of the Figma .fig Kiwi format
  214. OpenPencil programmable editor, scene graph, Figma codec and DOM/CSS conversion
  215. OpenTimelineIO adapters, per-schema versioning with upgrade/downgrade functions and UnknownSchema preservation
  216. OpenType embedding permissions and reproducible font resources
  217. OpenUSD composition strength ordering, crate binary format, flattening and validation
  218. OpenUSD composition, layers, references and variants
  219. Operational transformation (dOPT, GOT, Jupiter, Wave) versus CRDTs (Shapiro et al. 2011) - convergence conditions and hosting either above a canonical document
  220. Patch theory in Darcs and Pijul, and the categorical theory of patches
  221. Penpot workspace UI, plugin API and RPC automation surface
  222. Penpot v3 package model and official builder
  223. Pix2Struct screenshot parsing as visual-language pretraining
  224. PNG third-edition preservation and deterministic decode inputs
  225. Property-based and model-based testing of stateful systems (QuickCheck, eqc_statem, quickcheck-state-machine, proptest-state-machine)
  226. Content-addressed provider manifests and external AI bills of materials
  227. QLoRA memory-efficient quantized fine-tuning
  228. React JSX and DOM element source surface
  229. Group-isolated reconstruction corpora and auditable benchmark snapshots
  230. Skia, WebRender, Servo pipeline and wgpu rendering architectures
  231. Bounded JSON, CBOR and stream ingestion for untrusted NUIF inputs
  232. Resource-aware NUIF packaging and source-backed capture synthesis
  233. resvg regression suite, resvg-test-suite reference corpus, usvg lowering and the SVG support table
  234. Retentive Lenses
  235. Reverse engineering flexible GUI layouts from observations
  236. Rust SDK facade and staged C, Swift and Kotlin binding boundary
  237. Rust snapshot, property-based, fuzzing, mutation, runner, benchmark and coverage tooling for round-trip trials
  238. Rust toolchain pin and minimum supported Rust version policy for the NUIF workspace
  239. Coordinated SHA-2 and WebSocket dependency migration
  240. Admission criteria for Protobuf, FlatBuffers and Cap'n Proto as NUIF codecs
  241. Scholarly citation, archival DOI, preprint and software-paper workflow
  242. ScreenAI element typing, localization and screen annotation
  243. Sequence-level knowledge distillation
  244. Bounded typed YAML parsing with serde-saphyr
  245. Sketch-n-Sketch (PLDI 2016, UIST 2016, UIST 2019) - trace-based program updates and output-directed programming for SVG
  246. Skia GM tests, DM, Skia Gold triage and fuzzy matching; browser reftests (WPT, Chromium, Firefox)
  247. SSIM, MS-SSIM, PSNR and exact-pixel comparison policies for rendering tests
  248. Standards-development venue requirements for an interface interchange specification
  249. ISO 10303 STEP product-data exchange architecture
  250. Structured differencing and three-way merge
  251. Svelte component AST, retentive syntax and compiler-oracle boundary
  252. SVG 2 vector graphics model
  253. SwiftUI proposal-response layout model
  254. Symmetric Lenses
  255. Browser-derived layout fixtures in Taffy and Yoga (Chrome as reference oracle)
  256. Taffy Rust CSS layout engine
  257. Text rendering reproducibility (shaping determinism, HarfBuzz test format, FreeType hinting and anti-aliasing modes, browser differences, pinning strategy)
  258. Tree-sitter incremental concrete syntax trees
  259. ttf-parser retirement after RUSTSEC-2026-0192
  260. Screenshot-to-code and interaction-inference limits
  261. W3C UI Specification Schema Community Group
  262. Unity prefab overrides, YAML identity and UnityYAMLMerge
  263. Preservation of unknown entity kinds and extension payloads; OTIO UnknownSchema, Godot MissingNode, USD typeName, glTF extensions, Protocol Buffers unknown fields and CBOR tag 24 compared
  264. Unreal Engine asset versioning, transactions, automation framework and asset diffing
  265. Vello test infrastructure (vello_tests, vello_sparse_tests) and the vello_cpu renderer as a deterministic reference path
  266. Vello Rust 2D renderer
  267. VisRefiner difference-aligned supervision and render-feedback refinement
  268. W3C Community Group incubation and Recommendation-track requirements
  269. WebAssembly Component Model and WIT
  270. Headless execution of the Rust engine in browsers, Node and WASI runtimes for differential tests
  271. Finite browser lowering for portable behavior effects
  272. WebGPU security and robustness model
  273. WebRender wrench reftest harness, reftest.list syntax and RON scene capture/replay
  274. WebSight synthetic screenshot and HTML pairs
  275. Yoga embeddable Flexbox layout engine
  276. Release records
  277. NUIF Editor 0.1.0-alpha.1
  278. NUIF Editor 0.1.0-alpha.2
  279. NUIF Editor 0.1.0-alpha.3
  280. Implementation reference
  281. Schemas and IDLs
  282. NUIF command-line tool
  283. NUIF MCP adapter
  284. NUIF WebAssembly binding
  285. nuif-canva
  286. NUIF fuzz harness
  287. Independent Python profile 0
  288. Refpath research ingestion contract
  289. NUIF bounded PNG decoder profiles
  290. Static OpenType resource profile 0
  291. Variable TrueType metadata research profile
  292. NUIF collaboration profiles
  293. NUIF behavior state-machine profile 0
  294. Native binding contracts