TechEmpower Round 23 Results: Performance Madness and The Final Stand
Welcome to the Asylum: Why TechEmpower Round 23 Matters
Greetings, fellow code-jockeys, nanosecond-hunters, and those of you who still think writing a CRUD app in a framework that takes 400ms to respond is “fine.” It is I, your resident Wong Edan, back from the depths of the server room with a fresh pot of coffee and a heart full of digital salt. Today, we are dissecting the long-awaited, highly controversial, and potentially final TechEmpower Web Framework Benchmarks Round 23.
If you haven’t been paying attention to the TechEmpower Framework Benchmarks Round 23, then what have you been doing with your life? Probably something productive, like actually shipping features. But for the rest of us obsessed with backend framework performance and the eternal quest for the highest composite score, Round 23 is our Super Bowl. It’s the arena where frameworks come to flex, and where “web-scale” isn’t just a buzzword—it’s a bloodbath of JSON serialization and database queries.
Why do we care? Because in the world of high-performance web development, every microsecond is a penny saved, and every failed request is a tear in the eye of a DevOps engineer. Round 23 represents a massive shift in the ecosystem. We’ve seen substantial increases in performance across the board, particularly in network-bound tests. But as the whispers of “archiving” and “sunsetting” grow louder in the tech corridors (shoutout to the 2026 news cycle), this round feels like the grand finale of an era. So, let’s dive into the madness.
The Ruby Renaissance: More Than Just ‘Rails is Slow’
If you listened to the “experts” five years ago, Ruby was supposed to be dead, buried under a pile of slow-performing gems and memory leaks. But hold your horses! The TechEmpower Web Framework Benchmarks Round 23 data, particularly the chatter over on r/ruby from March 2025, reveals a surprising narrative. Ruby frameworks have seen some “nice improvements.”
When we look at the composite score, Ruby isn’t just surviving; it’s thriving in its own niche. While it might not be dethroning the C++ or Rust monsters in raw plaintext throughput, the optimization in the Ruby ecosystem has clearly paid off. We are seeing better concurrency management and more efficient memory usage in the latest iterations. The gap between the “fast” languages and the “productive” languages is narrowing. It’s enough to make a Wong Edan shed a tear—or at least stop screaming at his terminal for five minutes.
The improvement in Ruby’s standings suggests that the community has stopped focusing purely on syntax sugar and started looking at the underlying VM performance. In a world where backend framework performance is often sacrificed for developer ergonomics, Ruby is trying to prove you can have both. Or at least, you can have enough of both to not get laughed out of the server room.
GoFrame: The Go Powerhouse Steals the Spotlight
Moving on to the gophers. If you’re into the Go ecosystem, you know it’s a crowded field. But GoFrame has emerged in Round 23 as a serious heavyweight. The evaluation results published in March 2025 show that GoFrame, as a full-featured Go web development framework, has achieved excellent results across multiple test categories.
What makes GoFrame stand out in the TechEmpower Web Framework Benchmarks Round 23? It’s not just about raw speed; it’s about being “full-featured.” Usually, when a framework does everything for you (ORMs, logging, configuration), it pays a “complexity tax.” GoFrame seems to have dodged the tax collector. It’s hitting high marks in:
- JSON Serialization: Rapidly converting structures to strings without melting the CPU.
- Database Access: Efficient connection pooling and query execution.
- Fortunes: The ultimate test of template rendering and database interaction.
For those of you looking for high-performance web development tools in 2025, GoFrame is making a compelling case that you don’t need to piece together 50 different micro-libraries to get top-tier performance. It’s a “batteries-included” approach that actually works. Wong Edan approves, even if the gopher mascot still looks like it’s seen things it shouldn’t have.
The Perl Comeback: Kelp Overhauls the Status Quo
Now, let’s talk about something truly “Edan” (crazy). Perl. Yes, Perl. You thought it was for CGI scripts written in 1997? Think again. GitHub Issue #9589, dated February 2025, flagged a complete overhaul of the Kelp framework code for Round 23.
Kelp was historically one of the best performing Perl web frameworks, and the contributors decided that Round 23 was the time to reclaim that crown. By stripping away legacy bloat and optimizing the request-response cycle, Kelp is proving that the “ancient” languages still have teeth.
# A glimpse into the Kelp mindset
use Kelp;
my $app = Kelp->new;
$app->add_route('/json' => sub {
return { message => "Hello, World!" };
});
$app->run;
The overhaul was designed to maximize performance in the TechEmpower environment, which favors lean, mean, non-blocking machines. Seeing Perl frameworks pop up in the top tiers of performance benchmarks is a reminder that good engineering beats “modern” hype every single day. If you’re a Perl developer still holding the line, Kelp in Round 23 is your banner of victory.
The ASP.NET Core Conundrum: Ranking 35 and the Kestrel Question
Wait, what? Stop the press. One of the most shocking revelations from the TechEmpower Web Framework Benchmarks Round 23—and a hot topic on Hacker News—is the fall of aspnetcore. In the Fortunes leaderboard, it dropped to the 35th position.
Now, before the Microsoft fanboys come for my head with pitchforks made of C# interfaces, let’s look at the facts. The code used for this result primarily relies on Kestrel, the cross-platform web server for ASP.NET Core. Critics and benchmark enthusiasts have noted that the implementation used in Round 23 is “bare-bones,” almost just a Kestrel wrapper rather than a full-fledged application.
The paradox here is that while aspnetcore is still insanely fast, other frameworks—particularly those using Rust (actix) or specialized C++ (drogon)—have pushed the ceiling so high that “fast” isn’t enough anymore. You need to be “absurd” to stay in the top 10. The drop to 35 on the Fortunes leaderboard is a wake-up call. It suggests that while Kestrel is a beast, the overhead of the surrounding framework in a specific, highly-contested test like Fortunes is where the battle is lost or won. Or maybe the developers were just too busy building actual features to micro-optimize a benchmark. (But where’s the fun in that?)
Technical Breakdown: The Network-Bound Surge
One of the most significant takeaways from the March 17, 2025, update regarding Round 23 is the “substantial increase in performance across the board, particularly in network-bound tests.” This isn’t just because the frameworks got better; the environment and the way the TechEmpower Web Benchmarks handle networking have evolved.
In previous rounds, many frameworks were bottlenecked by how they handled TCP connections or how the underlying OS managed high-concurrency network traffic. In Round 23, we see a shift. Frameworks that utilize io_uring (on Linux) or highly efficient asynchronous event loops are reaping the rewards.
Key Performance Indicators (KPIs) in Round 23:
- Throughput (Requests Per Second): How many hits can the server take before it catches fire?
- Latency: The time it takes for the first byte to reach the client. In Round 23, we’re seeing sub-millisecond latencies in the top 50 frameworks.
- Composite Score: A weighted average across multiple tests (JSON, Fortunes, DB updates) that gives a holistic view of backend framework performance.
When a framework claims a high composite score, it means it’s a generalist. It’s not just good at spitting out “Hello World” in plaintext (which is easy); it’s good at talking to a database and handling complex data structures. This is where the real high-performance web development happens.
The Sunsetting: Is Round 23 the Last Dance?
Now for the bittersweet part of our TechEmpower Framework Benchmarks Round 23 coverage. Reports surfacing in March 2026 indicate that the TechEmpower Framework Benchmarks are now Archived. Yes, you read that right. The project that has defined backend bragging rights for over a decade is sunsetting.
Why? Because as the project gained more traction, having good results became a “top priority for framework developers for their new software releases.” This sounds like a good thing, right? Well, it led to “benchmarketing.” Developers were writing code specifically to win the benchmark, code that looked nothing like what you’d use in a real production environment.
“As it got more and more traction, having good results became a top priority… the code for some results doesn’t even represent real-world usage.”
— Industry Insider via Hacker News
When frameworks start stripping away security features, logging, and basic sanity checks just to climb five spots on a leaderboard, the benchmark loses its utility for the average developer. Round 23 might just be the pinnacle of this “arms race.” It’s the most optimized, most hyper-tuned set of results we’ve ever seen, but it’s also a warning that we might have reached the limit of what “meaningful” benchmarking can achieve.
Wong Edan’s Verdict: The Good, The Bad, and The Blazing Fast
So, what have we learned from this 2000-word descent into madness?
First, the TechEmpower Web Framework Benchmarks Round 23 has proven that Ruby is not your grandfather’s slow scripting language anymore. The improvements in the Ruby composite score are a testament to the hard work of the community in optimizing the modern stack.
Second, GoFrame is a beast. If you’re in the Go world and want a framework that handles the heavy lifting without sacrificing your backend framework performance, look no further. It’s the gold standard for full-featured Go performance in Round 23.
Third, Perl lives! The Kelp overhaul is a glorious middle finger to everyone who said Perl was dead. It’s lean, it’s mean, and it’s fast.
Fourth, ASP.NET Core is in a weird spot. It’s still a top-tier choice for enterprise, but its slide on the Fortunes leaderboard shows that even the giants can get out-maneuvered by hyper-specialized contenders using Kestrel in “clever” ways.
Finally, the sunsetting of the benchmarks is a reminder that performance is just one piece of the puzzle. A framework that responds in 10 microseconds is useless if it takes you ten years to write a login page in it. We use these benchmarks to push the boundaries of what’s possible, but we should never mistake the leaderboard for the ultimate truth of software engineering.
Final Thoughts for the Performance Obsessed
If you’re building the next big thing, use Round 23 as a guide, not a gospel. Look at the high-performance web development techniques these winners are using—like non-blocking I/O, efficient serialization, and smart connection management—and apply them to your own code.
But for the love of all things holy, don’t rewrite your entire app in a framework just because it jumped ten spots in a JSON serialization test. That’s Wong Edan behavior, and believe me, you don’t want to be as crazy as I am. Stay fast, stay skeptical, and keep coding.
End of Report. Now, go optimize something—or go get some sleep. You look like you’ve been staring at top for too long.