SlintPlot benchmarks

Frame times of SlintPlot's charts from 100 to 1,000,000 points, with Slint's software renderer and with Skia on the GPU. For the short version, see how much a chart can show.

How it's measured

The numbers come from the stress test app, slintplot-stress. --bench renders each configuration with Slint's software renderer, without a window; --bench-gpu renders the same configurations with Skia, on the GPU.

• Machine: Apple M4 (10 cores, 16 GB), macOS 27, a release build of SlintPlot 0.5.0 with Slint 1.18.1 (its Skia renderer through skia-bindings 0.153.3).
• Versions matter. Most of a frame is spent in Slint's renderer, so another Slint version, or another Skia, can give different numbers, faster or slower. We measure again for each SlintPlot release; when you compare your own numbers with these, check which Slint version your build uses (cargo tree -i slint).
• Software renderer: on one CPU core, into a 1280×800 pixel buffer.
• Skia: Slint's Skia renderer with Metal on the M4's GPU, in a 1280×800 window at scale factor 1. Each frame is drawn with Window::take_snapshot, which returns once the GPU has drawn it and the pixels are read back, so the GPU's work is included. Reading back costs a fixed amount per frame: the least a frame takes, a gauge, is 1.3 ms.
• Data: three datasets (three groups for the sunburst), random walks.
• Frame: the chart's layout plus drawing every pixel, measured once per configuration. Showing it on a screen isn't included. Hover is the next frame after the mouse moves over the chart. With Skia, redraw is the median of up to 15 more frames of the same data.
• Runs: each number is the median of three runs. Most numbers differed between runs by ±3% or less; frames under 5 ms, and a few others, by up to ±15%.

At 60 frames per second, a frame has 16.7 ms. Frames below that can be animated and streamed smoothly; slower ones are fine for charts that change now and then.

Software renderer

Lines, bars and points

Frame time per number of points in each dataset. Decimation draws a line with more points than pixels as one span per pixel column.

With point markers and smooth lines, a line takes 6.3 ms at 100 points, 14 ms at 1,000 and 129 ms at 10,000: each marker is an element. Bars and markers are one element each, so the benchmark doesn't run them past 100,000 bars or 10,000 markers.

Charts with one shape per item

Waterfall, dumbbell, funnel and sunburst charts draw every step, row, stage or item, with no decimation:

A gauge frame takes 2.3 ms.

Streaming limits

How much data can a chart show while it streams, and still update at 60 or 30 frames per second? slintplot-stress --bench-stream measures it: each update appends one value to each of three datasets, drops the oldest, and renders a full frame. It grows the window (the values kept per dataset) in 1-2-5 steps from 1,000 to 10,000,000, and times each size: the 95th percentile of up to 100 updates, the median of three runs. Same machine and renderer as above: Apple M4, macOS 27, Slint's software renderer on one core, 1280×800.

Two views: everything, the whole window on screen, and the latest 1,000, zoomed in to the newest values, as a live view usually is, with the rest kept for scrolling back.

The largest window, in values per dataset, that updates within 16.7 ms (60 fps) or 33.3 ms (30 fps). 10,000,000+ means the largest size tried still made it.

• Zoomed in, the data size doesn't matter. A view of the latest 1,000 values updates in about 6 ms with 1,000 values kept per dataset or with 10,000,000: the chart finds the visible values with a binary search and reads only those.
• Showing everything, decimation sets the limit. A decimated line updates at 60 fps with 50,000 values per dataset, and takes 130–150 ms with 500,000. A decimated time series makes 60 fps with 20,000 in two runs of three and 50,000 in one: at 50,000 it takes 16.4–16.8 ms, right at the 16.7 ms limit. Below about 2,500 values (twice the plot width in pixels) lines aren't decimated, so up to there all line charts cost the same.
• Scatter charts read every point, since their points can be in any order, so even zoomed in they slow down from about 20,000 points per dataset.
• One value per update. At higher data rates, the samples that arrive between frames are added in one batch per frame (see Streaming). The benchmark doesn't measure those larger batches; the stress app shows their effect live, at up to 100,000 samples a second.

What the numbers mean

• Up to about 1,000 points per dataset, every chart fits in a 60 fps frame, except the sunburst (21 ms).
• Lines of any size stay usable with decimation, which is on by default: 5 ms at 10,000 points, 24 ms at 100,000 and about 240 ms at 1,000,000 for a full redraw. Hovering stays at about 3 ms at every size, and zooming in to 0.1% of a million points brings a frame to 46 ms. Without decimation, a million-point line takes 17 s to draw.
• Bars, scatter markers and the one-shape-per-item charts grow with the count. For animation and streaming, keep them to about 1,000 bars, markers or items; at 10,000 a frame takes 23–266 ms.
• Up to 10,000 points, drawing takes most of the time. Computing the chart takes 1–8 ms (19 ms for a line with point markers) of frames of 6–266 ms. With decimated million-point lines it's the other way round: reading and decimating the data takes 188 ms of the 238 ms frame.

What isn't measured

• FemtoVG, and Skia on other systems. Skia is measured on macOS only, with Metal. FemtoVG, Slint's default GPU renderer, isn't benchmarked: its snapshots can't be timed the same way. The streaming limits are measured with the software renderer only.
• The browser. The web gallery runs SlintPlot as WebAssembly; it isn't benchmarked, and is likely slower.
• Other machines. Everything above is from one fast computer. Older or low-power hardware is slower; embedded devices are untested.
• Memory use and start-up time.

Run it yourself

To measure your own machine, run the benchmark, or open the app to try the charts with live numbers:

cargo install slintplot-stress
slintplot-stress --bench          # the tables above, for your machine
slintplot-stress --bench-stream   # only the streaming limits, with your machine's specs
slintplot-stress                  # the interactive stress test

git clone https://github.com/trondegil/slintplot
cd slintplot
git checkout v0.5.0
cargo run --release -p slintplot-stress -- --bench

SLINT_BACKEND=winit-skia SLINT_SCALE_FACTOR=1 \
  cargo run --release -p slintplot-stress --features skia -- --bench-gpu

SlintPlot · slintplot.dev · license@slintplot.dev