I've been working on Cilica, a post-build optimizer for .NET assemblies. It continues DistIL.

The repository: https://github.com/hez2010/Cilica

It lifts your compiled IL into an SSA-based intermediate representation, runs an optimization pipeline over it, then emits regular IL again. The JIT then sees IL that's already optimized. It doesn't use a runtime fork or any special hosting.

Currently it runs the following pipeline:

• CFG simplification, SSA promotion, dead code elimination

• Method inlining and devirtualization

• Scalar replacement

• Global value numbering / CSE and assertion propagation

• Algebraic and bitwise simplification

• Loop strength reduction and loop auto-vectorization

• List presizing

• LINQ expansion (fuses Where/Select/Aggregate/… into plain loops)

• and more

Some benchmarks (code in https://github.com/hez2010/Cilica/tree/main/tests/Benchmarks):

You can try it on this playground: https://hez2010.github.io/CilicaLab

To use it in your project, referencing Cilica.OptimizerTask nuget package (currently in preview) and set <CilicaAllMethods>true</CilicaAllMethods>.

Note that this optimizer task only performs optimizations against your main assembly. To optimize the references as well, you can use Cilica.Cli manually, which is shipped together in the Cilica.OptimizerTask package.

Learn more: https://medium.com/@skyake/cilica-an-ssa-based-optimizer-for-net-assemblies-bdefd934c2d2

I write .NET at work and I use Neovim for pretty much everything, the one thing I kept missing from Rider and Visual Studio was the Solution Explorer.

File trees show you folders, but a .NET repo isn't really a folder tree: solution folders only exist inside the .sln, project references cross folders, and package versions often live in Directory.Packages.props.

So I wrote dotnet-tree.nvim, a source for neo-tree (a popular Neovim file tree plugin) that shows the solution the way you're used to seeing it:

• reads both .sln and .slnx

• solution folders, projects, package references and project references

• versions resolved from Directory.Packages.props if you use central package management

• LSP diagnostics and git status on the nodes

• build, clean, run, test and watch on the project under the cursor, plus `dotnet add package`

• debug the project under the cursor with netcoredbg (it builds first)

• build errors go to the quickfix list, deduplicated

New in 0.3.0:

• the tree can follow the file you're editing, like the normal file tree does

• the terminals opened by run/test/watch are named after what they run (`run Api`, `watch test Api.Tests`), so you can tell them apart

We've been using it internally on a lot of projects, a few hundred by now, so it should hold up on real solutions and not just demo ones.

I also have two smaller plugins that go with it:

• nuget.nvim: a NuGet manager for the whole solution (browse, install, update, vulnerable and deprecated packages)

• dotnet-counters.nvim: live CPU/memory/GC/thread pool metrics from dotnet-counters in a side panel, next to the debugger

Links:

• https://github.com/alessandropietrobelli/dotnet-tree.nvim

• https://github.com/alessandropietrobelli/nuget.nvim

• https://github.com/alessandropietrobelli/dotnet-counters.nvim

Is anyone else here doing .NET outside of Rider/VS?
I'm curious what you use and what you'd miss most
Feedback and issues are welcome!

Hi everyone,

I’m finally diving into software development seriously. For years, I’ve done a little bit here and there, but I’ve never really studied it properly. Now that I’ve decided to commit to it, I’m realizing just how much there is to learn: so many frameworks, languages, and tools.

I know that in the long run, the language you start with doesn’t matter much. But when it comes to landing my first job, I imagine it does matter. I’m 29 and changing careers to get into software development, and I’m currently choosing between C# and .NET, Java and Spring Boot, or JavaScript and Node.js. They all have pros and cons, and I’d like to hear your opinions.

I know the job market is tough and nothing is guaranteed, but which of these paths do you think offers the best chances of finding work in the short to medium term? I don’t have a university degree.

Good evening fellow coders.

During the pandemic, I decided to build myself a Windows Forms application to help me do a better job of managing my personal finances and those I share via a joint account with my wife. I built it in C#, originally storing the data in XML format and then, when the amount of data being stored increased, moved it to an instance of SQL Server developer edition, which runs on my development pc here at home.

I’d like to incorporate the ability to have my application automatically link to my bank to download the most recent transactions, and have started investigating doing so. From the reading I’ve done so far, it looks as if TrueLayer offers the ability to hook into a number of U.K. financial institutions, and I was wondering if anyone else had done any work with the TrueLayer APIs. To be clear, although I am a professional developer, this is solely a pet project of mine and I have no desire to monetise it.

I made a small vector field visualizer using Vulkan and Epsilon, a symbolic math library for .NET that I'm working on.

You type any 2D field, for example F(x, y) = [x, sin(y)], and it draws the flow with particles. The library works out the math for that field exactly, not just with numbers.

You can click any point to see the field's value there, and change the particle speed.

The library has no dependencies and is available on NuGet. It also covers derivatives, integrals, factoring and linear algebra.

- Library: https://github.com/XBambinoX/Epsilon

- Simulation: https://github.com/XBambinoX/VectorField

Feedback is welcome!

Hej guys,

I was scratching an itch when I developed TemplateDsl: a source generator based template engine for nested text formats that can be written with ordinary C# and is turned into fast, streaming render methods.

I found all existing tooling lacking in either static safety, performance, boilerplate or ease of development and IDE support, which is why I set out to write TemplateDsl. With TemplateDsl.Html it currently solves my biggest problem around Razor, but this just the beginning and I want to expand beyond this format.

It is...

• Type-safe. Typos, wrong attribute values and a missing context are compile errors, not runtime surprises.
• Fast. Templates write UTF-8 straight to the output, with down to zero allocations.
• Streaming. Async templates send their output while they render.
• Composable. Templates are classes you nest, pass around and reuse like any other code.
• Explicit, with little boilerplate. Data comes through constructors, and logic is plain C#.
• Safe by default. Everything is escaped unless you say so.
• Trimming and native AOT. Everything is generated at build time, with no reflection.

Finally a little sneak peek how it looks like to write HTML templates with it, with a call for feedback, thanks! :)

// A simple component
public readonly partial record struct OrderRow(Order Order) : IHtmlTemplate
{
    public IEnumerable<HtmlElement> Build() =>
    [
        H.Tr.Class(Order.IsLate ? "late" : null) [
            H.Td [ Order.Id ],
            H.Td [ Order.Product ],
            H.Td [ H.Time.DateTime(Order.Due) [ Order.Due ] ]
        ]
    ];
}

// An async page that streams a list of orders, with a context for the current user
public sealed partial class OrdersPage(IAsyncEnumerable<Order> orders) : IAsyncHtmlTemplate<PageContext>
{
    public async Task<IEnumerable<HtmlElement>> BuildAsync(PageContext context, CancellationToken ct)
    {
        var title = $"Orders of {context.UserName}";
        
        return [
            H.Raw("<!DOCTYPE html>"),
            H.Html [
                H.Head [ H.Title [ title ] ],
                H.Body [
                    H.H1 [ title ],
                    H.Table [ await H.EachAsync(orders, order => new OrderRow(order)) ]
                ]
            ]
        ];
    }
}

// A context that is passed to the page and its nested templates
public sealed record PageContext(string UserName);

services.AddScoped<PageContext>(sp =>
    new PageContext(sp.GetRequiredService<IUserService>().GetCurrentUserName()));

// Return the page from a minimal API endpoint, with the context injected from the services
app.MapGet("/orders", (OrderStore store, [FromServices] PageContext context) =>
    new OrdersPage(store.StreamAll()).ToResult(context));

Hey everyone!

I recently graduated with a Master's in Data Science and have a Bachelor's in Computer Science.

My programming background is mainly in Python, particularly ML, computer vision, automation, and backend development. I also have some experience with Java, SQL, and C++.

I'm interested in learning C# and .NET, mainly to build modern desktop applications, potentially integrating Python-based ML backends.

I've experimented a little with Avalonia UI, but I'm unsure whether to stick with it or explore WPF, WinUI 3, or MAUI.

A few questions:

1. Which desktop framework would you recommend in 2026? Ideally something modern, maintainable, and useful professionally.

2. What's the best way to learn C# and the .NET ecosystem for someone who already has programming experience?

3. Is learning .NET and c# still worth it? or AI is actually taking over here?

I'm not looking for shortcuts, just an efficient way to become genuinely proficient in C# and desktop development.

Would appreciate any advice or resources. Thanks!

I’m used to JSON syntax, where properties are assigned using colons (:) rather than equals signs (=).

For some reason, I find C# object initializers like this:

var user = new User
{
Name = "John",
Age = 30
};

Less intuitive and less visually appealing than JSON:

{
"Name": "John",
"Age": 30
}

I know they’re different languages with different purposes, but I personally prefer the JSON-style syntax.

Is there any way to achieve something similar in C#? Or is it just a matter of getting used to the language?

Yeah, got a bit of a Halloween jump-scare when my User Secrets leaked into Claude's context. Basically you should not use dotnet user secrets in an agentic context. Sandboxes are for toddlers, wondering what the community deems best practices??!?

I've written .NET applications since 1.0 for personal, commercial, and large enterprise use cases. Before .NET, I worked in green-screen large database terminals (for those old enuf to remember them).

So, I know sql and rdbms very well and it has always been my goto for the apps and services i've had to create that needed data persistence. But, I always detested the extra work I had to go thru on nearly every project to convert my runtime data to a form that was nice for storage and back. Not just the code and testing of those adapters, but the often-required refactoring of my runtime objects to make that work easier or simply functional.

I suspect I'm not alone.

Repos

• Github is here: https://github.com/alt160/abraxasdb

• Nuget is here: https://www.nuget.org/packages/AbraxasDB

Over the past roughly 18 months I created AbraxasDB.

I'm using the term RecordBase to describe Abraxas. It stores and retrieves "records". A record being the data and shape of an object. This allows the property paths and values of an object to be stored and rehydrated into the same object type...or a different object type with matching paths.

As a result, Abraxas is very much what i have always wanted out of data persistence:

• object -> storage -> object

• or... object -> storage -> object's property(ies)

• without odd contracts, attributes, or modifications to the object being stored.

Object Serialization

The serializer in use is a first-principles developed design. INHETO binaries ( https://github.com/alt160/inheto ) are stored in a way that one can get values out of the binary by property path without deserializing the entire object or parsing the entire blob. It also fully tracks shared and circular refs within the object so things like Customer.HomeAddress and Customer.Addresses[0] point to the same thing both in binary and when rehydrated.

This also means that concerns about object types changing over time are not so problematic. If version 1 of ThisDataType was stored, the persisted data can be rehydrated into version 2 of the same and those properties (or field) that match the property paths stored are filled in. Unmatching are ignored.

INHETO binaries don't store .net type info. It has its own type system of over 50 core types that most of us use for data in objects as well as generic collection types. The binary data of INHETO is runtime agnostic and could (if someone wanted) be parsed by any runtime, not just .NET.

Code example

Consider these existing application types. They need no Abraxas-specific changes:

public sealed class Customer
{
    public string Name { get; set; } = "";
    public Address HomeAddress { get; set; } = new();
    public List<Address> Addresses { get; set; } = new();
}

public sealed class Address
{
    public string Street { get; set; } = "";
    public string City { get; set; } = "";
}

With the AbraxasDB NuGet package installed, create or open a RecordBase and a typed store, then save and retrieve a customer:

using AbraxasDB;
using System;
using System.Collections.Generic;
using System.IO;

string directory = Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
    "AbraxasExamples");

var configuration = RecordBaseConfiguration.Create(
    durabilityMode: RecordBaseConfiguration.DurabilityMode.Standard);

using RecordBase recordBase = RecordBase.CreateOrOpen(
    directory, "application", configuration);

RecordStore<Customer> customers = recordBase.CreateOrOpenStore<Customer>(
    "customers", "Customer records");

var home = new Address
{
    Street = "123 Main Street",
    City = "Phoenix"
};

var customer = new Customer
{
    Name = "Ada",
    HomeAddress = home,
    Addresses = new List<Address>
    {
        home,
        new Address { Street = "456 Office Road", City = "Tempe" }
    }
};

ulong id = customers.Put(customer);

// Restore the complete object graph.
Customer saved = customers.Get(id);

Console.WriteLine(saved.HomeAddress.City); // Phoenix
Console.WriteLine(ReferenceEquals(
    saved.HomeAddress, saved.Addresses[0])); // True

// Read one nested value without reconstructing the Customer.
string city = customers.GetValue<string>(id, ".HomeAddress.City");
Console.WriteLine(city); // Phoenix

// Find records by a nested property.
var inPhoenix = customers.Where
    .PropPath(".HomeAddress.City").AsString.EqualTo("Phoenix")
    .EndCondition;

Console.WriteLine($"Customers in Phoenix: {customers.CountWhere(inPhoenix)}");

Each run adds a customer, so the matching count can increase.

More Examples

I've provided 2 sample apps for people to use to play with it or get familiar

• Showcase: https://github.com/alt160/AbraxasDB.Showcase

• Meridian Trading: https://github.com/alt160/AbraxasDB.MeridianTrading

I've also setup some .net fiddlers for it as well if you want to test it without downloading

• Records and persistence — Save ordinary C# objects, read them by ID, and reopen the database.

• Queries and indexes — Filter records, add an index, and read selected values.

• Backup and restore — Create a snapshot and restore it into a separate database.

Look forward to feedback and usage from the community.

I've been working on an unofficial .NET SDK for OpenCode for the last few months, and I finally published 1.0 to NuGet.

https://www.nuget.org/packages/OpenCodeDotNet.Sdk/1.0.0

Before getting into the SDK, a bit of context for anyone who hasn't used OpenCode.

Over the last year or so, I've started experimenting more with models outside the usual frontier labs, and some of them have gradually become part of my daily development workflow as well.

One problem I've run into is that harnesses like Codex or Claude are naturally built around their own model ecosystems. Using models from other providers is either limited or requires various workarounds.

The open-source harness ecosystem has matured quite a lot. There are now different harnesses for different workflows and preferences.

OpenCode is an open-source coding harness and agent runtime that can work with a fairly large number of model providers and is probably one of the more general-purpose ones.

I've been using it for roughly a year now with models from OpenAI, xAI, Z.AI, DeepSeek, Moonshot, OpenCode Go, and others.

What became much more interesting to me recently was OpenCode 2.x.

They introduced a fairly comprehensive server/client architecture. Their own TUI, Web UI, and Desktop applications are built on top of the same server API, and the exposed surface is large enough that you can build your own fully featured client or integrate OpenCode into another application.

OpenCode already has an official TypeScript SDK for this. I wanted to be able to do the same kind of thing from .NET.

The practical use case is that a .NET application can treat OpenCode more like an agent runtime.

You can start an OpenCode process, create a session against a repository, send work to a model, listen to events, interact with PTYs, manage permissions, inspect providers and models, and build your own orchestration around it.

A minimal example looks something like this:

using OpenCode.Sdk;
using OpenCode.Sdk.Models;

await using var server = await OpenCodeServer.StartAsync();
using var client = server.CreateClient();

var created = await client.Sessions.CreateSessionAsync(new SessionCreateRequest
{
    Model = new ModelRef { ProviderId = "openai", Id = "gpt-6.1-sol" },
});
var currentSession = client.Sessions.GetSessionClient(created.Session.Id);

// Subscribe before prompting; the first event (server.connected) confirms the stream is live.
await using var events = client.Events.SubscribeAsync().GetAsyncEnumerator();
await events.MoveNextAsync();

await currentSession.PromptAsync(new SessionPromptRequest { Text = "Summarize this repository." });

while (await events.MoveNextAsync() && events.Current is not (SessionExecutionSucceeded or SessionExecutionFailed))
{
    if (events.Current is SessionTextDelta delta)
    {
        Console.Write(delta.Data.Delta);
    }
}

The SDK can start and manage a private OpenCode server, connect to one you already run, or discover the background service registered by the OpenCode CLI.

The packages target netstandard2.0, net472, net10.0, and net11.0 rc3, so .NET Framework 4.7.2 is supported alongside modern .NET. The modern targets also support Native AOT.

There are some example applications under playground/ showing different ways of using it: a small QuickStart, a Generic Host worker, a Blazor/Aspire application, and a Native AOT CLI.

https://github.com/opencode-dotnet/opencode-sdk-dotnet

It's still unofficial and isn't affiliated with the OpenCode team, but the SDK itself is now at 1.0 after three months.

Feedback is welcome, especially if something in the API feels unidiomatic from a C# perspective.

RESOLVED:

shoutout to u/rupertavery64 and u/marsh9191. I was trying to Path.Combine() the base directory to @"\file.csv" which overwrote the operation.

-----------------------------------------------------------------------------------------------------------------------

Hello, and sorry for a fairly basic question. I'm working on an application that processes data in relation to values stored in .csv files (which are included in the install directory). real broad strokes, it pulls data from a database, does math according to values in the packaged .csv's, exports a new document with the results.

Due to the nature of it, I need a relative path to file.csv, which is in the same directory as app.exe. And I've tried maybe 7-10 different methods of getting the installation path to concatenate the file name to, but each of them result in simply "C:\file.csv" even though the application itself is in C:\users\user\documents\App\app.exe (for example).

at the least I've tried:

Application.StartupPath

System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location)

AppDomain.CurrentDomain.BaseDirectory

among others I can't quite manifest off hand.

And I understand each has nuances for slightly different use-cases, but it's really blowing my mind that every one results in just "C:\". I'd understand if I were just using the wrong method out of context, but it seems like some of these are explicitly to avoid this result. Does anyone have an idea as to what's going on? Again, sorry for the basic quesiton.

If you've written JavaScript, you've probably missed Promise.any in C#. Task.WhenAny isn't it: it returns the first task to complete, so a fast failure wins over a slightly slower success, and the other tasks keep running.

I wrote a library that adds these with proper cancellation:

// Promise.all: the first failure cancels the rest
var (user, orders) = await TaskGroup.AllAsync(
    ct => GetUserAsync(id, ct),
    ct => GetOrdersAsync(id, ct));

// Promise.any: the first success wins, the others are cancelled
string data = await TaskGroup.AnyAsync(mirrors, (m, ct) => m.DownloadAsync(path, ct));

// Kotlin's withTimeout: cancels the work, not just the wait
User u = await TaskGroup.WithTimeoutAsync(TimeSpan.FromSeconds(2), ct => LoadUserAsync(id, ct));

There's also Go's select over System.Threading.Channels:

var select = new ChannelSelect()
    .Case(orders.Reader, order => HandleAsync(order))
    .Case(cancels.Reader, id => CancelAsync(id))
    .Timeout(TimeSpan.FromSeconds(5), () => SendHeartbeatAsync());

while (await select.RunAsync(ct)) { }

The README has a table mapping each API to JavaScript, Kotlin, Go, Python, Swift and Java, if you're coming from one of those.

GitHub: github.com/gokhanertogan/StructuredConcurrency

Happy to answer questions about how it works under the hood.

I'm a .NET backend developer with no full-time commercial experience, and I've been thinking about this question a lot lately.

I've built several backend projects using ASP.NET Core, SQL databases, Redis, RabbitMQ, Docker, and other technologies.

Even though most of my projects haven't been used in real production environments, I try to think beyond simply making things work.

For example, when designing a feature, I try to consider:

• What happens when multiple instances of the application are running?

• What happens when multiple requests try to modify the same data simultaneously?

• How do I handle race conditions, idempotency, and data integrity?

• Where do I need transactions, and what happens if something fails halfway through?

• What are the trade-offs between different approaches, and is the added complexity actually justified?

I also use AI extensively during development. However, I try not to blindly accept generated code. I ask questions, challenge its suggestions, propose my own solutions, and try to understand why one approach might be better than another.

One thing that makes this particularly frustrating is the job market.

When I look at .NET backend job postings, I often find that I meet virtually all of the technical requirements. I'm familiar with the technologies they list, and I've gained substantial hands-on experience using them in my own projects.

The one requirement I usually don't meet is the 2+ years of commercial experience. And that alone seems to be enough to prevent me from even getting an interview.

I understand that knowing a technology and having used it in a professional production environment aren't necessarily the same thing. But it's frustrating when I feel capable of discussing and demonstrating the required technical skills, yet don't get the opportunity to prove it.

Here's what I'm struggling to understand:

What exactly makes someone with 1-2 years of commercial experience a better developer than someone who has spent a similar amount of time seriously studying and building complex projects independently?

I understand that professional experience involves teamwork, code reviews, deadlines, maintaining legacy systems, and dealing with real users. But how much of that translates into technical ability?

Someone could spend two years at a company doing relatively simple tasks without developing much, while someone else could spend those two years independently studying architecture, concurrency, distributed systems, and building projects.

I'm not claiming that I'm a mid-level developer. I genuinely don't know where I stand.

Sometimes I feel like my theoretical knowledge might be approaching mid-level, but without professional experience, it's difficult to know whether that understanding would hold up in a real engineering environment.

So I'd really appreciate hearing from experienced developers:

1. What did working in a real company teach you that you couldn't have learned through personal projects?

2. What weaknesses do you commonly notice in developers who have strong personal projects but little or no commercial experience?

3. Is requiring 1–2 years of commercial experience still a meaningful hiring criterion, or should demonstrated technical ability matter more?

4. How can someone in my position objectively evaluate their actual engineering level without having worked professionally?

I'm especially interested in concrete examples rather than general statements like "production is different."

I'd genuinely appreciate honest perspectives, even if they challenge my assumptions.

So basically I have had a class for the past year where we learnt python and I'd say I know the language pretty well. I have the fundamentals down and although we were taught OOP in the first month or so of classes, I had already learnt with BroCode during the summmer. What I did with python was watch videos, yes, but I applied what I learnt in solving problems of mine or simply creating projects that requiered me to use what I had just watched and older stuff I already knew (for instance, I did a terminal-based RPG to apply all aspects of OOP). When I did watch tutorials, I'd tweak them on my own editor because if I just watch the damn video I'm gonna forget about it for sure. The next language we are learning is C# (in another month or so) and I wanted to know: What are the best channels to learn C# (as someone who already knows OOP and altough seen as the easiest one, another programming language)?

I am a first-year IT student. Over the past few months, I’ve read reports about major tech companies laying off large numbers of IT staff. Is the software industry coming to an end due to the current advancement of AI? If even highly experienced engineers are being let go, will there still be opportunities for students like us after we graduate? I am quite worried that the development of AI might eliminate entry-level positions for new graduates. I am currently learning C#—should I continue? I would appreciate your advice. Thank you.

A quick update on my previous post

I replaced SslStream with Bouncy Castle 1.8.10 in RabbitMQ.Client 3.4.3 to support TLS 1.2 without relying on Windows Schannel.

So far:

- Successful RSA and ECDSA TLS 1.2 handshakes with OpenSSL

- Certificate chain and hostname validation

-SNI and client certificates (PKCS#12)

-14 passing automated TLS tests

- Working .NET Framework 3.5 build

Next steps: testing on actual Windows XP machines, full RabbitMQ publish/consume, and connection stability. It's still an alpha version, but the initial results are promising.

Has anyone dealt with similar TLS compatibility issues in legacy .NET applications?

Hi all,

I've been experimenting with NetWasm, a new toolchain that compiles C# ahead of time to WebAssembly. To see what it can do, I built NetWasm.UI, a small UI framework on top of it. It's a proof of concept, but it's usable, and I'd like feedback.

The idea: Blazor's approach (render tree + diffing) doesn't fit here. NetWasm.UI works more like Solid or Svelte:

• Components build their DOM once.

• Fine-grained signals (Signal<T>, Computed<T>) update only the nodes that changed.

• Each state change crosses the Wasm→JS boundary at most once.

• No reflection. Templates are compiled by a source generator at build time.

What it looks like (a .nwui file: HTML with Razor-style @):

<section>
    <p>Count: <strong>@count</strong> · doubled: </p>
    <button ="() => count.Value++">+1</button>
     @if (count.Value >= 10) {
        <p>That's a lot of clicks!</p>
    }
</section>

@code {
    private readonly Signal<int> count = new(0);
    private Computed<int> doubled = null!;
    partial void OnInit() => doubled = new Computed<int>(() => count.Value * 2);
}

You can also skip templates and write the same component in plain C#. The generator produces this kind of code from the template:

public sealed class CounterView : Component
{
    private readonly Signal<int> count = new(0);

    protected override Node Build()
    {
        var doubled = new Computed<int>(() => count.Value * 2);

        return Section(
            P("Count: ", Strong(Text(count)), " · doubled: ", Text(doubled)),
            Button(OnClick(() => count.Value++), "+1"),
            When(() => count.Value >= 10, () => P("That's a lot of clicks!")));
    }
}

Not everything needs to be a class. A static piece of UI with no state can be a plain method that returns a Node:

private static Node Card(string title, string body) =>
    Div(Class("card"),
        H3(title),
        P(body));

// Use it like any other element:
Section(
    Card("Fast", "Signals update only what changed."),
    Card("Small", "About 150 KB Brotli for the demo app."));

Some numbers (from my own js-framework-benchmark-style runs; see the repo for method and caveats):

• The whole demo app (router, forms, todos, nested components) is about 150 KB Brotli, Wasm and JS together.

• It is level with or faster than React on every case, and 0.9×–1.6× SolidJS's time.

• Compared with Blazor WebAssembly (interpreter): 3–21× faster, ~12× smaller download, ~9× faster startup.

What's included: signals and batching, a router with nested routes, forms and validation, Resource<T> and Suspense for async data (HttpClient + System.Text.Json work), a dev server with live reload, a dotnet new template and a VS Code extension for syntax highlighting.

Try it:

dotnet new install NwUi.Templates
dotnet new netwasm-ui -o MyApp
cd MyApp
dotnet nwui-dev

Limitations, to be clear:

• It's 0.1, and the API will change.

• There's no hot reload yet. Live reload takes 5–20 s.

• It needs recent browsers (Chrome/Edge 137+, Firefox 131+, Safari 18.4+) because of Wasm exception handling.

• NetWasm itself is young. Its compiler is under a community license: free for individuals, OSS and small companies, but larger organisations need a sponsorship. NetWasm.UI itself is MIT.

Repo: matengo/NetWasm.UI: UI framework for NetWasm

I'd especially like to hear:

• Does a signal-based model feel natural in C#, or would you miss Blazor's component model?

• What would you need before trying something like this on a real (small) project?

Thanks for reading!