ggrust

The Grammar of Graphics, written in Rust, used from Python.

ggrust is a plotting library with a Lets-Plot compatible Python API. Plots are built the familiar ggplot way, layer by layer with +, while the stats, scales, layout and rendering all run in Rust.

It was started for Cellestial, which needed a maintained backend for its Lets-Plot based API.

Every plot above is ggrust. More in the gallery.

Highlights

• Fast and lean: a median 40x faster SVG, 22x faster PNG and 14x lower peak memory than Lets-Plot on identical work (details).
• ggplot2 extensions, built in: beeswarms, significance brackets, cluster marks, side panels, dendrograms, raincloud plots, patchwork layouts and more, under their R names (list).
• The Lets-Plot API: most code ports with an import swap, lets_plot -> ggrust.
• Interactive: notebook and HTML output with tooltips, zoom and pan; dense point layers drawn on a canvas.
• Publication output: SVG, PNG, vector PDF and HTML, with your own fonts. Data crosses into Rust once, as Arrow, so Polars and pandas frames work directly.

Installation

pip install ggrust

uv add ggrust

Quickstart

import polars as pl
from ggrust import *

frame = pl.DataFrame(
    {
        "height": [150, 162, 171, 180, 168, 175],
        "weight": [52, 60, 68, 82, 65, 74],
        "group": ["a", "a", "b", "b", "c", "c"],
    }
)

plot = (
    ggplot(frame, aes(x="height", y="weight", color="group"))
    + geom_point(size=4)
    + labs(title="Height vs weight")
    + ggsize(600, 400)
)

plot.to_png("plot.png")

In a notebook the plot shows as interactive HTML (tooltips, zoom and pan with ggtb()).

ggplot2 extensions, built in

Many popular ggplot2 extension packages from R are built into ggrust, under their R function names. Nothing extra to install; Lets-Plot has none of them.

ggrust reimplements their behavior in Rust; the R packages and their authors designed it. Examples and credits are in the extensions guide.

Performance

Compared with Lets-Plot on identical work: same data, every row drawn (Lets-Plot sampling turned off), same output size. Measured on an Apple M4 Pro, ggrust 0.1.0 vs lets-plot 4.11.0.

• Speed: SVG a median 40x faster (5x to 185x over 23 cases), PNG a median 22x faster (13x to 119x).
• Memory: a median 14x lower peak memory (3.6x to 220x). A 1M-point scatter PNG peaks at 44 MB above the data in ggrust and 9.6 GB in Lets-Plot.
• No case was slower. The weakest spots are point-heavy PNGs (13x to 21x) and large SVGs, where ggrust still peaks at 430 MB for 1M points.

Full methodology, raw numbers and side-by-side output images are in the benchmark report.

More examples

Distributions

Violins with boxplots on top, using the same layering as ggplot.

import numpy as np

rng = np.random.default_rng(0)
days = ["Mon", "Tue", "Wed", "Thu", "Fri"]
commute = pl.DataFrame(
    {
        "day": np.repeat(days, 200),
        "minutes": np.concatenate([rng.gamma(4 + i, 6, 200) for i in range(5)]),
    }
)

(
    ggplot(commute, aes(x="day", y="minutes", fill="day"))
    + geom_violin(alpha=0.6)
    + geom_boxplot(width=0.15, fill="white")
    + labs(title="Commute time by weekday")
    + theme_classic()
    + ggsize(600, 400)
)

Facets

Split a plot into panels by a column.

months = np.arange(1, 13)
temperature = pl.DataFrame(
    {
        "month": np.tile(months, 3),
        "temp": np.concatenate(
            [10 + 8 * np.sin((months - 3) / 12 * 2 * np.pi) + offset for offset in (0, 5, -4)]
        ),
        "city": np.repeat(["Lisbon", "Athens", "Oslo"], 12),
    }
)

(
    ggplot(temperature, aes(x="month", y="temp", color="city"))
    + geom_line(size=1.2)
    + geom_point()
    + facet_wrap("city", ncol=3)
    + labs(title="Monthly temperature", y="°C")
    + theme_bw()
    + ggsize(900, 350)
)

What it covers

• Geoms: point, line, path, bar, col, histogram, boxplot, violin, area ridges, tile, raster, rect, text, label, text/label repel, segment, curve, polygon, rug, imshow, brackets and more.
• Stats: count, bin, density, smooth, summary, ecdf, contours, 2D bins, ellipses.
• Scales: continuous, discrete, log, reversed, datetime, hue, manual, gradients, viridis, brewer, secondary axes, axes on any side.
• Layout: facet_wrap, facet_grid, gggrid with collected legends, coord_fixed, coord_flip, themes (theme_classic, theme_bw, theme_minimal, theme_void, ...).
• Outputs: SVG, PNG, vector PDF, and interactive HTML through ggsave, with your own fonts (register_font). Dense scatter layers are drawn on a canvas in HTML.

ggrust is a subset of Lets-Plot, not all of it. Features follow what Cellestial and everyday plotting need. See the migration note for the differences.

Status

Early, but usable: the full Cellestial test suite passes on ggrust. Expect rough edges and API gaps; issues are welcome.

Development

uv sync          # create the dev environment
make develop     # build the Rust extension into .venv
make check       # fmt, clippy, ruff, cargo test, pytest

Roadmap in plan.md, contributor rules in AGENTS.md.