We Killed the Monster: WebForms Core 2.0 Released and the End of the Front-end Era of Terror

Introduction: Anatomy of a Modern Nightmare

The world of web development had gone astray. The front-end, once a simple tool for displaying information, had evolved into a "monster". It bled developers dry with heavy frameworks, endless toolchains, multi-gigabyte node_modules, and the dizzying complexity of State Management.

At Elanat, we have slain this monster. Not with another tool to compete, but with a revolutionary paradigm shift. WebForms Core 2.0 is the definitive answer to the questions that modern frameworks (like React and Angular) and even hybrid solutions (like Blazor Server) have failed to answer.

Version 2 of the WebForms Core technology has been released, and the WebForms class in the C# programming language has been aligned with the WebFormsJS library.
The WebForms class for the PHP programming language has also been aligned with version 2, and we will soon be updating the WebForms classes for other programming languages ​​(Python, GO, Java, etc.) to align with WebFormsJS version 2.

≈ 99% Performance Guarantee

In this release, we not only tested new features, but also thoroughly evaluated all WebForms Core features from the beginning, fixing any bugs we encountered (most of which were minor). We used the Regression Testing model: we tested all features and after a round of corrections, we retested all system features to make sure that the new changes did not break any previous features. Interestingly, while testing the performance of WebForms Core, we also added several new features to this technology based on the needs we felt.

WebForms Core vs. Front-end Frameworks (React, Vue, Angular)

Version 2 of WebForms Core technology has achieved a significant advantage over front-end frameworks by providing new and diverse features. The only limitation of WebForms Core compared to front-end frameworks is that it has a smaller ecosystem and developer community, so the resources, plugins, and public documentation are not as extensive as React or Vue. However, we will soon compensate for these limitations by organizing the documentation and creating various module packages.

WebForms Core is the most comprehensive platform for full-stack development and is an exceptional implementation of the "server-driven UI" idea.

How to use WebForms Core technology?

Two steps are required:
1- On the client side: Add the WebFormsJS script to your HTML page.

<script type="module" src="/script/web-forms.js"></script>

Get the WebFormsJS script from the following link:
https://github.com/webforms-core/Web_forms/blob/elanat_framework/web-forms.js

2- On the server side: Import the WebForms class for your programming language.
Get the WebForms class associated with the server programming language from the following link:
https://github.com/webforms-core/Web_forms_classes

How to do it: Create an instance of the WebForms class on the server side and use the powerful functions of this class.

Example:

WebForms form = new WebForms();
form.AddTag("<form>", "h3");
form.SetTextColor("<h3>", "lightblue");
form.SetText("<h3>", "Hello World!");
form.AddState("#state1");
Write(form.Response());

Why Current Models Are Obsolete?

Almost the entire web today operates on two models:

• Data Flow (JSON/HTML): Raw data is sent, and the client must figure out what to do with it.
• Diff Flow (Virtual DOM): Structures are compared in memory (Diffing) to apply changes.

WebForms Core 2.0 eliminates these time-consuming and resource-heavy steps by introducing Imperative Command Flow. In this model, the server sends "direct commands" instead of sending entire data sets or HTML for comparison.

In Blazor Server, the server must maintain a copy of the client's DOM and perform heavy Diffing calculations. In WebForms Core, the server is stateless and simply says: "Turn the Main tag's color to green." That's it! This results in near-zero latency, negligible bandwidth consumption, and breathtaking server scalability.

Most Important Features in WebForms Core 2

1. Master Pages and Service Worker

Perhaps the most stunning part of version 2 is the Master Pages system. We have used a unique innovation instead of re-rendering layers. By combining Service Worker and routeAlias on the client, the application's main Layout is cached forever. When a user clicks a link, the system recognizes the layer is in memory, sends a Post-Back header, and the server only transmits commands for the <main> section.

You get the power of the server with the speed of a native application.

2. WasmBack and FrontBack

We have broken the boundaries of programming languages.

• WasmBack: This revolutionary feature allows languages like Rust, C++, Go, and C# to use the WebForms class directly in the browser (WebAssembly).
• FrontBack: For the 2% of scenarios requiring pure client logic, you no longer need to return to messy JS spaghetti code. FrontBack allows JS modules to generate WebForms commands.

WebForms Core is now an "Operating System for the Web" that speaks every language.

3. Unit Testing the DOM — From the Server

Frontend unit testing is usually fragile, slow, and JavaScript-heavy.

WebForms Core 2.0 includes a native Unit Testing system that allows:

• Deep DOM comparison
• Validation of inputs, attributes, classes, and structure
• Assertion of expected UI results after command execution

All written from the server.
No headless browsers. No external libraries.

This finally makes UI testing deterministic and practical.

4. Smart Form Submissions: Only Send What Truly Changed

One of the silent killers of performance in modern web applications is redundant data transfer. Traditional frameworks blindly resend entire form payloads, forcing the server to re-validate, re-parse, and re-process data that the user never touched.

WebForms Core 2.0 introduces Smart Form Submissions.
Only fields that have actually changed are transmitted to the server.

This is not a cosmetic optimization — it is a state-aware protocol feature.
The framework tracks the initial and current state, computes checksums, and guarantees that unchanged data is never resent.

The result:

• Dramatically smaller request payloads
• Faster server processing
• Clear detection of real user intent
• A foundation for secure, large-scale enterprise forms

This is form submission done correctly for the first time.

5. TriggerEvent: Programmatic Control Over User Interactions

Most frameworks treat events as sacred, user-only actions.
WebForms Core rejects this limitation.

With TriggerEvent, the server can execute any DOM event — click, input, submit, change, or custom events — without user interaction.

This enables:

• Fully automated UI flows
• Complex orchestration without client-side scripts
• Server-driven UX logic that remains deterministic and testable

The server is no longer reacting to the UI.
The server is orchestrating it.

6. Custom DOM Events: Expanding the Browser’s Event Model

HTML’s native event set is limited — and extending it usually requires fragile JavaScript hacks.

WebForms Core 2.0 allows developers to define entirely new DOM events on the server and bind them seamlessly to client elements.

These custom events behave like first-class browser events:

• They can be triggered
• Listened to
• Passed through the command pipeline
• Combined with native events

This effectively extends the browser’s event system using server logic — something no mainstream framework offers.

7. Async Command Execution: Non-Blocking UI Without Complexity

Asynchronous logic is notoriously hard to manage when UI consistency matters.

WebForms Core 2.0 solves this by introducing Async Commands directly into the command pipeline.
Commands can be executed using async / await, delayed, or run independently — without breaking execution order or UI integrity.

Heavy operations are isolated.
Lightweight UI updates remain instant.
No race conditions. No callback hell.

This is true asynchronous UI orchestration, server-controlled and deterministic.

8. Automatic Gzip: Bandwidth as a First-Class Concern

In WebForms Core 2.0, bandwidth efficiency is not an afterthought.

The framework natively supports:

• Gzip compression for outgoing data
• Automatic decompression of incoming form data and file uploads

This applies transparently to:

• Action Controls
• Form submissions
• File uploads
• Large payloads

The developer writes zero extra code.
The system simply moves less data, faster.

9. JavaScript Modules Without Dependency Chaos

Modern JavaScript requires modules — but most frameworks treat them as an afterthought.

WebForms Core 2.0 fully embraces ES Modules:

• Native type="module" support
• Dynamic async loading
• Safe detection of method existence
• Direct invocation from server commands

You get modern JS capabilities without surrendering control to a client-side framework.

Modules become tools — not the architecture.

10. Smart Templates & Deep Replace Engine

Templates in most systems are static, shallow, and disposable.

WebForms Core introduces Smart Templates:

• Placeholders anywhere (text, attributes, tag names)
• Deep traversal replacement
• Partial and surgical updates
• External template fetching from HTML, JSON, XML, or INI

Templates become living structures, not static markup.

This enables:

• Large-scale UI reuse
• Ultra-fast updates
• Zero re-rendering

---

WebForms Core 2.0 — Technical Reference (Feature List)

Version 2 of WebForms Core technology includes new, more powerful and extensive features. We have listed these new features below:

1. Architecture

1.1 Command Execution Model

• ptimization Pre-Runner Queue System
• Dynamic Command Queue Management
• Preventing Concurrent Request Collisions
• Ordered Command Execution
• Debounce Delay

1.2 Async & Runtime Model

• Fully Async WebFormsJS Architecture
• Async Action Controls
• Awaitable Server Commands
• Async Cache & Session Access
• Async Delay Between Commands
• Async JavaScript Module Loading
• Async FrontBack Execution
• Async WasmBack Response Handling

1.3 Layout & Rendering Strategy

• Master Pages Architecture
• Partial Rendering via Post-Back Header
• Layout Caching
• Cached Layout Reuse Across Routes
• Body OnLoad Routing Detection
• Skip Layout Rendering on Post-Back
• Combined HTML + ActionControl Responses
• Comment Mode Rendering

2. Communication

2.1 HTTP & PostBack

• PostBack / GetBack / TagBack
• Action Control Data Submission
• Submit Button Support
• Form Submission Detection
• Form Header Injection (form=true)
• Change-Only Form Submission
• Serialized Event Data Transport
• SendBack (Non-URL-Encoded Payloads)
• GraphQL-Compatible Transport
• GET Encoding Optimization

2.2 WebSocket

• Command-Based WebSocket Responses
• WebSocket Form Detection
• Optimized Data Transmission
• Mixed HTML + Command Responses
• Retry on WebSocket Failure
• WebSocket Logging
• Queue-Safe WebSocket Execution

2.3 Server-Sent Events (SSE)

• Native SSE Support
• SSE Broadcast from View / Controller / Model
• SSE ExportToLineBreak
• SSE Retry & Reconnect Handling
• SSE Console Logging
• SSE Configuration Options
• SSE Without Middleware Dependency

2.4 Network Optimization

• Automatic Gzip Data Compression (Client → Server)
• Automatic Gzip File Compression (Client → Client)
• Small Command Payloads
• Skip Unchanged Data Transmission

3. DOM & UI Commands

3.1 DOM Selection

• Advanced Tag Selectors
• Multiple Tag Selection (*)
• Query-All Support Across Outputs
• Deep DOM Traversal
• External HTML Tag Extraction

3.2 DOM Manipulation

• Replace (Text / Attribute / Value)
• Placeholder-Based Replace
• Deep Replace Traversal
• Update Structure
• Increase / Decrease Numeric Values
• Append / Insert / Remove Operations
• Reflection (Attribute & Child Inheritance)
• HTML Part Injection
• Template-Based Rendering

3.3 UI State & Interaction

• TriggerEvent (Artificial DOM Events)
• Custom DOM Events
• Window-Level Event Binding
• Element Reached Event
• Scroll-to-Bottom Event
• InputPlace (Window / Element)
• Automatic Loader System
• Flicker Prevention
• Interaction Lock During Requests

4. State, Storage & Security

4.1 State Management

• Client-Side Cache Management
• Client-Side Session Management
• Add / Insert Cache Values
• Add / Insert Session Cache Values
• Awaitable Storage Operations
• FormatStorage with Variables
• Template Storage
• Variable Injection into Storage

4.2 Integrity & Validation

• Checksum Generation
• SHA256 Hash Support
• Server-Side Checksum Validation
• Hash Storage & Lookup
• HasHash Condition Checks
• Detect Executed Action Controls
• Prevent Duplicate Submissions
• Data Integrity Verification

4.3 Security Controls

• Security Configuration Options
• XSS Mitigation Layer
• Module Execution Restrictions
• Method Existence Validation
• Browser Capability Detection
• Unsupported Feature Logging

5. Runtime Extensions & Cross-Platform

5.1 WasmBack

• WebForms Execution in WebAssembly
• Shared WebForms Class (Server & WASM)
• Action Control Detection in WASM Responses
• Multi-Language Support (C#, Rust, Go, C++)
• WASM Command Application to HTML

5.2 FrontBack

• Server-Less WebForms Execution
• JavaScript-Based WebForms Class
• PageLoad Execution in Front-End
• HTML & Action Control Generation in JS
• Hybrid Front / Server Scenarios

5.3 JavaScript Modules

• Native ES Module Support
• type="module" Enforcement
• Dynamic Module Loading
• Module Method Discovery
• JavaScript Function Assignment to DOM Events
• Custom JS Function Invocation from Server

6. Tooling, Testing & Diagnostics

6.1 Testing

• Integrated Unit Testing Tool
• DOM Equality Assertion
• Deep DOM Comparison
• Form Value Assertions
• Attribute & Class Comparison
• Non-Blocking Test Reporting
• Regression Testing Strategy

6.2 Logging & Debugging

• Console Message Injection
• Structured Logging System
• Error Categorization
• Network Error Detection
• Retry Logging
• Browser Support Logs

6.3 Reliability & Control

• Retry Mechanism
• Max Retry Count
• Retry Interval Control
• Request Queue Management
• Interval Assignment with ID
• Delete Interval Support

7. Fetch & External Resources

7.1 Fetch System

• InputPlace Upgrade for HTML Fetching
• External HTML Template Fetch
• JSON Fetch (Nested Keys)
• XML Fetch (XPath)
• INI Fetch (Key / Line Index)
• Event Fetch (evt)
• Escaped Fetch (@@)
• Location Property Access (href, pathname, host, …)

8. Progressive Web App (PWA)

• Service Worker Integration
• Route Alias Configuration
• More Offline Capability
• One-Time Layout Fetch
• Cached Layout Rehydration
• Native-App-Like Navigation

---

These features make WebForms Core 2.0 the most powerful full-stack development infrastructure, completely erasing the boundaries between server and client.

Note: These features are only relevant to version 2. Previous versions have also added powerful features and capabilities to this technology.

---

Why Is This a Revolution?

Imagine a developer who spent years learning complex JS frameworks suddenly realizing they can build a real-time, PWA-ready, high-performance app using only their C# (Or any popular programming language) knowledge. This is the moment "Technology" becomes "Magic."

The Front-end Monster is dead. Paradigm Shift: Write Once, Control Everywhere.

Why WebForms Core is outstanding and important:

• Unparalleled DOM Manipulation
• Complete Event Management
• Advanced State Management
• Powerful Template System
• Server-side management, heavy processing on the client
• Unprecedented comprehensiveness - everything in one package
• Changing the way we think about front-end/back-end
• Offline performance in a server-driven approach