DEV Community

Cover image for WebForms Core in NuGet
Elanat Framework
Elanat Framework

Posted on

WebForms Core in NuGet

#dotnet #nuget #news #webformscore

We’re excited to announce that WebForms Core, the server-driven UI technology developed by Elanat, is now officially available on NuGet under the package name WFC. This release makes it easy for .NET developers to integrate WebForms Core directly into their ASP.NET Core projects — including Razor Pages and MVC — using standard .NET tooling.

Install WebForms Core

Installing WebForms Core is now just one command away:

dotnet add package WFC
Enter fullscreen mode Exit fullscreen mode

Alternatively, you can reference WebForms Core directly in your project file by adding:

<PackageReference Include="WFC" />
Enter fullscreen mode Exit fullscreen mode

to your .csproj, making integration seamless with existing .NET workflows.

To complete the setup, the WebFormsJS runtime must be added to the <head> section of your HTML pages. You can get WebFormsJS from the following sources:

With this package, developers gain access to the WebForms Core server-side API, enabling command-based DOM manipulation, event handling, smart form submissions, and fully server-driven UI logic — without relying on heavy front-end frameworks.

WebForms Core introduces a Commander / Executor model, where the server emits precise UI commands and the lightweight WebFormsJS runtime executes them in the browser. This eliminates virtual DOM diffing, significantly reduces bandwidth usage, and keeps the server stateless while still delivering highly interactive and deterministic user experiences.

Example: Removing a DOM Element with WebForms Core

HTML

<script type="module" src="/static/script/web-forms.js"></script>
<div id="box">
    This element will be removed
</div>
<button id="removeBtn">Remove</button>
@Html.Raw(ViewData["WebForms"] ?? "")
Enter fullscreen mode Exit fullscreen mode

Server-side (C# – WebForms Core)

using WebFormsCore
...
public IActionResult OnGet()
{
    var form = new WebForms();

    if (Request.Query.ContainsKey("remove_box"))
    {
        form.Remove("box");
        return Content(form.Response(), "text/html");
    }

    // Bind click event
    form.SetGetEvent("removeBtn", "onclick", "?remove_box");

    // Export commands
    ViewData["WebForms"] = form.ExportToHtmlComment();

    return Page();
}
Enter fullscreen mode Exit fullscreen mode

What happens here?

  • When the button is clicked, a request is sent to the server
  • The server sends a Remove command
  • WebFormsJS executes it instantly in the browser
  • No page refresh, no DOM diffing, no JavaScript written

This example shows exactly what the WebForms Core philosophy is:

The server doesn’t send HTML — it sends intent.

WebForms Core can be described as a Deterministic UI Runtime + Protocol + DSL.

That means:

  • It’s not just a framework
  • It’s not just server-driven UI
  • It’s not a revival of classic WebForms

Instead, it defines:

  • A communication protocol
  • A UI execution model
  • A client-side runtime
  • A command-oriented language

No other web system currently combines all of these concerns into a single, cohesive model.

If you’d like to see a practical example, the following article walks through real usage with Razor Pages:

State Management in WebForms Core 2 (Razor Pages Example)

The availability of WebForms Core on NuGet marks an important step toward broader adoption in the .NET ecosystem. Whether you’re building new applications, modernizing legacy systems, or exploring server-driven UI architectures beyond Blazor, WFC offers a powerful, minimalist, and fundamentally different approach worth exploring.

Top comments (0)