BlazorDX.Interop 0.4.4

BlazorDX

🌐 Live demo & docs → blazordx.com

⚠️ Beta — not for production. BlazorDX was built with substantial AI assistance, is largely untested, and is published for evaluation and testing only. It is not designed for production workloads. See Status.

A secure-by-default, headless component system for .NET 10 Blazor. MIT-licensed. Zero runtime reflection. C# + Rust + TypeScript, each used where it is strongest.

BlazorDX starts from a question that has gotten less attention in the Blazor component space than productivity and feature count:

What would a Blazor component library look like if it were designed to be secure-by-default, AOT-safe, and styling-agnostic from the first line of code?

It is not a productivity skin over Bootstrap. It is a layered system that compiles down to the fastest primitives the browser offers and is designed, by policy, to avoid the patterns behind two well-known failure modes in reflection-heavy component architectures: breaking under trimming/AOT, and sharing UI state across users on the server.

What makes it different

See ARCHITECTURE.md for the full blueprint, COMPONENTS.md for the component catalog, docs/adr for the decisions behind it, and ROADMAP.md for what "complete" means and what is still ahead.

Live showcase: blazordx.com — every component, the docs, and the DataGrid at 100k rows.

Install

BlazorDX is published on nuget.org. Add the one package you need — it transitively pulls the primitives, Rust/WASM compute, JS interop, and the source generator:

dotnet add package BlazorDX.Components

Wire up the services (in both the WASM client and the server host Program.cs, so prerendering works):

builder.Services.AddBlazorDXCompute();               // grid compute (Rust in the browser) + DOM/JS interop
builder.Services.AddScoped<BlazorDX.Components.ToastService>();   // only if you use DxToast

Link the styles you use from the package's static web assets (start with the theme; add per feature — the full set lives under _content/BlazorDX.Components/):

<link rel="stylesheet" href="_content/BlazorDX.Components/dx-theme.css" />
<link rel="stylesheet" href="_content/BlazorDX.Components/dx-datagrid.css" />
<link rel="stylesheet" href="_content/BlazorDX.Components/dx-overlay.css" />

The Rust dx_grid.wasm and the JS bridges ship inside the package as static web assets and load automatically — no extra build tooling on the consumer side.

Packages: BlazorDX.Components (styled, start here) · BlazorDX.Primitives (headless + the source generator) · BlazorDX.Interop · BlazorDX.Compute · BlazorDX.Security · BlazorDX.Htmx (static-SSR forms tier).

Repository layout

src/        BlazorDX.* libraries (Primitives, Components, Interop, Compute, Security, SourceGen, Htmx)
analyzers/  BlazorDX.Analyzers — the build-time governance (DX1000 line cap + security bans)
build/      MSBuild targets that compile the Rust and TypeScript tiers
samples/    BlazorDX.Demo — a Blazor Web App with a live demo page per component
tests/      bUnit, compute, and analyzer test suites
docs/adr/   Architecture Decision Records

Prerequisites

The build degrades gracefully: if Rust or Node is missing it emits a clear warning and skips that tier, and the DataGrid still works because BlazorDX.Compute ships a managed C# fallback for every Rust routine.

Quick start

dotnet build BlazorDX.slnx          # builds C#, Rust (wasm), and TypeScript (esm)
dotnet test                         # bUnit + compute + analyzer suites (E2E skips if no server)
dotnet run --project samples/BlazorDX.Demo

To run the real-browser end-to-end suite (Playwright), start the demo, install a browser once, then point the tests at it:

dotnet run --project samples/BlazorDX.Demo/BlazorDX.Demo &     # serves http://localhost:5296
pwsh tests/BlazorDX.E2E.Tests/bin/Debug/net10.0/playwright.ps1 install chromium
BLAZORDX_BASEURL=http://localhost:5296 dotnet test tests/BlazorDX.E2E.Tests

The CI workflow (.github/workflows/ci.yml) defines the unit suites and the E2E suite across Chromium, Firefox, and WebKit (GitHub Actions format; adapt for your CI host).

Then open the printed URL. The DataGrid page shows 100,000 rows, virtualized to the viewport, sorted/filtered/aggregated by the Rust WASM module, with row selection, inline edit, column reorder/resize, and pinned columns. The nav links to every other component's demo — see COMPONENTS.md.

Status

Beta release. This project was created with substantial assistance from AI systems and has had only limited testing. Expect defects, gaps, and breaking changes. It is not intended for production use — treat it as a preview to evaluate and give feedback on.

BlazorDX spans 100+ components across overlays, inputs, navigation, the data-grid family (flat / tree / pivot, with server-side data and grouping), data visualization, scheduling (calendar / Gantt), editors (Markdown / WYSIWYG), files, forms (rendered from one model that doubles as an AI/MCP tool), an AI chat surface, and an Extended Document Handling track — Excel (.xlsx) and Word (.docx) viewers/editors with a live formula engine and hand-rolled OOXML, a native PDF viewer, and SSRS / Power BI reporting — every one built on the shared headless engine and verified in a real browser. See COMPONENTS.md for the full catalog.

• Tests: bUnit + compute + analyzer suites green, plus the Rust crate's own unit tests, plus a Playwright E2E suite that drives a real browser against the running demo (native drag-and-drop, canvas pixels, focus, console errors) — covering what bUnit cannot, and wired into CI across Chromium/Firefox/WebKit.
• Trimming/AOT: dotnet publish -c Release trims the entire WASM client with zero IL trim warnings (TrimmerSingleWarn=false surfaces every one) — concrete proof the zero-reflection claim survives the linker, not just an IsTrimmable assertion. AOT compilation is opt-in via -p:EnableAot=true (needs the wasm-tools workload) and the CI aot-publish job builds the full component set AOT and smoke-tests the published app with Playwright.
• Governance: the 1000-line cap and security bans hold across every file.

License & support

BlazorDX is free and open source under the MIT license — the full component library, source generators, Rust compute, and tooling. No license keys, no paid tiers gating the code, no runtime license checks. Use it in commercial products without restriction.

Sustaining the project and serving teams that need more than community help is funded through optional support, not by locking the code — see SUPPORT.md for community help, sponsorship, and commercial support / SLA / consulting options. Security reports: SECURITY.md.

Trademarks

BlazorDX is an independent project and is not affiliated with, endorsed by, or sponsored by Microsoft, Progress/Telerik, DevExpress, Syncfusion, MudBlazor, Blazorise, or any other company. All product names, logos, and trademarks are the property of their respective owners; any reference to them is for identification and comparison only.