Hi, I’m Kayla. I make charts for a living. And for fun. I know, that’s a little nerdy. But I like when data moves smooth, and the page doesn’t hiccup. If you want the blow-by-blow numbers, my extended benchmark write-up lives here.
This past month I tested a bunch of chart libraries. I wanted speed. Smooth zoom. No weird stutter when I pan. I focused on the heavyweight contenders—the so-called “big” JavaScript chart tools—which I also covered in a separate post here.
Some tools surprised me. Some… didn’t. If you’re shopping for a broader roundup of popular libraries, you might like the notes I kept here. For an even deeper, third-party look at the landscape, check out this comprehensive comparison of JavaScript charting libraries, detailing features, performance, and use cases.
Let me explain. By the way, I dug through a bunch of white-papers on rendering pipelines at EJSChart and they shaped some of the test ideas you’ll see below.
My setup (so you know I’m not guessing)
- Laptop 1: MacBook Pro (M1 Pro), 16GB RAM, Chrome.
- Laptop 2: ThinkPad T14, 32GB RAM, Edge.
- Screen: 60 Hz. Nothing fancy.
I ran each chart on both. I watched frame rate using Chrome’s perf tools. Mostly, I looked at feel. Does it drag? Does my fan spin? Does the UI freeze when I zoom?
What I charted (real stuff, not just fake lines)
- 1,000,000 points of sensor-style data (sine wave with noise).
- 120,000 minute stock prices (two years, one symbol).
- 5,000 bars for sales by SKU (gross, but it happens).
- A small dashboard with 6 charts live at once.
You know what? Big line charts are where most tools break a sweat.
Chart.js — friendly face, okay speed
I like Chart.js for small to mid charts. It feels cozy. The docs are clear. I used it in a school dashboard last spring.
- With 120k points, the decimation plugin helped. Use “decimation: enabled, algorithm: lttb” and “parsing: false.”
- Panning was okay. Zoom was a bit choppy. I got maybe 25–35 fps when moving fast.
- With a million points, it crawled or froze. Decimation still helped, but it wasn’t happy.
Quirk: clicking legend items with lots of data can lag.
Verdict: great for most apps, not my pick for huge streams. For more on how other open-source chart packages stacked up, check out my dedicated comparison here.
Apache ECharts — fast and pretty, with tricks that matter
ECharts surprised me. It looks good right out of the box. The “large” mode and “progressive” settings saved the day.
What worked:
- Line series with “showSymbol: false.”
- “sampling: lttb,” “large: true,” and “progressive: 4000.”
- Tooltips stayed usable up to 200k points.
Feel:
- 120k points: smooth pan and zoom, around 45–50 fps.
- 1M points: usable with the settings above, about 15–20 fps, and it didn’t freeze.
Quirk: I saw a tiny tooltip flicker once under heavy load. Not a dealbreaker.
Verdict: fast, stylish, and easier than rolling your own.
uPlot — silly fast for time series
If I only need line charts, uPlot is a rocket. It’s tiny and uses canvas. Not flashy, but wow.
- 120k points: 55–60 fps while panning hard.
- 1M points: stayed interactive, around 18–22 fps.
- Memory stayed calm. Typed arrays help here.
It doesn’t come with every widget. You might add your own legend or date controls. But the core is quick and clean.
Verdict: my go-to for big time series when I want speed and I don’t need fancy shapes.
LightningChart JS — the speed champ (but bring your wallet)
This one is commercial. WebGL all the way. I used it for a short-term IoT demo with a gnarly stream.
- 120k points: very smooth at 60 fps.
- 1M points: still smooth, and zoom felt crisp.
- Multiple charts on one page? It held up best of all.
It’s pricey, and licensing is a bit of a process. But if you need real-time charts with zero drama, this is the tank.
Verdict: best raw speed I saw. Great for trading, sensors, or labs.
D3 + Canvas — fast if you build it right
I love D3 for control. But SVG slows with big data. I switched to canvas for the draw calls.
- With canvas, 120k points ran smooth, about 50–60 fps.
- With 1M, I got 12–18 fps, and it stayed stable.
- You do more work yourself. Axes. Zoom. Hit tests. All on you.
Tip: render lines on canvas, but keep axes and UI in DOM. It feels neat and still runs fast. If you want a deeper dive into my D3 canvas workflow, the full breakdown is here.
Verdict: great if you need custom rules or weird scales, and you don’t mind elbow grease.
Plotly.js — rich features, slower with huge data
Plotly is easy to explore with. You click, you get info. 3D. Stats. It’s loaded.
- Up to ~50k points, it’s fine.
- At 120k, panning dropped to about 8–15 fps.
- With 1M, the tab groaned or locked up.
For dashboards with modest sizes, it shines. For giant series, not so much. I also spent time with Google Charts; spoiler: it’s fine for small dashboards but struggled in the same places—full notes here.
Verdict: choose it for features and quick wins, not for monster sets.
Recharts (React) — nice dev flow, not a big-data tool
I used Recharts in a React app for a sales team. It’s smooth for small stuff.
- 5,000 bars? It worked, but hover felt laggy.
- 120k points: panning was 2–5 fps. Not fun.
- It’s SVG-based. That’s the limit.
Verdict: comfy for business charts, not made for heavy loads.
How they stacked up for me
These numbers mirror the condensed “7-library shoot-out” I published here.
Big line chart, 120k points (panning/zooming feel):
- LightningChart JS: smooth 60 fps
- uPlot: 55–60 fps
- ECharts (progressive/large/sampling): 45–50 fps
- D3 + Canvas: 50–60 fps
- Chart.js (decimation): 25–35 fps
- Plotly: 8–15 fps
- Recharts: 2–5 fps
At 1,000,000 points:
- LightningChart JS: ~45–60 fps
- uPlot: ~18–22 fps
- ECharts (large+progressive): ~15–20 fps
- D3 + Canvas: ~12–18 fps
- Chart.js: ~1–3 fps or freeze
- Plotly: often unresponsive
- Recharts: nope
Note: frame rates vary with your hardware and what else is on the page.
If you care about raw numbers and methodology, there’s also an in-depth analysis of high-performance JavaScript chart libraries, including benchmarks and performance tests that’s worth a read.
Bugs and quirks I hit
- Chart.js: legend toggles hang with giant data.
- ECharts: saw a brief tooltip flicker under heavy load.
- uPlot: fewer built-ins; I wrote my own tooltip to match brand style.
- LightningChart: licensing setup took time; docs are fine, just more steps.
- Plotly: double-click to reset axes lagged with big sets.
- Recharts: frequent re-renders in React can hurt; memoization helps a bit.