js-framework-benchmark

js-framework-benchmark This is a simple benchmark for several javascript frameworks. The benchmarks creates a large table with randomized entries and measures the time for various operations including rendering duration. Security advice Currently there are 186 implementations in this repository. It's of course impossible for me to make a security assessment for all those implementations. npm ci and npm install can execute arbitraty commands, so they should be executed only for packages you trust. Consequently I build on a dedicated virtual private linux server such that I don't have to install the packages for all those implemenations on my laptop. There's a prebuild build.zip for each chrome release you can download such that you can avoid installing the packages from all implementations. (I don't know of any (attempted) case for malicious packages in this repository, so please take it just as a general warning.) The server implementation in this repository should only be started on your local machine and access should be restricted to your local machine. I recommend against starting the server such that it can be publically accessed from the internet. About the benchmarks The following operations are benchmarked for each framework: create rows: Duration for creating 1,000 rows after the page loaded (no warmup). replace all rows: Duration for replacing all 1,000 rows of the table (with 5 warmup iterations). partial update: Time to update the text of every 10th row for a table with 10,000 rows (with 5 warmup iterations). select row: Duration to highlight a row in response to a click on the row. (with 5 warmup iterations). swap rows: Time to swap 2 rows on a table with 1,000 rows. (with 5 warmup iterations). remove row: Duration to remove a row for a table with 1,000 rows. (with 5 warmup iterations). create many rows: Duration to create 10,000 rows (no warmup) append rows to large table: Duration for adding 1,000 rows on a table of 10,000 rows (no warmup). clear rows: Duration to clear the table filled with 10,000 rows. (no warmup) ready memory: Memory usage after page load. run memory: Memory usage after adding 1,000 rows. update memory: Memory usage after clicking 5 times update for a table with 1,000 rows. replace memory: Memory usage after clicking 5 times create 1,000 rows. repeated clear memory: Memory usage after creating and clearing 1,000 rows for 5 times. update memory: Memory usage after clicking 5 times update for a table with 1,000 rows. startup time: Duration for loading and parsing the javascript code and rendering the page. consistently interactive: The lighthouse metric TimeToConsistentlyInteractive: A pessimistic TTI - when the CPU and network are both definitely very idle. (no more CPU tasks over 50ms) script bootup time: The lighthouse metric ScriptBootUpTtime: The total ms required to parse/compile/evaluate all the page's scripts main thread work cost: The lighthouse metric MainThreadWorkCost: Total amount of time spent doing work on the main thread includes style/layout/etc. total byte weight: The lighthouse metric TotalByteWeight: Network transfer cost (post-compression) of all the resources loaded into the page. For all benchmarks the duration is measured including rendering time. You can read some details on this article and in the wiki. Starting with chrome 118 the overall performance is computed as a weighted geometric mean. Official results Official results are posted on the official results page. To work on the results website, see website development and publishing. My blog has a few articles about the benchmark. Older results of this benchmark are outlined on my blog (round 1, round 2, round 3, round 4, round 5, round 6, round 7 and round 8). Snapshot of the results The current snapshot that may not have the same quality (i.e. results might be for mixed browser versions, number of runs per benchmark may vary) can be seen here Keyed vs non-keyed frameworks Some frameworks like React, Vue.js or Angular, allow you to create a 1:1 relationship between a data item and a DOM node by assigning a “key” attribute (or for Angular, specifying “trackBy” in *ngFor). If you use some identifier of the data as the key, you get the “keyed” mode. Any update to the data will update the associated DOM node. If you reorder the list, the DOM nodes will be reordered accordingly. The other mode is “non-keyed” and this is what e.g. vue.js uses by default for lists. In this mode, a change to the data items can modify DOM nodes that were associated with other data before. This can be more performant, since costly DOM operations can be avoided (e.g. first removing old nodes and then adding new nodes) and the existing DOM nodes are updated to display the new data. For React and Angular, using the item index as the key uses “non-keyed” mode for those frameworks. Depending on your requirements, the “non-keyed” mode can be a performance gain or can cause severe problems, so one must carefully choose the mode and check that the framework supports that mode. Read more here: https://www.stefankrause.net/wp/?p=342 1 Run pre-built binaries for all frameworks There are currently 186 implementations in this repository. Installing (and maintaining) those can be challenging, but here are simplified instructions how to get started. See the security advice above to read why that might be a good idea. 1.1 Prerequisites Have node.js (>=v20.9.0) installed. If you want to do yourself a favour use nvm for that. The benchmark has been tested with node v20.9.0. Please make sure that the following command work before trying to build: > npm npm -version 10.1.0 > node --version v20.9.0 1.2 Downloading the pre-built binaries and starting the server building all frameworks can be challenging. There's a new way that allows to skip that and just run the benchmark without building all implementations. Start with checking out a tagged release like that. Pick the release that you want (e.g. chrome 100): git clon