Hosts
A Fuaran interface does not belong to any one language. The tree an AI emits as
JSON, a Python service stores, a TypeScript client hydrates and a SwiftUI app
projects are the same bytes: the language is the wire format (core@1.0), and
every implementation on this page is a host of that contract. Adding a language
never forks the language; it adds another place the same interface can be
authored or rendered.
That claim only holds if conformance means something, so the roster is precise about what each surface promises. Three kinds of surface sit on the contract:
- Codec hosts independently encode and decode the canonical wire, and are held to byte-identity against the shared fixture corpus.
- Render projections consume a codec host's already-decoded tree for native rendering only; they never canonically encode, so their bar is render coverage over the node set, not byte-parity.
- Authoring veneers are ergonomic author surfaces over an existing host's core; they emit the same wire, so they inherit its conformance for free.
The roster
| Surface | Language | Package / repo | Kind | Conformance bar |
|---|---|---|---|---|
| F# | F# / .NET | Fuaran.UI.* (NuGet) | reference codec host | generates the corpus; byte-identity |
| TypeScript | TypeScript | @fuaran-ui/* (npm) | codec host | round-trip byte-identity vs the corpus |
| Python | Python | fuaran-py (PyPI) | codec host | round-trip byte-identity vs the corpus |
| Go | Go | github.com/fuaran-ui/fuaran-go | codec host (headless) | round-trip byte-identity vs the corpus |
| Rust | Rust | fuaran-ui (crates.io; repo fuaran-rs) | codec host (headless + WASM) | round-trip byte-identity vs the corpus |
| Swift | Swift | fuaran-swift (SwiftPM) | render projection over the Rust core | render-coverage over the node set |
| Kotlin | Kotlin / JVM | io.fuaran:fuaran-ui (Maven Central) | render projection over the Rust core | render-coverage over the node set |
| C# | C# / .NET | Fuaran.UI.CSharp (NuGet) | authoring veneer over the F# core | fluent factory → identical wire |
| VB | VB / .NET | Fuaran.UI.VisualBasic (NuGet) | authoring veneer over the F# core | XML literals + the C# fluent factory → identical wire |
The F# host is the reference: it generates the shared fixture corpus, and every other codec host is held byte-identical to it. The native Swift and Kotlin surfaces ride the certified Rust codec rather than re-implementing one, so a new node kind costs them a renderer arm, not a wire change.
Where each surface has reached
- F# – the full reference: codec, apply engine, validator, client and server-side rendering, and the server-driven driver.
- TypeScript – codec, apply, validator, renderer and hydration, tracked in lock-step with the corpus.
- Python – a co-equal authoring and rendering tier: codec, validator, server-side HTML rendering, and in-browser rendering via Pyodide.
- Go – the headless backend tier: codec, apply, validator, and complete server-side emission (static HTML, islands partial hydration, and a server-driven driver) as a library, not a runtime.
- Rust – dual-role: a headless/edge host and a browser client compiled to WebAssembly, plus a C-ABI core library that the native surfaces bind.
- Swift – a full native surface over the Rust core: render-projection decoder, SwiftUI renderer, and interaction driver.
- Kotlin – the same shape on the JVM/Android: render-projection decoder, Jetpack Compose renderer, and interaction driver, packaged for Android.
Compute resolves at render time in every one of these surfaces: a tree whose values are transforms over wire data renders to the same resolved output whether it is server-rendered by F#, Python or Go, hydrated by TypeScript, rendered by Rust in the browser, or projected into SwiftUI and Compose. The Rust core resolves bindings before handing the native surfaces their projection.
The shared contract
Every host speaks the same two versioned contracts: the core@1.0 wire-format
profile (the canonical tree/op JSON) and the v2 op-stream chain envelope.
Neither moves without every codec host and the fixture corpus moving together;
that parity gate is what makes "one tree, every host" a guarantee rather than an
aspiration. See the wire format for the byte-level
contract, and the guide for per-host authoring tracks.
This page is the map of which surfaces exist and what each one promises. Every surface has a get-started track, grouped as .NET (F# / C# / VB) · Web (TypeScript) · Python (Python) · Systems (Go / Rust) · Native UI (Swift / Kotlin).