A charting library can get faster by drawing faster. XY mostly tries to stop drawing things nobody can see.

The open-source project from Reflex is an interactive Python visualization library. With small datasets, every point can reach the browser. With large ones, its Rust core computes a level of detail based on the current view resolution and sends a representation bounded by what the screen can actually display.

Zooming requests more detail again.

The idea feels obvious afterward: a 1400-pixel window has little reason to receive one hundred million individual markers just to produce an overview.

Exact data stays on the Python side

XY keeps canonical f64 columns in Python. Its native core then chooses between direct points, decimation and density representations.

The browser receives a small spec plus typed binary buffers. Rendering uses WebGL2 for marks, Canvas for some chart elements and DOM for interface pieces.

When the user zooms or selects a region, the system can resolve back to original rows instead of interacting only with an aggregated image.

That makes the technique different from simply pre-rendering a bitmap. The visual summary changes with the viewport while the underlying data remains available.

The benchmark is spectacular, and it is still their benchmark

The README publishes unusually aggressive numbers.

On the stated test machine, an Apple M5 Pro, XY reports roughly 0.08 seconds from 10,000 through 100 million points once density rendering takes over. The project explains the flat curve by no longer drawing one marker for every row above a threshold.

It also demonstrates an OpenStreetMap dataset of roughly ten billion points.

These figures come from the project itself, using its methodology and comparison choices. They should not be converted into a universal claim that "XY is 177x faster."

The mechanism matters more than the leaderboard: overview cost stops scaling directly with the raw number of available points.

Zoom becomes a detail request

The model behaves more like a map than a traditional scatter plot.

A world map does not load the geometry of every building window before showing a continent. It uses levels of detail and refines as the viewer moves closer.

XY applies that logic to analytical charts.

A dense overview can become a density surface. A narrower range requests more precise data. Hover, pan and selection follow the transformed view.

That changes the design question. Instead of asking "how many WebGL points can we draw?", ask "what visual information remains distinguishable at this scale?"

For data visualization, that is usually the more interesting question.

Matplotlib compatibility is the entry ramp

XY also ships a matplotlib.pyplot-style compatibility layer.

The idea is to let some existing scripts change imports before gradually moving toward XY's declarative API. Coverage is not complete, and the repository explicitly labels the project alpha.

It already supports several chart families including lines, scatter, bars, histograms, heatmaps, box and violin plots, contours, facets and scientific primitives. Its roadmap extends into finance, maps, 3D and volume visualization.

That ambition is broad enough that the roadmap should not be confused with what is stable today.

Visualization is already compression

The most useful idea in XY is larger than its Rust and WebGL stack.

A chart is itself a compression mechanism. Thousands or millions of values become a shape a person can perceive.

Shipping every source row into the browser before visually compressing it is sometimes an implementation habit rather than a conceptual requirement.

XY moves computation closer to the real limit: output resolution.

That is not universally correct. Some analyses require every individual point to remain immediately visible, and careless aggregation can hide structure.

But the principle travels well: when an output has finite perceptual capacity, optimizing around that capacity can be more useful than endlessly accelerating the transfer of detail nobody can see.