Performance Comparison of JavaScript Chart Libraries in 2026

When doing a performance comparison of JavaScript Chart Libraries, we are often asked “which is the fastest JavaScript chart?“. Users coming to SciChart for the first time often spend time setting up a complex benchmark comparison app to see if SciChart can meet their needs. This is a time consuming process, and each benchmark will be different, so, we’ve taken the time to do this for you!

We want to demonstrate to you that we care about performance, and that SciChart.js has all the performance you need, even for the most demanding apps. We’ve built a benchmark application for comparing the rendering performance of multiple popular JavaScript Chart Libraries under extreme workloads. This includes the evaluation of a wide range of metrics, including FPS (Frames per second), time to first render (initialization time), memory usage, data ingestion rate (data-points per second) across a wide range of 2D and 3D chart series and features. 

Using our benchmark application, you can quickly evaluate the performance of SciChart.js vs. open source and commercial alternatives under very demanding conditions. The outcome is that you can make an informed choice when evaluating a chart library for your big-data, real-time data visualization projects. 

Here’s what we will discuss and present below: 

• A comprehensive open-source benchmark test suite for a thorough performance comparison of JavaScript Chart Libraries.
• Testing many chart types, including line charts, scatter charts, column charts, mountain/area, candlestick, heatmap, 3D surface, 3D point cloud.
• Measurement of metrics, including FPS (frames per second), time to first render, memory usage, number of frames rendered and data ingestion rate (datapoints per second).
• Our benchmark outputs JavaScript Chart Performance Test Results for several chart libraries including Chart.js, HighCharts, Plotly.js, LightningChart, Apache eCharts, uPlot and SciChart.js.
• A single Chart Bench score which ranks the performance of JavaScript chart libraries based on weighted sum of FPS, Memory usage, Time to first render and data ingestion rate.
• How you can reproduce or verify results on your hardware setup in order to evaluate the performance of SciChart.js vs. competing chart libraries.

In later blog posts in the series, we will also present test results on many hardware configurations from high-end workstations to low-powered or integrated graphics hardware. This will help you to make an informed choice on whether SciChart’s JavaScript Charts has the performance you need for demanding and complex applications. 

Part #1: The Open-Source JavaScript Chart Performance Test Suite

We’ve published an open-source JavaScript Chart Performance Test Suite at github.com/abtsoftware/javascript-chart-performance-test-suite.

This benchmark runs a number of tests on a variety of chart libraries and measures FPS, Time to first render (startup latency), Memory usage, Frame count, data ingestion rate (data-points per second) and monitors error conditions such as Hanging (timeouts or freezes), Exceptions, Low FPS warnings. 

The benchmark test suite can be run simply via npm start and manually driven. Alternatively, you can bulk run the tests using PlayWright npx playwright install, npm install, npm run test:headed, which stores the data as JSON, which can later be imported into the dashboard. 

Here’s a quick walkthrough:

The Chart Benchmark Homepage

When the chart benchmark starts up, you’ll be presented with a number of tables for each test case and blanks. Click ‘Run’ on any chart library / test case combo to run that test. This will open in a new tab, once it’s complete, close the tab and run the next test. At the time of writing, you’ll have to refresh the homepage to update the table. 

Note: Instructions how to bulk-run the tests using PlayWright can be found on GitHub.

Once you’ve populated some test case data, your home screen should look like this:

Some notes here:

• You can chose the result set: ‘Local’ means your local test data. Apple M1 / ARM Snapdragon / Intel i9 / nVidia RTX 4090 are pre-recorded result sets on various hardware. Try switching between the hardware (pre-recorded result sets) to test out how mid/low end GPU or different architectures (ARM, Apple M1, Intel) affect JavaScript Chart Performance.  
• You can import, or export result sets: Record a result set on one PC, then click ‘Export Selected’. This will download a JSON file that can be shared, or imported on another PC. 
• You can choose which libraries you want to compare: By default all are checked.
• You can choose which metric you are analyzing: Average FPS, Memory (MB), Init Time (ms), Total Frames or Ingestion Rate (pts/sec).

For each test case:

• Table cell values: Are reported as your metric, e.g. Average FPS for the test case / chart library combination. 
• The table cell color: Is a heatmap from best (green) to worst (red).
• Error conditions: Such as ‘HANGING’ / ‘SKIPPED’ are reported in the table:
  • If a test is marked as ‘HANGING’ this means that the chart library didn’t complete the test in the allotted time. Further tests are skipped.
  • If a single test drops below 1 FPS, that’s considered a low FPS warning and further tests are skipped.
• Best/Fastest column: Notes the Best (lowest memory) or Fastest (highest FPS, lowest init time, highest data-ingestion rate) in that test-case / parameter combination. 
• Chart Bench: Is a custom algorithm that computes a score for the chart library based on this test (see more details below).
• Fastest Wins: Which library scored the most wins for this test-case.

Switching between Metrics

FPS only tells part of the story. For an overall holistic view of JavaScript Chart performance we’ve included logging of not only frames per second, but also memory usage, initialization time (time to first render), total frames rendered, and ingestion rate (datapoints per second). 

On the homepage, you can switch between metrics to view how each chart library performed as follows:

The Chart Benchmark Test Page

When you start the application, your Local result set scores tables will be empty. You’ll need to click ‘Run’ on any of the chart library / test combinations to open a test page. After that has run, close the tab and refresh the homepage.

Clicking ‘Run’ on any specific test will bring up the test page which looks like this:

The test page runs for several seconds, with logarithmically increasing difficulty (more data points, more series, more charts). At the end of the test, the chart library is deleted (if supported) and memory is freed.

On the right we have some system information, immediate stats and an FPS counter where you can see frame drops. On this machine I have a UHD monitor with 240 FPS, so you can see this 3D chart test running almost clamped at 240 FPS throughout! 

Note: After each test run, close the chart test page before running another test. The homepage will automatically update. Repeat with as many tests as you wish to populate the Local Result set table with data. 

The Chart Benchmark Charts View Page

The benchmark test suite also includes a Charts View. Click the Charts View button at the top of the page to switch to this:

Here you will see FPS Scores and Chart Bench scores plotted for each individual test-case, with results ranked by the highest benchmark number. 

Switching between the metrics will help explain the Chart Bench score. For example, a library that performs with high FPS may have high initialization time, or higher memory, or lower data ingestion rate. The benchmark score takes into account all this to provide an overall score (more on this below). 

What Chart Libraries are Tested in the Benchmark?

At the time of writing, we’ve included the following chart libraries in the test suite. 

• Plotly.js, an SVG and WebGL powered JS chart with WebGL module enabled
• HighCharts, SVG powered JS charts with Boost WebGL module enabled
• Chart.js, an open-source library based on HTML5 Canvas
• Apache eCharts, an open-source library based on HTML5 with WebGL acceleration for 3D charts
• uPlot, a lightweight open-source library based on HTML5 canvas
• ChartGPU, a relative newcomer in the open-source space rendering charts using WebGPU with no WebGL fallback
• SciChart.js, our WebGL and WebAssembly powered chart library
• LightningChart.js v4.2.2 and v8.2.0 (LCJS), a competing WebGL enabled chart library*

We put them head to head in a demanding performance test that stress your CPU and GPU to the max to find out the limits of these libraries. You’ll see how well they perform and their respective stats (FPS, memory usage, initialization time, data ingestion rate) on a variety of hardware. 

* LightningChart.js (LCJS) v4.2.2 was included, as well as LightningChart v8.2.0, as v4.x is the latest version which has a community license and does not require a downloadable trial key. The latest version (v8) requires a license key to run the tests. 

What Test Cases are Carried Out in the Benchmark?

At the time of writing, the JavaScript Chart Performance Test Suite carries out 13 tests across each of the JavaScript Chart Libraries, each with several sub test-cases. The benchmark aims to test a variety of operations including line charts, scatter charts, column or bar charts, candlestick charts, multi-chart cases, 2D heatmaps as well as 3D charts (surface mesh/plot, 3D point cloud).

Below you will find a list and brief description of the test cases carried out:

3D Surface Mesh Test

Big Data Line Series Test

3D Point Cloud Test

Xy Scatter Test

Xy Line Test

Multi Chart Test

Mountain Series Test

Heatmap 2D Test

ECG/FIFO Lines Test

Many Series Tests

Point-Line Test

Candlestick Test

Column Series Test

• 3D Surface Mesh Performance Test: Varies a uniform (NxM) surface mesh in real-time and measures performance (FPS), memory and data update rate. 
• Big Data Line Series Test: A real-time test where data is appended to a line chart as fast as you can. Data is a random walk, and appended in blocks of up to 1 million points per timer-tick. This tests the chart’s ability to ingest and render millions of data-points per second. This shows the data ingestion rate (millions of points per second) of each chart library as well as maximum memory usage and rendering speed of the chart.
• 3D Point Cloud Test: Varies a randomized XYZ dataset in real-time, replacing the entire dataset each timer tick and measuring performance (FPS), memory and data update rate. 
• Xy Scatter Chart Test: Single chart, single series test with a randomized, Xy dataset rendered by scatter points. Starting at 1000 datapoints, the point-count is incrementally updated to 10000, 50000, 100000, 200000, 500000 all the way up to 10 million data-points. The entire dataset is updated in real-time and the chart render speed, memory and frame count is measured.
• Xy Line Series Test: Single chart, single series test with a randomized, Xy dataset rendered by line points. Starting at 1000 datapoints, the point-count is incrementally updated to 10000, 50000, 100000, 200000, 500000 all the way up to 10 million data-points. The dataset is updated in real-time and the chart render speed, memory and frame count is measured.
• Multi Chart Test: Starts with a single chart with real-time data, then 2 charts, 4, 8, 16, all the way up to 128.
• Mountain/Area Series Test: Mountain or area charts with static data, where the chart is programmatically zoomed. Tests the performance of the chart to render area polygons which can be surprisingly sub-optimal in some JS chart libraries.
• Heatmap 2D Test: A Heatmap Chart renders a 2D uniform array of data with double precision values and maps these to a color map. The dataset is updated entirely every timer-tick and chart performance measured on redraw. 
• ECG/FIFO Scrolling Lines Test: A single chart is loaded with 5 series, each with a fixed number of data-points. New data is appended in real-time and the chart scrolled in a ‘First in first out’ or ECG style. Test cases get incrementally harder starting off at hundreds of data-points per second and ramping up to tens of millions of data-points per second ingested.
• N Series x M Points Test: Multi-line test case for Monte Carlo simulation style charts. Starting with 100 line series x 100 data-points per series, the test is incrementally updated to 200×200, 500×500, 1000×1000, 2000×2000, 4000×4000 and 8000×8000.
• Point-Line Series Test: Real-time updating series where the entire dataset is updated, and the chart must render lines and scatter points at the same time.
• Candlestick Series Test: This test case stresses the rendering performance of candlestick charts, an often overlooked chart type in high performance financial visualization, but one that is critical in financial applications, quantitative trading and HFT applications.
• Column Series Test: Stresses the rendering performance of column or bar charts, an often overlooked chart type in high performance visualization, but one that is critical in dashboards and complex applications.

What Test Data is Recorded by the Benchmark Suite?

In our benchmark test suite, we test each chart library and compare the output. Each individual test case reports:

• The Chart Library name and test case name
• A min/max/average FPS (frames per second) – higher is better
• The individual frame times (milliseconds) – lower is better
• Frame count (total number of frames rendered) – higher is better
• Memory usage (estimated by a single call to performance.memory.usedJSHeapSize at the end of the test. This is only available in Chrome) – lower is better
• Time to first render (initialization time, milliseconds) – lower is better
• Data ingestion rate (datapoints per second) – higher is better
• Error conditions such as Hanging/Freezes, Low FPS warnings, Exceptions – errors are considered as test failure conditions

All of this data is logged to IndexedDB locally and displays on the homepage of the benchmark app. 

Individual test cases report more data such as system information, CPU/GPU stats, immediate FPS, frame count, library initialization time, time to first render, memory consumption and chart data-points. Aggregated results just report the average FPS. 

What Is the Chart Bench Score & How Is this Calculated?

FPS doesn’t tell the whole story. What if your chart library renders at 60 FPS but takes 10 seconds to initialize? Or, what if two chart libraries both render at the same speed, but one uses more memory than the other? How does the data ingestion rate play into the overall performance of the chart library?

To compute an overall score, or Chart Bench, we do the following composite calculation:

Chart Bench Benchmark Score Calculation:

Score = Σ(composite × weight) / Σ(weight)
Composite = (FPS×65% + InitTime×20% + Frames×10% + Memory×5%) × 100

Metrics use power transformation to amplify performance differences:

• FPS^1.5: Exponentially rewards higher FPS (42 vs 4.77 FPS → 272 vs 10.4 = 26x scoring difference)
• Frames^1.5: Higher frame counts exponentially better
• Init Time: Linear scale (lower is better)
• Memory: Linear scale (lower is better)
• Weight = [log₁₀(points × series × charts)]^3.5

Aggressive polynomial weighting ensures complex tests contribute exponentially more (16M points >> 1K points).

Failed/skipped tests receive 0 score but full weight penalty.

We then report both FPS numbers and Chart Bench results in the test-suite.

Part #2: JavaScript Chart Performance Comparison

In the next series of blogs which we will be publishing soon, we’ll present results of SciChart.js vs. a variety of competitors on multiple different hardware setups. 

We’ve carried out the tests internally on different hardware, in order to show the effect of different CPU/GPU setups, and conclude that SciChart.js has all the performance you need for demanding scientific, medical, IoT, industrial or telemetry apps, regardless of your target hardware. 

Here’s a quick rundown of the test setup and hardware:

What Test Hardware was Used?

Some libraries perform all their calculations on the CPU, while others use the GPU or other techniques. SciChart, for instance, uses a load-balanced approach to CPU/GPU scheduling.

Which is the fastest when there is a low-powered hardware, single-board computer or integrated graphics? What are the limits of performance of JavaScript Charts on integrated graphics?

Not all workstations or IoT / embedded or medical devices have access to the fastest possible GPU, so in these test cases, we validate performance on the following machines:

Watch this space for the test results. Until then, you can download Chart Bench from GitHub and try running some JavaScript Chart Performance tests!

What Results Did We Get from the Tests?

We’ll be publishing full test results soon for a variety of hardware test setups, but for now, here are some key takeaways:

• SciChart.js scored the highest FPS in approximately ~70% of test cases vs. all competitors on Intel Windows PCs and ARM Snapdragon.
• SciChart.js data ingestion rates peak at about ~40,000,000 (40 million) data-points per second on Intel Windows PCs, Apple M1 hardware and ARM Snapdragon.
• SciChart.js performance is not significantly degraded by hardware, e.g. even on integrated GPUs (ARM Snapdragon, Apple M1) you still can see millions of data-points rendered at interactive framerates. 
• SciChart.js particularly excels at data-ingestion rate, time-to-first-frame (init time) and memory usage in the most demanding test cases.

Download Chart Bench & Test for Yourself

Which chart library you should choose depends on your specific platform needs, workloads and developer workflow preferences. This blog post and associated Git repo is designed to be informative, to help the evaluation process should you be deciding on a chart library to use.

Every project has different performance requirements, datasets and development constraints. If evaluating SciChart or comparing against open source or commercial competitors, and if performance is a requirement, we encourage you to clone the repo and try out the tests. Any question, comments or feedback, do get in touch with tech support and we’ll be glad to help!

Clone Chart Bench now on GitHub: github.com/abtsoftware/javascript-chart-performance-test-suite