ruviz

High-performance 2D plotting library for Rust combining matplotlib's ease-of-use with Makie's performance.

Release Notes

• Changelog
• Release Notes Index
• Latest Release Notes (v0.1.5)

Quick Start

use ruviz::prelude::*;

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("plot.png")?;

Need typeset math labels? See Typst Text Mode below.

Features

🛡️ Safety & Quality

• Zero unsafe in public API
• Strong type system prevents runtime errors
• Comprehensive error handling with Result types
• Memory-safe by design

📊 Plot Types

Basic: Line, Scatter, Bar, Histogram, Box Plot, Heatmap Distribution: Violin, KDE, ECDF Composition: Pie, Donut Continuous: Contour Polar: Polar Plot, Radar Chart Error: Error Bars (symmetric/asymmetric)

🎨 Publication Quality

• High-DPI export: 72, 96, 300, 600 DPI for print
• Multiple formats: PNG, SVG, and PDF (with the pdf feature)
• Professional themes: Light, Dark, Publication, Seaborn-style
• Custom styling: Colors, fonts, markers, line styles
• International text: Full UTF-8 support (Japanese, Chinese, Korean, etc.) with cosmic-text

⚡ Advanced Features

• Simple API: One-liner functions for quick plotting
• Parallel rendering: Multi-threaded for large datasets (rayon)
• GPU acceleration: Optional wgpu backend (experimental)
• Interactive plots: Optional winit window integration
• Animation: GIF export with record! macro and easing functions
• Cross-platform: Linux, macOS, Windows

Installation

Add to your Cargo.toml:

[dependencies]
ruviz = "0.1.5"

Feature Flags

Choose features based on your needs:

[dependencies]
ruviz = { version = "0.1.5", features = ["parallel", "simd"] }

For minimal builds: default-features = false

Typst Text Mode

Enable Typst text rendering:

[dependencies]
ruviz = { version = "0.1.5", features = ["typst-math"] }

Use .typst(true) on a plot to render all static text surfaces (titles, axis labels, ticks, legend labels, and annotations) through Typst:

use ruviz::prelude::*;

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

Plot::new()
    .line(&x, &y)
    .title("$f(x) = e^(-x)$")
    .xlabel("$x$")
    .ylabel("$f(x)$")
    .typst(true)
    .save("typst_plot.png")?;

Notes:

• Invalid Typst snippets fail render/export with a TypstError.
• If typst-math is not enabled, .typst(true) returns FeatureNotEnabled at render/export.
• Migration: .latex(true) has been removed; use .typst(true) instead.
• Typst text in PNG output is rasterized at native output scale (1x).
• For maximum text sharpness, prefer higher DPI (for example .dpi(300)) or vector export (.export_svg(...) / .save_pdf(...)).
• DPI changes output density, not the intended physical size of fonts, strokes, markers, or layout spacing.
• Prefer .size(width_in, height_in) when you care about physical figure size. .size_px(width, height) is a convenience that maps pixels through the 100-DPI reference size before final output DPI is applied.
• Ticks are enabled by default and render inward on all four sides. Use .ticks(false) to hide tick marks and tick labels while keeping the frame and axis titles.
• Migration: if you want the older bottom/left-only tick appearance, call .ticks_bottom_left().
• Migration: if you previously relied on high-DPI exports making lines, markers, or text look larger, set those sizes explicitly instead of relying on DPI.

Tick customization:

use ruviz::prelude::*;

Plot::new()
    .line(&x, &y)
    .tick_direction_inout()
    .ticks_bottom_left()
    .show_top_ticks(true)
    .show_right_ticks(true)
    .save("custom_ticks.png")?;

Examples

Basic Line Plot

use ruviz::prelude::*;

let x = vec![0.0, 1.0, 2.0, 3.0, 4.0];
let y = vec![0.0, 1.0, 4.0, 9.0, 16.0];

Plot::new()
    .line(&x, &y)
    .title("My First Plot")
    .save("output.png")?;

Multi-Series with Styling

use ruviz::prelude::*;

let x = vec![0.0, 1.0, 2.0, 3.0, 4.0];

Plot::new()
    .line(&x, &x.iter().map(|&x| x).collect::<Vec<_>>())
    .label("Linear")
    .line(&x, &x.iter().map(|&x| x * x).collect::<Vec<_>>())
    .label("Quadratic")
    .line(&x, &x.iter().map(|&x| x.powi(3)).collect::<Vec<_>>())
    .label("Cubic")
    .title("Polynomial Functions")
    .xlabel("x")
    .ylabel("y")
    .theme(Theme::publication())
    .save("polynomials.png")?;

Grouped Series with Shared Styling

use ruviz::prelude::*;

let x = vec![0.0, 1.0, 2.0, 3.0];
let a = vec![0.0, 1.0, 2.0, 3.0];
let b = vec![0.0, 1.5, 3.0, 4.5];
let baseline = vec![0.2, 1.2, 2.2, 3.2];

Plot::new()
    .group(|g| {
        g.group_label("Sensors")
            .line_style(LineStyle::Dashed)
            .line_width(2.0)
            .color(Color::from_hex("#1E88E5").unwrap())
            .line(&x, &a)
            .line(&x, &b)
    })
    .line(&x, &baseline)
    .label("Baseline")
    .legend(Position::TopRight)
    .save("grouped_series.png")?;

Subplots

use ruviz::prelude::*;

let plot1 = Plot::new().line(&x, &y).title("Line").end_series();
let plot2 = Plot::new().scatter(&x, &y).title("Scatter").end_series();
let plot3 = Plot::new().bar(&["A", "B", "C"], &[1.0, 2.0, 3.0]).title("Bar").end_series();
let data = vec![0.5, 1.0, 1.5, 2.0, 2.5];
let plot4 = Plot::new()
    .histogram(&data, None)
    .title("Histogram")
    .end_series();

subplots(2, 2, 800, 600)?
    .suptitle("Scientific Analysis")
    .subplot(0, 0, plot1)?
    .subplot(0, 1, plot2)?
    .subplot(1, 0, plot3)?
    .subplot(1, 1, plot4)?
    .save("subplots.png")?;

Large Dataset

use ruviz::prelude::*;

// 100,000-point PNG export
let x: Vec<f64> = (0..100_000).map(|i| i as f64).collect();
let y: Vec<f64> = x.iter().map(|&x| x.sin()).collect();

Plot::new()
    .line(&x, &y)
    .title("Large Dataset")
    .save("large.png")?;

Animation

Enable the animation feature for this example:

[dependencies]
ruviz = { version = "0.1.5", features = ["animation"] }

use ruviz::prelude::*;
use ruviz::animation::RecordConfig;
use ruviz::record;

let x: Vec<f64> = (0..100).map(|i| i as f64 * 0.1).collect();
let config = RecordConfig::new().max_resolution(800, 600).framerate(30);

record!(
    "wave.gif",
    2 secs,
    config: config,
    |t| {
        let phase = t.time * 2.0 * std::f64::consts::PI;
        let y: Vec<f64> = x.iter().map(|&xi| (xi + phase).sin()).collect();
        Plot::new()
            .line(&x, &y)
            .title(format!("Wave Animation (t={:.2}s)", t.time))
            .xlim(0.0, 10.0)
            .ylim(-1.5, 1.5)
    }
)?;

Typst Text Example

Run:

cargo run --example doc_typst_text --features typst-math

Documentation

• User Guide - Comprehensive tutorials and examples
• API Documentation - Complete API reference
• Gallery - Visual examples showcase
• Migration from matplotlib - For Python users
• Migration from seaborn - Statistical plots
• Performance Guide - Optimization techniques

Why ruviz?

Rust's plotting ecosystem has several options, but each has trade-offs:

ruviz fills the gap with:

• High-level API: matplotlib-style Plot::new().line().title().save() - no boilerplate
• Pure Rust: No Python, JavaScript, or external runtime needed
• Built-in plot types: 15+ plot types out of the box (violin, KDE, radar, etc.)
• Publication quality: Professional themes and high-DPI export

// plotters: ~30 lines for a simple line plot
// ruviz: 4 lines
Plot::new()
    .line(&x, &y)
    .title("My Plot")
    .save("plot.png")?;

Contributing

Contributions welcome! See CONTRIBUTING.md for setup, testing, and pull request guidelines.

Development

# Clone repository
git clone https://github.com/Ameyanagi/ruviz.git
cd ruviz

# Setup pre-commit hooks (recommended)
make setup-hooks

# Run code quality checks
make check

# Run tests
cargo test --all-features

# Run examples
cargo run --example basic_example --release

# Run benchmarks
cargo bench --all-features

The pre-commit hooks will automatically run cargo fmt --check and cargo clippy before each commit to ensure code quality.

Roadmap

• Core plot types (line, scatter, bar, histogram, boxplot, heatmap)
• Parallel rendering
• SIMD optimization
• GPU acceleration (experimental)
• Professional themes
• Subplots and multi-panel figures
• Distribution plots: Violin, KDE, ECDF
• Composition plots: Pie, Donut
• Continuous plots: Contour
• Polar plots: Polar, Radar
• Error bars
• SVG export
• Experimental interactive window support
• High-level APIs for area, hexbin, step, and stem plots
• High-level APIs for regression and composite plots
• Stabilize the interactive zoom/pan workflow
• 3D plotting (v1.0+)

License

Licensed under either of:

• Apache License, Version 2.0 (LICENSE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE or http://opensource.org/licenses/MIT)

at your option.

Acknowledgments

• Inspired by matplotlib, seaborn, and Makie.jl
• Built with tiny-skia for rendering
• Text rendering by cosmic-text
• Thanks to the Rust community for excellent crates and feedback

Status: v0.1.5 - Early development, API may change. Production use at your own risk.

Support: Open an issue or start a discussion