Pandas vs Polars vs Dask, Charted Live

I wanted one page that actually shows the difference between pandas, Polars, and Dask instead of just telling you Polars is "fast." The three charts above are Chart.js, running client-side, against a fixed dataset I picked by hand – not a stock template with placeholder numbers. Ecosystem stats as a bubble chart. A benchmark as a scriptable bubble chart, where the color is computed from the value instead of pinned to a library. An adoption curve that draws itself in progressively, left to right, the same way the real growth unfolded year over year.

Three libraries, one job – tabular data in Python – and three very different trade-offs between throughput, memory, and how much of your existing pandas code survives the switch. The numbers below are rounded, dated September 2026, and the benchmark is illustrative rather than a run I reproduced on this exact page. I'd rather repeat that once too often than let a chart imply more precision than it has.

1. Why only three libraries share the bubbles

Bubble and scatter charts are the one chart form where every mark can end up sitting right next to every other mark, so a categorical color palette has to survive every possible pair, not just neighbors in a legend. Run that all-pairs check against my usual eight-hue set and only the first three colors clear it, in both light and dark mode, for a colorblind reader. That's not a design opinion – it's the actual reason the ecosystem chart above compares exactly pandas, Polars, and Dask instead of five libraries in five muddy colors. PySpark and Modin get a paragraph near the bottom of this page instead of a bubble.

pandas still wins on downloads by an order of magnitude, which is exactly what you would expect from a fifteen-year-old standard with thousands of integrations. The more interesting read is how close Polars has gotten to Dask on GitHub stars while running on roughly a tenth of the contributors – a small, focused team rewriting the engine from scratch instead of extending an existing API can apparently out-pace a much larger one.

2. Scriptable color, not identity color

The performance chart runs a groupby-and-aggregate on a CSV at two sizes – 2 GB, which fits comfortably in memory, and 20 GB, which sits at the edge of a typical laptop. Chart.js lets you set elements.point.radius and backgroundColor as functions instead of fixed values, which is exactly what Chart.js's own scriptable-options sample demonstrates. I used it here for something with real meaning: color is computed straight from the runtime in seconds – fast, moderate, slow – not pinned to a library, so the same green can belong to Polars at 2 GB or Dask at 20 GB. Bubble radius comes from peak RAM, on a square-root scale so area, not raw radius, tracks memory roughly linearly.

At 2 GB, Dask actually loses to plain pandas – building a task graph has overhead that only pays off once there is enough work to spread across it. At 20 GB the picture flips: single-threaded pandas, copying data in memory, degrades the hardest; Polars, running on Rust with SIMD and streaming execution, stays in the "moderate" band; Dask, splitting the file into chunks, keeps memory in check and closes most of the gap to Polars on time.

3. Progressive lines, and what I'd actually reach for

The growth chart tracks estimated weekly PyPI downloads from 2019 to 2026 for the same three libraries, and it animates the way Chart.js's progressive-line sample does: each point gets its own delay based on its index, so the line draws itself left to right instead of just fading in. That's a deliberate echo of the subject, not decoration – the real adoption also unfolded one year at a time. pandas is levelling off, which is what a mature, fifteen-year-old standard looks like, not a library losing ground. Polars, released in 2020, shows the textbook late-start curve: barely visible at first, then a sharp bend once people outside the Rust-enthusiast bubble started writing about the speed.

So, what would I actually reach for? pandas when the ecosystem and the team's muscle memory matter more than raw seconds. Polars for a new pipeline on one strong machine, where memory and CPU cost real money. Dask when the data stops fitting on one machine at all and you'd rather keep pandas-shaped code than rewrite it in PySpark. PySpark and Modin sit one step further out – PySpark once you're firmly in cluster territory or Spark already runs your infrastructure, Modin when the honest goal is a parallel speed-up with a one-line import change and zero appetite for a rewrite.

• pandas – data up to a few GB, maximum ecosystem, a team that already knows the API cold.
• Polars – single powerful machine, a fresh pipeline with no legacy code to drag along, memory and CPU that actually cost money.
• Dask – data that no longer fits on one machine, a pandas-shaped API you don't want to give up, a cluster that exists or is coming.
• PySpark or Modin – one step further: PySpark once you're squarely in cluster territory, Modin for a one-line import swap when a rewrite is off the table.

About the numbers

GitHub stars and weekly PyPI downloads are rounded estimates as of September 2026, sourced from public trackers like pepy.tech and each project's own repository. The benchmark numbers reproduce the typical shape of public groupby comparisons rather than a run I executed for this exact page – real seconds depend on hardware, versions, and the shape of your data. All three charts are built on Chart.js: a bubble chart, a scriptable bubble chart, and a progressive-line animation, the same three sample patterns Chart.js ships in its own docs.