HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
TechEmpower
FrameworkBenchmarks
C++2013–2026
TechEmpower / FrameworkBenchmarks · Archived

FrameworkBenchmarks

Source for the TechEmpower Framework Benchmarks project

143Distinct people
247Mentions
3Explicit recommenders
8.1KGitHub stars
REPOSITORY AT A GLANCE

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, 2:59:53 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.

02550751002013-01-01 00:00:00 UTC to 2014-01-01 00:00:00 UTC (exclusive): 106 mentions; 2 submissions, 104 comments20132014-01-01 00:00:00 UTC to 2015-01-01 00:00:00 UTC (exclusive): 20 mentions; 0 submissions, 20 comments2015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 8 mentions; 0 submissions, 8 comments2016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 8 mentions; 0 submissions, 8 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 4 mentions; 0 submissions, 4 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 9 mentions; 0 submissions, 9 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 10 mentions; 0 submissions, 10 comments20192020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 14 mentions; 0 submissions, 14 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 25 mentions; 0 submissions, 25 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 14 mentions; 0 submissions, 14 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 15 mentions; 0 submissions, 15 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 8 mentions; 1 submissions, 7 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 4 mentions; 2 submissions, 2 comments. Incomplete calendar period.2026*

* 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
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20132013-01-01 00:00:00 UTC2014-01-01 00:00:00 UTC1062104
20142014-01-01 00:00:00 UTC2015-01-01 00:00:00 UTC20020
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC808
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC808
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC404
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC909
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC10010
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC14014
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC25025
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC14014
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC15015
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC817
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC202
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC422

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 GitHub

What Hacker News says

25 sources
These discussions inevitably end up as a flame war sooner or later. Regardless, i actually compared Java with .NET and their web frameworks as a part of my bachelors', everything from synthetic benchmarks for encryption and data processing and transformations, to things like shuffling JSON around. Now, it's all in Latvian and was a number of years ago, so it's not entirely relevant at this point, but i did have some tangible findings. In short: - both Java and .NET (then Core) are inconsistent in their performance - there are certain things which are slower in one technology than other by not using external optimized libraries. For example, Java had problems with writing deeply nested dynamically generated JSON with JavaEE libraries (now Jakarta), whereas .NET Core had problems with handling large amounts of text - their performance w
Read the rest
as largely comparable in most other tests, neither was faster by a factor of 10, like you'd see with Python and Ruby compared to either - thus, it's largely a matter of choosing the actual frameworks that you'll want to utilize properly and consider both the job market and business factors (familiarity with the tech stack, job market etc.) - in summary, they're close enough for it to not be a technical decision most of the time in real world circumstances (save for a few exceptions), but rather is a decision that depends on social elements Since then: - i don't believe that the observation of them being "close enough" has changed much, both in legacy code and otherwise - .NET Core and now .NET 6 has improved bunches with its runtime; Core was so successful it's essentially the future of the platform (i feel bad for developers who'll be tricked into working on legacy code with the old .NET and IIS, versus the new one and Kestrel) - JDK has improved bunches with its runtime and GC; the runtime situation is a bit complicated and cumbersome, considering the OP's article, but overall it's pretty usable, especially with frameworks like Quarkus If you care about benchmarks and vaguely realistic performance comparisons in the current year, simply have a look at the TechEmpower benchmarks: https://www.techempower.com/benchmarks/#section=data-r20&hw=... If you jump around the different tabs that compare which frameworks do what better, on average: - .NET is better for plain text - .NET is noticeably better for data updates - Java is noticeably better for JSON serialization - Java is noticeably better for single DB queries - Java is noticeably better for multiple DB queries - as for cached queries and other use cases, there's more variance - neither is better than the other for it to matter a lot These are probably better than me linking the bachelors' because it's done in a better controlled environment, with more resources, and a lot of people contributing to the source code of the benchmarks: https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast... In short, you're not necessarily wrong - there have indeed been great improvements to the .NET platform and it's good to see it finally being a capable and performant tech stack that you can use on *nix. But you're also not right: Java is getting similar attention, even though it's still lagging behind a few years in regards to "having its stuff together" (e.g. going from Oracle JDK to a more stable model + the JDK 8 to newer version shift, which is similarly painful with old .NET versions). To lighten the mood, i'd consider suggesting that anyone also have a look at Go, which is similarly performant and allows you to build runtime independent executables by default, which is easier than in either .NET or Java. It's also pretty easy to write and has seen good use for the development of tools, since its startup time is a tad better than either that of Java or .NET as well. Here's the three compared: https://www.techempower.com/benchmarks/#section=data-r20&hw=...
In Which version of JDK should I use?
I had a discussion about benchmarks and how useful they are a few days ago: i remember mentioning TechEmpower in particular because of how close to typical real world usage of the libraries and ecosystems their benchmarks are! That said, Vert.X and some other of the frameworks aren't exactly idiomatic Java, because they're heavily focused on maximum performance - when i last checked them out, there were even async JDBC drivers in development, and while the performance was indeed stellar, it wasn't exactly production ready back then. Edit: well, the actual way it writes and reads isn't bad in of itself, but some might need some time to get adjusted to the concepts. Actually, i'd say that it reads a bit more like JS: https://vertx.io/docs/vertx-core/java/ Of course, things have probably improved, but perhaps it's also useful to compare some
Read the rest
of the full platform implementations and perhaps the most popular of each language's frameworks. Maybe even with ORMs, to also see how those technologies fare in reality, since i've personally seen some of the most widely used enterprise frameworks become pretty slow due to all of the abstraction that's going on, which perhaps is a deserved criticism for Java. So for most of the "boring & stable" projects, it could look a bit like the following: https://www.techempower.com/benchmarks/#section=data-r18&hw=... - Java, Spring: the most popular enterprise framework in my experience - Java, Dropwizard: a pretty good alternative to Spring that takes a number of the industry standard frameworks/libraries and integrates them (Quarkus not featured because while the MicroProfile compatibility would be useful to test, they actually have no tests with ORMs for now) - JavaScript, Express: still the most popular framework for back end development with Node - JavaScript, Node: sometimes i've seen people write servers directly as well, which is surprisingly far easier in Node than it is in Java (servlets and the abstractions around them can be unpleasant to work with) (Koa not featured because while it's gaining popularity, they actually have no tests with ORMs for now) With those particular frameworks, the scene changes a bit and both of them are far more similar in their performance. I'm not sure what the takeaway here would be: whether it's that Wirth's law (https://en.wikipedia.org/wiki/Wirth%27s_law) applies to libraries that try to cover all use cases, that Java just has some popular frameworks which underutilize its potential for performant code, or that you really should compare particular frameworks, paradigms and implementations, rather than just languages in general (since the overhead cannot be disregarded). Of course, these results also may not be representative of the stacks that other companies use or even those that are popular in other regions of the world, so i invite you all to check out those results for yourselves with the stacks that you're considering and maybe even browse the test source code: https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast...
In The Xterm Window Manager Homepage
In the case of the TechEmpower benchmarks, i'd argue that it's actually pretty much the same thing as real world applications: https://github.com/TechEmpower/FrameworkBenchmarks For example, look at a full platform Java Spring Boot example here: https://github.com/TechEmpower/FrameworkBenchmarks/tree/mast... The controller code, the model code and even the repository code are all very reflective of the primitives you'd find in production code. The only differences would be when you add additional complexity, such as validations and other code into the mix, such as additional service calls etc., but if even the simpler stuff in Python (as an example) would be noticeably slower, then it stands to reason that it wouldn't get magically faster on the basis of less overhead alone. The exceptions to this which i could imagine would be calls to n
Read the rest
ative code, since the aforementioned Python has an amazing number crunching or machine learning support, but that is hardly relevant to web development in most cases. Otherwise we risk running into the "No true Scotsman" fallacy: https://en.wikipedia.org/wiki/No_true_Scotsman In such a case, we'd adamantly claim that these benchmarks are simply not good enough even for educated guesses and we'd have to build out our full system to benchmark it, which no one actually has the resources for - in practice you'd develop a system and then would have to do a big rewrite, as was the case with PHP and Facebook, as well as many other companies. On the other hand, premature optimization and dogmatic beliefs are the opposite end of the spectrum: you don't need to write everything in Rust if using Ruby would get your small application out the door in a more reasonable amount of time. There are no easy answers, everything depends on the context (e.g. small web dev shop vs an enterprise platform to be used by millions) and the concerns (e.g. resource usage and server budget vs being the first to market, as well as developer knowledge of tech stacks, for example market conditions of PHP vs Rust). Regardless, in my eyes, there's definitely a lot of value in these attempts to compare idiomatic interpretations of common logic for web development primitives (serving network requests in a known set of formats).
In Faster Python with Guido van Rossum
> If you (or your company) are paying cloud fees for hosting your services (including serverless), you are absolutely throwing money away, perhaps for a "good" reason ('we have a huge rails codebase'), if you ignore this information. No one "throws away money" based on the Tech Empower benchmark. Because many of those optimizations are not free and, often, are not available. Such micro-optimizations are present in every program. This benchmark is just noise at this point and should be used as an argument against any framework/language. https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast...
In Why most programming language performance comparisons are most likely wrong
AaronFriel·Apr 11, 2021Recommendation phrase
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 numbering. Please don't mistake me for someone who just learned about Go or Rust and is evangelizing them because I think they're the cool new thing. Which of the Java implementations for the TechEmpower benchmarks use an ORM? Are they representative of the kind of code you would write? I think that the TechEmpower benchmarks suffer from many of the same problems the language benchmarks game benchmarks do - micro-optimization, unrealistic workloads. My experience tells me that you an get any sufficient level of performance in almost any language, but that you are going to pay for some languages more in opex than others, particularly in memory usage. It takes more compute
Read the rest
spend for a workload written in Java than one written in Go, all other things being equal. That's not to say Java is a bad language, but it does lack many features - some of them being intentional design decisions - which make it less cost effective to operate systems built on Java. However, we know that a significant cost is the cost to develop, so it's hard for me to say Java is a bad language for that reason either. And memory usage is generally a good predictor of density in terms of scheduling workloads, be it Tomcat servers (back in the day) or VMs or containers these days. I also think that Java suffers, performance wise, from boxing values and pointer chasing / poor cache locality. The default container implementations are just, well, it would be polite to simply say that they're as good as the language allows. However, data is better than claimed experience, no? I just opened up the raw benchmark stats[1] for the database updates route. It's one that my favorite languages don't do well in, but I was curious about the operational overhead of running them in memory usage, something I've mentioned quite a lot up above. I looked at a vertx-postgresql benchmark for the "updates" TechEmpower. This is a high performing implementation without an ORM[2] I also looked at quarkus + reactive routes + hibernate, which appears to use hibernate, applicable to the original post[3]. And lastly, I looked at actix diesel, another ORM using implementation[4]. java quarkus-hibernate: 3.9GiB memory (peak, start of test) java quarkus-hibernate: 3.1GiB memory (lowest value, near end of test) java vertx-postgres: 2.35GiB memory (consistent) rust actix-diesel: 1.2GiB memory Standard deviation was: java quarkus-hibernate: 221.4MiB java vertx-postgres: 1.9MiB rust actix-diesel: 0.5MiB I included the steady state for quarkus because its memory usage (perhaps due to a config flag starting it with a 4GiB heap?) started out extremely high and decreased over the course of the run. That likely affects the standard deviation, which I included to highlight that I didn't try to cherry-pick results. Perhaps the funniest thing to me digging into it is, again due to the absurdity of Java's design decisions, to make sure that "Integer" objects are efficient, the Java benchmarks use the command line parameter "-Djava.lang.Integer.IntegerCache.high=10000". This tells you that if the benchmark used a wider range of random values[5], performance would degrade. Have you ever heard of a language requiring an integer cache? It's absurd to me that Java, rather than implement value types, requires Integers to be interned for performance. Are there any other languages in the TechEmpower benchmark or the Debian benchmark game (formerly went by another name) that requires setting an "IntegerCache" to optimize... allocating integers? I mean, come on. You can't tell me this is a language that was designed for performance when integers can't be directly stored in arrays and instead have to be autoboxed and a cache is needed to intern them! I will say one final thing: cost to operate/memory efficiency is just one metric for measuring languages. I think that Java is actually a pretty bad language for a lot of reasons, but path dependence has produced an extremely rich ecosystem that gives developers a lot of flexibility and a lot of tools to use when writing it. I think Kotlin, Scala, and even Clojure are by far more pleasurable languages to write in, though the JVM still holds them back for all the reasons above. [1] Raw results from https://tfb-status.techempower.com/unzip/results.2021-01-13-... [2] You can see they have simply hardcoded the SQL. See: https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast... [3] https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast... [4] https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast... [5] The update benchmark only requires random numbers between 1 and 10,000. Performance of Java apps would degrade if they were asked to use boxed integers greater than 10,000, which is possibly the most absurd statement I have said of any programming language ever. See: https://github.com/TechEmpower/FrameworkBenchmarks/wiki/Proj...
In Problems with JPA/Hibernate
Looking techempower's benchmark code, specifically the "dbs" and "update" functions (which are weighted highly), I think there's some optimization that could be done, like using .values() and .update() in more places. https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast... Django ends up getting benchmarked against "uvicorn" which just uses raw sql, so yeah, of course raw sql is faster. Django has a raw sql option too, but they're not using it for the benchmark. https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast...
In Django 3.2 – News on compressed fixtures and fixtures compression
It needs to be emphasized how artificial these benchmarks really are. Here is the source for the Fortunes C# benchmark: https://github.com/TechEmpower/FrameworkBenchmarks/blob/mast... There's no routing or templating, it just writes a bunch of strings. No one would build an actual web app this way. The only C# benchmarks that are remotely realistic are the mvc variants, starting with aspcore-mvc-ado-pg at number 79.
In 12 requests per second: A realistic look at Python web frameworks

Showing the 15 most recent of 25 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.