All depends on context.
One could say that:
In the "fortunes" category, the giraffe F# benchmark, which is a single 150 line file used 100% as advertised in the documentation performs better than many java frameworks, some CPP frameworks, etc: https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast...
However, that's not accurate. It's an incomplete take based on a fragment of the data. It's a matter of data presentation and sympathy/empathy with your audience (IMHO).
In How fast is ASP.NET Core?TechEmpower
FrameworkBenchmarks
C++2013–2026
TechEmpower / FrameworkBenchmarks · Archived
FrameworkBenchmarks
Source for the TechEmpower Framework Benchmarks project
143Distinct people
247Mentions
3Explicit recommenders
8.1KGitHub stars
What to know before exploring
What it is
Source for the TechEmpower Framework Benchmarks project
GitHub
Where it is used
- ASP.NET Core — ASP.NET Core used the TechEmpower Framework Benchmarks as a focus for performance work. Microsoft prioritized improving ASP.NET’s performance in these benchmarks. Source
- Benchmarks for ASP.NET Core — Benchmarks for ASP.NET Core includes scenarios from the TechEmpower Web Framework Benchmarks in its benchmarking suite. Source
What people are saying
Sorry, I should have been more precise. I am very, very familiar with the TechEmpower benchmarks and I first learned Java around SE 5, right after they switched from 1.x…
AaronFriel used a recommendation phrase. 3 indexed comments match. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 3:30:57 AM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year247 dated mentions
Observed mentions: 2013-03-28 15:05:31 UTC to 2026-03-24 12:37:38 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 106 | 2 | 104 |
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 20 | 0 | 20 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 8 | 0 | 8 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 8 | 0 | 8 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 9 | 0 | 9 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 10 | 0 | 10 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 14 | 0 | 14 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 25 | 0 | 25 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 14 | 0 | 14 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 15 | 0 | 15 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 8 | 1 | 7 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 4 | 2 | 2 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
Welcome to TechEmpower Framework Benchmarks (TFB)
If you're new to the project, welcome! Please feel free to ask questions here. We encourage new frameworks and contributors to ask questions. We're here to help!
This project provides representative performance measures across a wide field of web application frameworks. With much help from the community, coverage is quite broad and we are happy to broaden it further with contributions. The project presently includes frameworks on many languages including Go, Python, Java, Ruby, PHP, C#, F#,Clojure, Groovy, Dart, JavaScript, Erlang, Haskell, Scala, Perl, Lua, C, and others. The current tests exercise plaintext responses, JSON serialization, database reads and writes via the object-relational mapper (ORM), collections, sorting, server-side templates, and XSS counter-measures. Future tests will exercise other components and greater computation.
Read more and see the results of our tests on cloud and physical hardware. For descriptions of the test types that we run, see the
test requirements section.
If you find yourself in a directory or file that you're not sure what the purpose is, checkout our file structure in our documentation, which will briefly explain the use of relevant directories and files.
Quick Start Guide
To get started developing you'll need to install docker or see our Quick Start Guide using vagrant
Clone TFB.
$ git clone https://github.com/TechEmpower/FrameworkBenchmarks.git
Change directories
$ cd FrameworkBenchmarks
Run a test.
$ ./tfb --mode verify --test gemini
Explanation of the ./tfb script
The run script is pretty wordy, but each and every flag is required. If you are using windows, either adapt the docker command at the end of the ./tfb shell script (replacing ${SCRIPT_ROOT} with /c/path/to/FrameworkBenchmarks), or use vagrant.
The command looks like this: docker run -it --rm --network tfb -v /var/run/docker.sock:/var/run/docker.sock -v [FWROOT]:/FrameworkBenchmarks techempower/tfb [ARGS]
-it tells docker to run this in 'interactive' mode and simulate a TTY, so that ctrl+c is propagated.
--rm tells docker to remove the container as soon as the toolset finishes running, meaning there aren't hundreds of stopped containers lying around.
--network=tfb tells the container to join the 'tfb' Docker virtual network
The first -v specifies which Docker socket path to mount as a volume in the running container. This allows docker commands run inside this container to use the host container's docker to create/run/stop/remove containers.
The second -v mounts the FrameworkBenchmarks source directory as a volume to share with the container so that rebuilding the toolset image is unnecessary and any changes you make on the host system are available in the running toolset container.
techempower/tfb is the name of toolset container to run
A note on Windows
Docker expects Linux-style paths. If you cloned on your C:\ drive, then [ABS PATH TO THIS DIR] would be /c/FrameworkBenchmarks.
Docker for Windows understands /var/run/docker.sock even though that is not a valid path on Windows, but only when using Linux containers (it doesn't work with Windows containers and LCOW). Docker Toolbox may not understand /var/run/docker.sock, even when using Linux containers - use at your own risk.
Quick Start Guide (Vagrant)
Get started developing quickly by utilizing vagrant with TFB. Git,
Virtualbox and vagrant are
required.
Clone TFB.
$ git clone https://github.com/TechEmpower/FrameworkBenchmarks.git
Change directories
$ cd FrameworkBenchmarks/deployment/vagrant
Build the vagrant virtual machine
$ vagrant up
Run a test
$ vagrant ssh
$ tfb --mode verify --test gemini
Add a New Test
Either on your computer, or once you open an SSH connection to your vagrant box, start the new test initialization wizard.
vagrant@TFB-all:~/FrameworkBenchmarks$ ./tfb --new
This will walk you through the entire process of creating a new test to include in the suite.
Resources
Official Documentation
Our official documentation can be found in the wiki.
If you find any errors or areas for improvement within the docs, feel free to open an issue in this repo.
Live Results
Results of continuous benchmarking runs are available in real time here.
Data Visualization
If you have a results.json file that you would like to visualize, you can do that here. You can also attach a runid parameter to that url where runid is a run listed on tfb-status like so: https://www.techempower.com/benchmarks/#section=test&runid=fd07b64e-47ce-411e-8b9b-b13368e988c6.
If you want to visualize them or compare different results files on bash, here is an unofficial plaintext results parser
Contributing
The community has consistently helped in making these tests better, and we welcome any and all changes. Reviewing our contribution practices and guidelines will help to keep us all on the same page. The contribution guide can be found in the TFB documentation.
Join in the conversation in the Discussions tab, on Twitter, or chat with us on Freenode at #techempower-fwbm.
Read the full README on GitHubWhat Hacker News says
14 sourcesFWIW I asked a similar question in the discussion section of the repo, specifically since there is a column in the output to help with this sort of sorting (Implementation Type) and received an answer: https://github.com/TechEmpower/FrameworkBenchmarks/discussio...
The issue here seems to be of data-display and intent of information.
From what David Fowler has to say: https://twitter.com/spetzu/status/1592255871199096833, it does seem as though the engineering portion are using the benchmarks in an expected way. Multiple implementations to see "what perf impact is there to removing X part of the code" piece-by-piece.
The benchmarks display is a comparative-between-frameworks visualization. For that to be realistic, the types of implementations would need to be the same (hence my questioning the "Implementation Approach" column). Instead,
Read the rest
you can find various quotes online of people comparing frameworks based on the techempower scores (usually just the fortunes or plaintext), which is disingenuous at best.
I think that a more varied and utilized implementation-approach column could help alleviate this aspect of it.
The other valuable data that doesn't have the best UX for access is: how is the a single framework-test doing over time? You can head to tfb-status and download the data for each run, but then you'll need to correlate commit-ids with your own changes to build a chart.
Either way I can say that I do like the idea of the benchmarks and I've learned some interesting things diving into some of the more stripped framework/implementations found within.
While I agree with your general point (yes a Ruby web app once basic database access patterns have been optimized is essentially CPU/GVL bound), I'd advise caution when using things like techempower benchmarks of the benchmark game.
Different languages receive very different levels of care in these, and from memory there was some big no-nos in the Rails benchmark.
One I remember for instance is that they use redis as a cache but without a connection pool [0], and AFAICT they run puma with at least 5 threads [1], so they are very likely to content on that one Redis connection.
That's just one of the many things I spotted when I looked at it a few months back.
[0] https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast...
[1] https://github.com/TechEmpower/FrameworkBenchmarks/blob/5429...
Edit:
To add to my point, you linked to the "20
Read the rest
queries" benchmark, which is essentially:
render json: 20.times.map { |i| World.find(i) }
Somehow this average 260ms latency while the single query version average 8ms, so something definitely don't add up, since worst case scenario it would be 20x slower so ~160ms.
Another evidence is that the "cached" version is also 260ms.
And this is a dummy app barely doing anything, I've seen apps doing a ton more work in much less time.
Looks like Javascript to me
https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast...
In Deno vs. Bun performance is riggedI was hesitant as to how much I should go into this because you get into the semantics of the benchmark but this [0] thread goes into why - that particular implementation doesn't behave the same way as the other implementations, it uses a different db driver that doesn't synchronise, which won't be allowed in the next version of the benchmarks. Techempower publish regular snapshots of their benchmarks at [1], and if you look at any of the snapshots that aren't the last published set where the discrepancy was fixed you'll see that all of the js implementations lag far far behind.
[0] https://github.com/TechEmpower/FrameworkBenchmarks/issues/72...
[1] https://tfb-status.techempower.com/
In Deno vs. Bun performance is riggedWould you call TechEmpower benchmarks synthetic? I think they're a pretty useful data source and indeed support the claim that the performance of .NET is rather good.
https://www.techempower.com/benchmarks/#section=data-r21
Personally I think that some of their tests are pretty close to what web applications might actually do a lot of the time (fetching the data, processing it, saving it), for example, see here: https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast...
Sure, sometimes the code you see in benchmarks can be a bit more clever than the code you'd see normally, but for the most part TechEmpower seems close enough to be a vague indicator towards what frameworks/languages/stacks have decent performance.
It also helps you get a feel for how big the differences are between any two given platforms, like using something like J
Read the rest
ava + Spring and Python + Django, which may or may not be relevant in actual business conditions, since you might also want to iterate quickly.
you might want to check it out again! the latest code is more mature and hopefully easier to use. it is though very much designed to be a lower level SDK rather than an all-singing/dancing higher level platform like node.js or deno.
also, your assertion re. C is incorrect - the C/C++ is mostly boilerplate and wrappers around C libraries and syscalls. postgres driver and http framework completely written in JS. still lots of work to do and you are right it is not "usable" in sense of it having little to no development resources right now but i find it very useful for building many things personally.
JS on V8 is very very fast.
round 21 code
https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast...
postgres driver
https://github.com/just-js/libs/blob/main/pg/pg.js
In TechEmpower Web Framework Benchmarks: Round 21These are web frameworks specifically but a good broad suite of examples: https://www.techempower.com/benchmarks/#section=data-r21&l=z...
An amazingly fast specialized JS runtime solution [1][2] does indeed have the #1 spot on the most recent rounds, but full PHP frameworks hold spots #2 - 29 and then it's a mixture of PHP and JS all the way to #58 before we see the first other language (python, uvicorn) emerge.
[1] https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast...
[2] https://github.com/just-js
In I still love PHP and JavaScriptIf you look at the techempower submission source code you'll quickly see why: https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast....
In Is Rust Web Yet?I honestly don't know. It could be a consequence of the way the test is set up, or how the total score is calculated, or maybe the code was optimized better than other frameworks were.
You read see the source of the tests here: https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast...
The SQL code seems quite optimized (manually compiling database packets instead of using a library). Most code seems quite static and very small, so it's probably very quick. I don't think you can actually use the framework like that in practice, though.
In Is Rust Web Yet?That did happen.
The downvotes are likely because it's 20 years later and TechEmpower benchmarks are neutral and open-source: https://github.com/TechEmpower/FrameworkBenchmarks
In .NET Myths DispelledThe most comprehensive benchmarks to track are the TechEmpower benchmarks as they are open source so you can see what each framework is doing: https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast...
The benchmarks model simple, but real world scenarios. It has breakdowns by EF, Dapper (the StackOverflow "micro-ORM"), MySQL, PG, and raw ADO.NET.
It should be noted that EF and EF Core are not the same thing; EF Core is more or less a full rewrite: https://docs.microsoft.com/en-us/ef/efcore-and-ef6/
Recent benchmarks have EF Core catching up to Dapper. You can read more about Microsoft's focus on performance for EF Core here: https://devblogs.microsoft.com/dotnet/announcing-entity-fram...
In .NET Myths DispelledTechEmpower appears[0] to be using Laravel 8.70, which was released about 3 months ago. Much less than 7 years ago.
The numbers there don't paint an encouraging picture either, but I'm happy to concede that performance isn't everything... it just doesn't matter for some applications. But, numbers like these are pretty appalling to me. (And yes, I feel the same way about Rails.)
[0]: https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast...
In Laravel 9Are you familiar with https://github.com/TechEmpower/FrameworkBenchmarks ?
It's not tutorial-style, but it does contain hundreds of sample web apps (that all do the same thing, but still)
In Ask HN: Who wants to collaborate?