A full-stack Model-View-Update (MVU) framework for .NET — build interactive web applications with pure functions, from server-rendered HTML to client-side WebAssembly.

Abies brings the Elm Architecture to .NET with a twist: one codebase, four render modes. Write your UI as pure functions and deploy it however you need — static HTML, interactive server, client-side WASM, or auto (server-first with WASM handoff).

• Pure functional architecture — no side effects in your domain logic
• Virtual DOM with efficient keyed diffing and binary batch patching
• Type-safe routing with C# pattern matching on URL segments
• Full-stack tracing with OpenTelemetry (browser → server)
• Built on Picea — the Mealy machine kernel that powers MVU, Event Sourcing, and Actor runtimes

Abies supports four render modes — the same spectrum as Blazor, but built on pure MVU:

All four modes share the same Program<TModel, TArgument> interface. Your MVU code doesn't change — only the hosting configuration does.

// Static — one-shot HTML, zero JavaScript
var html = Page.Render<MyApp, MyModel, Unit>(new RenderMode.Static());

// InteractiveServer — patches over WebSocket
var html = Page.Render<MyApp, MyModel, Unit>(new RenderMode.InteractiveServer());

// InteractiveWasm — client-side .NET runtime
var html = Page.Render<MyApp, MyModel, Unit>(new RenderMode.InteractiveWasm());

// InteractiveAuto — server-first, transitions to WASM
var html = Page.Render<MyApp, MyModel, Unit>(new RenderMode.InteractiveAuto());

# Install the Abies templates
dotnet new install Picea.Abies.Templates

# Create a browser (WASM) app
dotnet new abies-browser -n MyApp

cd MyApp
dotnet run

using Picea;
using Picea.Abies;
using Picea.Abies.Subscriptions;
using static Picea.Abies.Html.Elements;
using static Picea.Abies.Html.Attributes;
using static Picea.Abies.Html.Events;

await Picea.Abies.Browser.Runtime.Run<Counter, Model, Arguments>(new Arguments());

public record Arguments;
public record Model(int Count);

public record Increment : Message;
public record Decrement : Message;

public class Counter : Program<Model, Arguments>
{
    public static (Model, Command) Initialize(Arguments argument)
        => (new Model(0), Commands.None);

    public static (Model, Command) Transition(Model model, Message message)
        => message switch
        {
            Increment => (model with { Count = model.Count + 1 }, Commands.None),
            Decrement => (model with { Count = model.Count - 1 }, Commands.None),
            _ => (model, Commands.None)
        };

    public static Document View(Model model)
        => new("Counter",
            div([], [
                button([onclick(new Decrement())], [text("-")]),
                text(model.Count.ToString()),
                button([onclick(new Increment())], [text("+")])
            ]));

    public static Subscription Subscriptions(Model model) => SubscriptionModule.None;

    public static Result<Message[], Message> Decide(Model state, Message command)
        => Result<Message[], Message>.Ok([command]);

    public static bool IsTerminal(Model state) => false;
}

Abies is built on the Picea kernel — a Mealy machine abstraction that provides the core (State, Event) → (State, Effect) transition function. Abies specializes this for MVU:

Message
  → Transition(model, message) → (model', command)
    → Observer: View(model') → Document → Diff → Patches → Apply
    → Interpreter: command → Result<Message[], PipelineError>
        → Dispatch each feedback message (recurse)

The Apply delegate is the seam between pure Abies core and platform-specific rendering:

Subscriptions let you react to external event sources without putting side effects in Transition:

public record Tick : Message;
public record UrlChangedTo(Url Url) : Message;

public static Subscription Subscriptions(Model model) =>
    SubscriptionModule.Batch(
        SubscriptionModule.Every(TimeSpan.FromSeconds(1), () => new Tick()),
        Navigation.UrlChanges(url => new UrlChangedTo(url)));

Measured with js-framework-benchmark on the same machine, same session.

Latest same-session validation (2026-04-02, AC power, local main baseline):

• Full 9-benchmark duration suite rerun against Blazor WASM (same machine/session)
• Geometric mean (total medians): 0.62x for Abies vs 1.62x for Blazor
• Duration, startup/size, and memory tables below reflect the fresh 2026-04-03 run

Details: Render StringBuilder Pool Cap Validation (2026-04-02)

Note: These size rows come from js-framework-benchmark's 40_sizes artifact metric. They are not equivalent to full .NET publish output size reported in docs/benchmarks.md.

Note: Clear memory is higher in Abies due to lazy GC in the WASM runtime. All other metrics show Abies ahead.

📊 Interactive Benchmark Charts — Historical trends on GitHub Pages

See docs/benchmarks.md for details on running benchmarks locally.

The repository includes Conduit, a full implementation of the RealWorld specification — a Medium.com clone demonstrating:

• User authentication (login/register)
• Article CRUD with Markdown rendering
• Comments and favorites
• User profiles and following
• Tag filtering and pagination
• Both WASM and server-rendered hosting modes
• REST API with PostgreSQL read store
• E2E tests with Playwright
• .NET Aspire orchestration for local development

See Picea.Abies.Conduit/README.md for the Conduit-specific layout, local run commands, and test strategy.

# Run with .NET Aspire (recommended)
dotnet run --project Picea.Abies.Conduit.AppHost

# Or run individually
dotnet run --project Picea.Abies.Conduit.Api &
dotnet run --project Picea.Abies.Conduit.Wasm.Host

Abies provides full-stack OpenTelemetry tracing out of the box:

• Browser — DOM event spans, fetch request propagation (via abies.js)
• Server — Session lifecycle, page render, message dispatch spans
• Runtime — Message processing, command execution, model update spans
• OTLP export — Browser traces export to /otlp/v1/traces proxy endpoint

Configurable verbosity levels: off, user (default), debug.

<meta name="otel-verbosity" content="user">

See Tutorial 8: Tracing for a full walkthrough.

• .NET 10 SDK or later
• A modern browser with WebAssembly support (for WASM mode)

dotnet build
dotnet test

See the docs folder for comprehensive documentation:

• Installation
• Project Templates
• Your First App
• Project Structure

• MVU Architecture
• Render Modes — Static, Server, WASM, Auto
• Virtual DOM
• Commands & Effects
• Subscriptions
• Pure Functions

1. Counter App — Basic MVU
2. Todo List — Managing collections
3. API Integration — HTTP commands
4. Routing — Multi-page navigation
5. Forms — Input handling & validation
6. Subscriptions — Timers, resize, WebSocket
7. Real-World App — Conduit walkthrough
8. Tracing — OpenTelemetry integration

• Testing
• Debugging
• Performance
• Deployment
• Head Management
• Error Handling

We welcome contributions! Abies follows trunk-based development with protected main branch.

1. Fork and clone the repository
2. Create a feature branch from main
3. Make your changes with tests
4. Ensure CI passes: dotnet build, dotnet test, dotnet format --verify-no-changes
5. Submit a pull request following our PR template

For detailed guidelines, see CONTRIBUTING.md.

Abies is a Latin name meaning "fir tree" — a species in the genus Picea.

• A: as in "father" [a]
• bi: as in "machine" [bi]
• es: as in "they" but shorter [eːs]

Stress: First syllable (A-bi-es) · Phonetic: AH-bee-ehs

Apache 2.0 · Copyright Maurice Peters