Document Engineering · AI-Ready Platform

One platform. Three deployment tiers. Edge AI when it matters.

Web sites, desktop apps, and high-security native applications — authored once as Xlli documents, rendered to every surface from a single codebase. Rust WASM shipping today. Python library support across every compiled language. Secure Excel in Rust WASM.

Local when possible. Private when required. Frontier when valuable.

Three tiers. One platform. Managed together.

Kestrel serves public web sites and web apps. WebView2 powers internal Chromium desktop applications. Rust delivers high-security native apps with private local AI. The same Xlli document model and the same WASM modules run on every tier — no per-tier rewrites.

Kestrel Web	WebView2 Desktop	Rust Secure
Web sites · web apps · REST APIs	Internal Chromium desktop apps	High-security native · Edge AI
ASP.NET Kestrel serves public sites and web applications. Let’s Encrypt HTTPS, REST APIs, Swagger, health checks. Rust WASM client-side compute shipping now. Locked-down numerical JS/TS. Python library support across every compiled language.	Windows + WebView2 (Chromium). Multi-panel navigator layouts, Monaco editor, in-process C# with zero HTTP overhead. SkiaSharp + Direct2D rendering. Rust WASM inside the WebView. Python library support. High-speed in-process & in-memory messaging between WPF and the WebView.	Zero-Chromium Rust native applications. Private local AI (Gemma 4, edge models). Air-gapped operation, no network stack required. wgpu GPU rendering. Rust WASM for sandboxed plugins. No data leaves the machine.

Model escalation with privacy gates.

Xll.Ai doesn’t send everything to the largest model. It evaluates where work should happen and escalates only when necessary. Privacy gates apply across every tier — they’re a cross-cutting capability, not a separate platform.

Run locally first

Desktop models and Rust/WASM modules handle sensitive preprocessing — classification, redaction, summarisation, routing.

Escalate privately

Route heavier workloads to private NVIDIA infrastructure when local models aren’t enough. Sovereign, controlled, no third-party exposure.

Use frontier selectively

Send only approved, transformed, or policy-cleared payloads to cloud AI when frontier reasoning is genuinely required.

Keep control

Enforce routing, redaction, policy and audit at every gate. Decisions about what leaves the local environment are explicit, never implicit.

One document format. Every screen type.

Xlli is the universal document format that drives every surface — HTML web pages, interactive spreadsheets, AI chat and secure messaging, real-time numerical trading screens, desktop workflows. Same JSON, every runtime. The page you’re reading is an Xlli document rendered to HTML.

News & Releases

News

AI news from the wider ecosystem on the left, Xll.Ai release news on the right. Two streams, one page.

AI News

11 May 2026 · devclass.com

Anthropic’s Bun team trials port from Zig to Rust

Read on devclass.com →

May 2026 · techbooky.com

Anthropic Strikes Surprise Compute Deal With Elon Musk’s xAI and SpaceX

Read on techbooky.com →

Xll.Ai News

12 May 2026

Xll.Ai CPS Cargo Project Solution 6.5.1 Beta Released

Internal release

25 Apr 2026

Xll.Ai CPS Cargo Project Solution 6.4.7 Alpha Released

Internal release

Xll.Ai’s First App

CPS Build — Cargo · Project · Solution.

A product, not a convention. The desktop app that makes multi-language monorepos behave — one source of truth for every project’s identity, dependencies, and rendering posture, validated and enforced by tooling that humans, CI pipelines, and AI assistants all read from.

What CPS is.

CPS — Cargo · Project · Solution — is the metadata convention every project in the Xll.Ai monorepo declares. A single cps.ai.toml file at each project root describes who owns the project, what it depends on, how it’s distributed, and how it renders. Tools, CI, and AI sessions all read the same file. Conventions stop being lore.

What CPS Build does.

Validate

Schema and conventions

Validates every cps.ai.toml against the schema. Catches drift before it reaches CI. Surfaces violations as actionable cards.

Orchestrate

Multi-language builds

One pass over C#, Rust, and Python. Dependencies declared in CPS match what the build actually consumes — no more silent skew.

Package

NuGet and Rust artefacts

Produces signed NuGet packages and Rust crate artefacts ready for distribution to internal feeds or external registries.

Surface

Project state at a glance

Every project as a card on a dashboard: ownership, distribution mode, security posture, build state, validation status.

Why it matters.

Multi-language monorepos drift. C# build files don’t agree with the Rust workspace, the Python wheels reference a different commit, the docs describe last quarter’s structure. CPS is the answer: declared, validated, AI-readable, reproducible. It’s the foundation under every other Xll.Ai product — the reason any of the rest of this platform holds together at scale.

See it in action.

The dual-WebView2 web-site testing tool inside CPS Manager — a Cargo · Project · Solution MECP automated testing pack for web sites. Frontier and local-AI capable. Same diagnostic shape probes the xll.ai site's own theme axes; the pattern repeats for any web target.

CPS · MECP · Automated web-site testing · Dual WebView2 chrome

Screenshots.

TODO: Replace placeholders with real captures. CPS Manager dashboard, project detail view, validation report.

Try it.

CPS Build is currently in private beta. Free for evaluation. Commercial licence on request — tiered by team size and distribution scope.

TODO: Finalise licence model and pricing copy · wire download link to dl.xll.ai/cps-build · add contact form.

Request access

Two Formats · One Effect

XLLI × WASM — Author once. Render anywhere. Compute anywhere.

XLLI is the universal document format. WASM is the universal execution format. Together they’re how Xll.Ai ships across web, desktop, and native — from a single codebase, without per-tier rewrites.

The matrix.

Every Xll.Ai product crosses three deployment tiers. The same XlliDocument JSON, and byte-identical WASM modules, run on every one. This is what makes one-codebase delivery actually true rather than marketing-true.

Tier	Web	Desktop	Native
Runtime	ASP.NET Kestrel	Windows + WebView2	Rust + wgpu
XLLI role	Server-rendered or client-loaded XlliDocument. Same JSON the desktop and native tiers consume.	Same XlliDocument, rendered in-process via the C# reference renderer. Zero HTTP overhead.	Same XlliDocument, rendered to native UI via the Rust reference renderer. Two engines, byte-identical output.
WASM role	Client-side compute in the JavaScript sandbox. Rust WASM shipping today — #1 choice on the web.	Rust WASM inside the .NET sandbox (`wasmtime-dotnet`) or the JavaScript sandbox inside WebView2. Same byte-identical module either way.	Sandboxed plugins, licence checks, anomaly detection — same modules the Web and Desktop tiers use.

The narrative.

Author once

XlliDocument JSON is the single source of truth. Pages, calculators, reports, dashboards — one schema, one authoring surface.

Render anywhere

Three reference renderers (C#, Rust, JS) consume the same JSON. The output is structurally identical — not pixel-identical, structurally identical — across web, desktop, and native.

Compute anywhere

Rust WASM modules are byte-identical across tiers — the Black-76 module that prices an option on the web is the same module that prices it on the desktop and in the native app. Rust is the #1 choice on both web and server. Other production WASM languages today: C, C++, Go, C# — and as of December 2025, the computer-science theorists’ favourite, Haskell via GHC (the Glasgow Haskell Compiler).

Privacy preserved

Local stays local. Escalation to private GPU or frontier cloud is explicit and gated. The same Xlli document drives the same workflow whether the AI runs on-device or off.

The reference.

XLLI is published as an open standard at xlli.org, with two reference implementations kept in lockstep via WIT (WASM Interface Type): a C# implementation (Xll.Ai.Xlli.Canonical) and a Rust implementation (xlli-canonical). JavaScript bindings via wasm-bindgen; Python bindings via PyO3. Conformance is enforced by a fuzz harness, not by hand.

Open standard at xlli.org

Reference

Glossary

A short vocabulary for the platform. Bookmarkable terms; cross-references back to the sections where each is shown in context.

TODO: Steve to cut any term too internal for public consumption · reorder by importance vs alphabetical · add cross-references inline.

CPS: Cargo · Project · Solution. The metadata convention every Xll.Ai project declares in a cps.ai.toml file at its root. Identity, dependencies, distribution, rendering posture — all in one place, read by humans, CI, and AI alike.
CPS Build: Xll.Ai’s first shipped product. The desktop application that reads, validates, and acts on CPS metadata across the monorepo. Orchestrates multi-language builds, produces packaging artefacts, surfaces project state.
cps.ai.toml: The single TOML file every project carries at its root. Schema-validated. Inheritable defaults from the repo-level monorepo.ai.toml. The contract between projects and the tooling that operates on them.
Document engineering: The discipline of authoring information once in a canonical format — tables, math, code, narrative — and rendering deterministically to every surface that needs it. xlli.org is the open standard; Xll.Ai is the applied platform.
Edge AI: AI models running on the user’s own device. Lowest latency, highest privacy, no network required. Gemma 4-class and smaller models on the Native tier.
Export Controller: The .NET abstraction at the core of Xll.Ai’s cross-tier delivery model. One controller surface, multiple hosts — the same controller serves Kestrel web requests, WebView2 desktop in-process calls, and Rust native shells without rewriting. Foundation under MECP and under every product that ships across deployment tiers.
Frontier Cloud AI: Models hosted by third-party cloud providers — GPT-class, Claude-class. Used selectively when frontier reasoning is genuinely needed and the payload has been approved by the privacy gates.
Kestrel: The cross-platform ASP.NET web server underlying the Web tier. Industry standard — the same server Microsoft Azure and Amazon AWS use to serve ASP.NET on Windows Server. Serves Xll.Ai public sites and web applications, with industry-standard encryption.
MCP: Model Context Protocol. The open protocol from Anthropic that lets AI assistants connect to external data sources and tools through a standard interface. Xll.Ai uses MCP for AI-agent integration across the CPS toolchain — every CPS-managed project can expose its services to a connected assistant over MCP stdio. Distinct from MECP.
MECP: Managed Export Controller Pack. Xll.Ai’s pattern for packaging an Export Controller so the same controller can be hosted equally by a Kestrel web server, a WebView2 desktop application, or a Rust native shell — one packaging contract, three hosts. Distinct from MCP.
MicroTable: Xlli’s open-spec table primitive, published as part of the XLLI standard at xlli.org. A simpler XLSX-compatible format that round-trips with Excel for common cases — anchors the v0.1 release of the open spec.
Private GPU AI: Open-source models running on private NVIDIA infrastructure — client-owned or Xll.Ai-managed. Sovereign, controlled, no third-party data exposure. The middle tier of the privacy-gates escalation.
Privacy Gates: The decision points where Xll.Ai chooses whether to keep work local, escalate to private GPU, or send approved payloads to frontier cloud. Each gate is explicit, auditable, and enforced by code rather than convention.
Rust WASM: Rust code compiled to WebAssembly. The same byte-identical module runs in browser (Web tier), inside WebView2 (Desktop tier), and as a sandboxed plugin (Native tier).
Three deployment tiers: Web (Kestrel) · Desktop (WebView2) · Native (Rust). The three runtime targets every Xll.Ai product can ship to. Not three platforms — three deployment shapes of one platform.
WASM: WebAssembly. The universal execution format that lets compiled code from many languages run in the same sandbox — browser, server, desktop. Production WASM languages today: Rust (the #1 choice on both web and server), C, C++, Go, C# — and as of December 2025, Haskell via GHC (the Glasgow Haskell Compiler). Xll.Ai uses Rust WASM as its primary compute target across all three deployment tiers.
WebView2: The Microsoft-supplied Chromium-based control underlying the Desktop tier. Hosts the same XlliDocument render that runs on the Web, with in-process C# behind it instead of HTTP.
XLLI: The universal document format that drives every Xll.Ai surface. Open standard at xlli.org. Two reference engines (C#, Rust) kept in lockstep via WIT. Bindings to JavaScript and Python.
XlliDocument: A specific Xlli document instance. JSON-serialisable. Round-trip safe. The page you’re reading is rendered from an XlliDocument source.
XlliFrame: The chrome wrapper around an XlliDocument when it needs site-level navigation — section tabs, theme switcher, multi-page structure. What you see at the top of this page is an XlliFrame.
XlliWork: The dispatch model that drives XlliFrame navigation. A coordinate-based dictionary keyed on the active axes (here: section and theme) maps to one of six well-known dispatch kinds: inline, scroll, cache, wasm, fetch, navigate. This site uses scroll between sections.

No entries in this category yet.