ruviz

High-performance 2D and 3D plotting for Rust. One builder, 29 plot types (33 with the 3d feature), PNG / SVG / PDF output.

Demo

https://github.com/user-attachments/assets/bce842b5-50d8-43e4-893d-074bf6738975

A 77-second tour: 29 plot types from one builder, the built-in themes, Typst mathematics and CJK text, 3D and animation, and the Python and WebAssembly bindings. Every figure in it is real ruviz output.

Install

[dependencies]
ruviz = "0.12.0"

Hello, plot

use ruviz::prelude::*;

fn main() -> PlotResult<()> {
    let x: Vec<f64> = (0..50).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = x.iter().map(|&x| x * x).collect();

    Plot::new()
        .line(&x, &y)
        .title("Quadratic Function")
        .xlabel("x")
        .ylabel("y = x^2")
        .save("quadratic.png")?;

    Ok(())
}

The one pattern

Plot::new() → series method(s) → setters → .save(path). That is the whole API. There is no separate figure or axes object.

• Every call returns the builder, so the chain never branches.
• A setter placed after a series method styles that series (.label, .color, .line_width, .marker). Plot-level setters (.title, .legend, .theme, .xlim) apply to the whole plot, wherever you put them.
• Starting another series — or calling .save() / .render() — finishes the previous series for you. Nothing to close.

use ruviz::prelude::*;

fn main() -> PlotResult<()> {
    let x = vec![0.0, 1.0, 2.0, 3.0, 4.0];
    let quadratic: Vec<f64> = x.iter().map(|&v| v * v).collect();

    Plot::new()
        .line(&x, &x)
        .label("Linear")
        .color(Color::from_palette(0))
        .line(&x, &quadratic)
        .label("Quadratic")
        .line_style(LineStyle::Dashed)
        .legend(LegendPosition::UpperLeft)
        .theme(Theme::seaborn())
        .save("series.png")?;

    Ok(())
}

Series methods

Every series method, complete. The one catalogued type missing here is fill_between, which is an annotation rather than a series — see Styling. &x / &data accept any numeric slice or Vec (&[f64], &Vec<f64>, and ndarray / polars / nalgebra types with the matching feature). Grid data differs by plot: heatmap takes nested rows (&Vec<Vec<f64>>), while contour takes a flat row-major &Vec<f64> of x.len() * y.len() values.

Every one of them takes the same chain shape: .<series>(..).label(..).color(..).legend_best().save(..).

Styling

Colors: Color::BLUE (and RED, GREEN, BLACK, WHITE, ORANGE, …), Color::from_rgb(31, 119, 180), Color::from_hex("#1f77b4")?, Color::from_palette(0) for the theme's cycle.

Markers: Circle, Square, Triangle, TriangleDown, Diamond, Plus, Cross, Star.

Themes for .theme(..): Theme::light() (default), dark(), seaborn(), publication(), minimal(), presentation(), ieee(), nature(), paul_tol(), colorblind_friendly(). Theme::seaborn() reproduces seaborn.set_theme(), and Theme::builder() customizes any of them. See styling guide.

Math and CJK text: enable the typst-math feature and call .typst(true); titles and labels then accept Typst math such as "$f(x) = e^(-x)$". See QUICKSTART.

Output

On wasm targets use the in-memory calls (render_png_bytes, render_to_svg) rather than the file-path ones.

Subplots

subplots(rows, cols, width, height) returns a SubplotFigure. Convert each plot with .into() and place it by index:

use ruviz::prelude::*;

fn main() -> PlotResult<()> {
    let x: Vec<f64> = (0..50).map(|i| i as f64 * 0.2).collect();
    let sin: Vec<f64> = x.iter().map(|v| v.sin()).collect();
    let cos: Vec<f64> = x.iter().map(|v| v.cos()).collect();

    subplots(1, 2, 800, 400)?
        .suptitle("Trig")
        .subplot_at(0, Plot::new().line(&x, &sin).title("sin").into())?
        .subplot_at(1, Plot::new().line(&x, &cos).title("cos").into())?
        .save("subplots.png")?;

    Ok(())
}

plots::composite::jointplot(&x, &y, w, h) and pairplot(&columns, w, h) also return a SubplotFigure.

3D (3d feature)

3D plots start from free functions — there is no Plot3D type: scatter3d(&x, &y, &z), line3d(..), surface(&x, &y, &z_2d), wireframe(..). They take .title(), .xlabel(), .zlabel() and .save() like a 2D plot.

use ruviz::prelude::*;

fn main() -> PlotResult<()> {
    let x = [-1.0, 0.0, 1.0, 2.0];
    let y = [-1.0, 0.0, 1.0];
    let z = [
        [-0.4, 0.4, 0.4, -0.4],
        [0.1, 1.0, 1.0, 0.1],
        [-0.4, 0.4, 0.4, -0.4],
    ];

    surface(&x, &y, &z)
        .title("3D surface")
        .zlabel("z")
        .save("surface.png")
}

Gotchas

• No Plot3D. Use the free functions above.
• fill_between is an annotation, not a series. It returns the plot, so it takes plot-level setters (.title), not series ones (.label).
• Not available at all: 2D KDE, regression and residual plots have no builder method; Sankey diagrams and streamplots are not implemented. Anything outside the series table cannot be drawn.
• The top-level line() / scatter() / bar() functions and the ruviz::simple module are deprecated — use the Plot chain (migration note).
• Build with --release; debug builds are far slower.

Feature flags

Defaults: ndarray_support, parallel.

SVG export is always compiled in; the svg feature gates nothing. parallel affects the software 3D rasterizer, not the 2D raster path — measure before enabling performance (benchmarks).

Beyond the Rust crate

Documentation

• Quick Start · User Guide · API docs
• Gallery — every plot type with runnable source
• Migrating from matplotlib or seaborn
• Examples: cargo run --release --example doc_line_plot (see examples/)

License

Licensed under either of Apache-2.0 or MIT, at your option.