CodeBehind 4.8, the server-side web framework developed by Elanat, has reached a significant performance milestone in the latest Web Frameworks Benchmark.
According to the benchmark results published on October 6, 2026, CodeBehind 4.8 processes substantially more requests per second than ASP.NET MVC 10 across all three tested request sizes.
The benchmark comparison is available on the Web Frameworks Benchmark results page for C#, where you can review CodeBehind 4.8 alongside ASP.NET MVC and other C# web frameworks.
On average, CodeBehind is about 19% faster than ASP.NET MVC in these results.
Benchmark Results
The benchmark reports the following results for C# frameworks:
| Framework | Requests/s (64) | Requests/s (256) | Requests/s (512) |
|---|---|---|---|
| ASP.NET Minimal API | 166,518 | 147,805 | 143,096 |
| Carter | 166,262 | 146,862 | 141,774 |
| CodeBehind 4.8 | 139,431 | 127,252 | 126,435 |
| FastEndpoints | 135,409 | 125,525 | 123,542 |
| ASP.NET MVC 10 | 114,011 | 108,498 | 107,883 |
| Effinitive Framework | 107,160 | 103,343 | 103,860 |
| GenHTTP | 101,527 | 95,798 | 98,406 |
| Simplify.Web | 56,881 | 57,221 | 56,785 |
The direct comparison between CodeBehind and ASP.NET MVC is particularly interesting:
| Request Size | CodeBehind 4.8 | ASP.NET MVC 10 | CodeBehind Advantage |
|---|---|---|---|
| 64 | 139,431 | 114,011 | 22.3% |
| 256 | 127,252 | 108,498 | 17.3% |
| 512 | 126,435 | 107,883 | 17.2% |
Taking the three comparisons together, CodeBehind's average advantage is approximately 19%.
This comparison is particularly significant because CodeBehind is a versatile, feature-rich web framework capable of supporting different development models and architectural approaches. It can provide MVC, MVC First-View, WebForms Core, and other approaches to server-side web development, making it comparable in scope to Microsoft's three major .NET web frameworks: ASP.NET Core MVC, Razor Pages, and Blazor. Through its integration with WebForms Core, CodeBehind also supports server-orchestrated UI manipulation using WebForms commands and WebFormsJS, with features such as Render, Snapshot, Rollback, and TransientDom. Achieving approximately 19% higher average throughput than ASP.NET MVC in the reported benchmark is particularly noteworthy given the versatility and range of capabilities CodeBehind offers.
An Important Detail About the CodeBehind Execution Model
CodeBehind uses a code-generation and compilation process to prepare its View and Controller execution paths. During initial startup, or after relevant structural changes, it generates a C# source file containing a switch statement for route handling and dedicated asynchronous methods for individual Views and Controllers. It then compiles this generated source code and loads the resulting assembly.
For example, a route such as /series/Default.aspx can be mapped to a dedicated method such as _series_Default_aspx_SeriesSiteController_PageLoad1. Once compilation is complete, request handling uses the generated, compiled execution paths instead of regenerating and recompiling this code for every request. This process is triggered again when required by application restarts, redeployment, or structural changes to Views and Controllers. With precompilation, the generation and compilation cost can also be moved to the build or deployment stage.
This distinction is important when interpreting performance benchmarks: the initial code-generation and compilation cost is separate from steady-state request throughput. Whether it affects a particular benchmark depends on how that benchmark measures application startup and request processing. The reported results establish CodeBehind's approximately 19% average throughput advantage over ASP.NET MVC in the three tested scenarios.
This Performance Did Not Come From a Single Change
The performance gap is the result of continuous engineering work by Elanat.
CodeBehind has been developed with a strong focus on reducing unnecessary processing in the server-side request pipeline while maintaining a structured programming model for server-side web applications.
Recent releases have introduced several important architectural and implementation improvements.
Removing Unnecessary Processing
One example is the removal of the Control method in CodeBehind 4.8.
Although the overhead of this method was relatively small, it introduced additional processing during requests. Removing it eliminates that unnecessary path from the framework.
This is an important principle in performance-oriented framework development:
Small amounts of unnecessary work become significant when they are repeated across a large number of requests.
CodeBehind 4.8 also removed the web_forms_view_place and use_comment_mode_for_web_forms_combinate options as part of a cleaner and more reliable options architecture.
These changes are not simply API cleanup. They reduce legacy paths and simplify framework behavior.
Performance Through Simplification
Elanat has also been working toward a more consistent WebForms API across different programming languages.
The WebForms class is available across multiple WebForms Core implementations. Removing language-specific behavior such as the old Control pattern makes the API more consistent between implementations.
This is useful not only from an API-design perspective but also from a maintenance and optimization perspective.
A smaller and more consistent execution path is easier to optimize.
CodeBehind and ASP.NET MVC
ASP.NET MVC remains one of the most established server-side web frameworks in the .NET ecosystem.
The benchmark result does not mean that CodeBehind is faster than MVC in every possible application or workload. Real-world performance depends on application architecture, middleware, database access, serialization, network conditions, hardware, configuration, and the specific operations performed by an application.
However, the benchmark provides a useful direct comparison under the same reported benchmark environment.
In these results, CodeBehind consistently stays ahead of ASP.NET MVC:
139,431 vs. 114,011 requests/s at the 64-request test size,
127,252 vs. 108,498 requests/s at 256,
and
126,435 vs. 107,883 requests/s at 512.
The resulting average advantage is approximately 19%.
More Than a Benchmark Number
For Elanat, the significance of this result is not simply the number itself.
CodeBehind has been evolving through a series of architectural decisions aimed at reducing unnecessary work, simplifying execution paths, improving rendering behavior, and creating a more consistent server-side development model.
The performance result is therefore better viewed as the outcome of continued optimization rather than a single performance trick.
Conclusion
The latest Web Frameworks Benchmark shows that CodeBehind 4.8 is approximately 19% faster than ASP.NET MVC 10 on average across the three reported request sizes.
The individual advantage ranges from 17.2% to 22.3%, with CodeBehind outperforming ASP.NET MVC in every tested case.
At the same time, CodeBehind performs one-time View and Controller class generation and compilation during its initial execution. This additional work should be distinguished from steady-state request processing after compilation.
Related Links
Elanat:
GitHub:
NuGet:
Top comments (0)