xy: The Rust-Powered Python Charting Library That Renders 100M Points Like It's Nothing

Grounded / Real Inflated / Uruttu

60% real

40% uruttu

article Original Content

After today, plotting in Python will never be the same!!! This github repo is pure gold!!! 100 million points. Rendered in 0.08 seconds. The exact same speed as a chart with 10 thousand points. 🤯 I had to re-read that table three times. Reflex just open-sourced xy, a Python charting library with a Rust core and WebGL2 rendering. In their live-interactivity benchmark, render time stays flat at ~0.08s from 10k all the way to 100M points. That's 34× faster than the next best at 10M, and 177× at 50M. Plotly doesn't finish at 50M. Matplotlib taps out at 100M. At 1 billion points, xy still hands you a working interactive chart in 1.24s. The one that broke my brain: a 10M-point interactive scatter exports to 258 KiB of HTML. Plotly's version is 259 MiB. And it's a drop-in swap "matplotlib.pyplot" for "xy.pyplot" and your code just runs. "pip install xy"

verified Validated Content

Confirmed as real and accurate:

Reflex did open-source xy, a Python charting library with a Rust core and WebGL2 rendering — this is a real, current project (alpha release), confirmed on their official docs, GitHub, and multiple independent posts.
It is genuinely a drop-in matplotlib replacement — swapping import matplotlib.pyplot as plt for import xy.pyplot as plt is confirmed by Reflex's own documentation.
pip install xy is accurate.
The 1 billion points → ~1.24s interactive render claim is essentially accurate — Reflex's official benchmark table shows 1.253s for "interactive, default GPU" at 1B points. Close match.
Reflex's official benchmarks do confirm that Matplotlib and Plotly failed to complete their default exact-marker rendering at the 1-billion-point scale (hit memory/time guardrails), while xy succeeded by switching to a density-based representation instead of drawing every point.

Not verified / likely exaggerated or misattributed:

"100 million points in 0.08 seconds" — Reflex's officially published benchmark table only shows measured points at 10k, 100k, 1M, 10M, and 1B — not 100M specifically. A secondary source (daily.dev) mentions render times staying flat "0.071s–0.081s from 10k to 100M," so this is plausible but not something I could confirm from Reflex's own primary benchmark page.
"34× faster at 10M, 177× faster at 50M" — These specific multipliers don't match the official benchmark numbers. At 10M points, Reflex's own table shows roughly 16–20× faster than Matplotlib/Plotly on interactive first render, or up to ~400× faster on static PNG rendering — neither matches "34×" cleanly. No 50M data point appears in the official table at all, so "177× at 50M" is unverifiable from primary sources. Other posts about xy cite a 523× speedup figure (for static PNG at 10M) — yet another number, suggesting these performance multipliers vary a lot depending on which specific benchmark/output type is cited, and the post may be blending or misquoting them.
"Plotly doesn't finish at 50M" / "Matplotlib taps out at 100M" — the official benchmarks document failures at the 1 billion point scale, not 50M or 100M specifically. Possible these come from a different (perhaps GitHub-only) test run, but I couldn't confirm it.
"258 KiB vs. 259 MiB" export size comparison — not found in Reflex's official docs or the sources I could access. Plausible given the architecture (density-based rendering vs. embedding every point), but unverified.

Verdict: The core story is real — this is a legitimate, novel open-source library with genuinely impressive architecture. But several of the specific numbers in the post (the "34×," "177×," and file-size figures) don't match Reflex's own published benchmark data and may be pulled from an unofficial source, rounded loosely, or simply incorrect.