ferrum-viz 0.9.0

Ferrum is a statistical visualization library for Python: a grammar-first charting system that unifies exploratory plots, statistical graphics, interactive views, and model diagnostics, backed by a Rust engine.

Ferrum

Grammar-of-graphics statistical visualization for Python, with a Rust core.

Ferrum builds every chart — scatter plot, faceted histogram, ROC curve, SHAP beeswarm — from the same grammar of data, encodings, marks, scales, and statistical transforms. The declaration layer is Python; the computation engine is Rust compiled via PyO3.

Install

pip install ferrum-viz

Install with all optional extras (scikit-learn, SHAP, Jupyter interactive rendering):

pip install ferrum-viz[all]

Quickstart

import ferrum as fm
import polars as pl

df = pl.DataFrame({"x": [1, 2, 3, 4], "y": [2, 4, 3, 5], "group": ["a", "a", "b", "b"]})

chart = fm.Chart(df).mark_point().encode(x="x", y="y", color="group:N")
chart.save("scatter.svg")
chart.show_png()  # raster output, no display server needed

Key features

• One chart model — scatter plots, statistical graphics, and ML diagnostics share the same grammar and compose with +, |, &.
• Stat transforms in the pipeline — KDE, LOESS, bootstrap CIs, binning, and aggregations are declared in the chart spec and computed in Rust.
• Model diagnostics as charts — fm.roc_chart(model, X, y), fm.confusion_matrix_chart(...), fm.shap_chart(...) return regular Chart objects.
• Zero system dependencies — no Cairo, no X11, no display server. Renders anywhere pip install works.
• DataFrame pluralism — polars, pandas, modin, cuDF, dask, ibis, and pyarrow all work through Chart(data).
• Interactive rendering — chart.interactive() switches to a GPU-backed WASM renderer with selections, zoom/pan, linked views, and tooltips. Backed by anywidget for Jupyter.
• 12 built-in themes — from Paper Ink (warm cream default) to dark, publication, and editorial styles.

Examples

# Layer a LOESS trend on a scatter plot
points = fm.Chart(df).mark_point(opacity=0.6).encode(x="x", y="y", color="group:N")
trend = fm.Chart(df).mark_smooth(method="loess").encode(x="x", y="y", color="group:N")
chart = points + trend

# Compose diagnostics into a model report
source = fm.ModelSource(model, X_test, y_test)
report = (fm.roc_chart(source) | fm.confusion_matrix_chart(source)) & fm.importance_chart(source)
report.save("model_report.svg")

# Figure-level helpers
fm.displot(df, x="value", hue="group", kind="kde")
fm.catplot(df, x="species", y="measurement", kind="violin")
fm.pairplot(df, vars=["a", "b", "c"], hue="label")

Architecture

Layer	Role
src/ferrum/	Python declaration API — Chart, encodings, marks, themes, plots
crates/ferrum-core/	Rust computation engine — transforms, scales, rendering
Arrow CDI	Zero-copy data transport between Python and Rust via pyo3-arrow

Development

Requires Python 3.10+, Rust toolchain, and maturin.

uv sync
unset CONDA_PREFIX && uv run --no-sync maturin develop   # build Rust extension
uv run pytest                                            # run tests

How this was built

Ferrum was designed and implemented in 9 days by one human and an agentic Claude framework — 918 commits, ~97k lines of source, 3,358 tests. The project uses a six-layer automation architecture with language-specific coding agents, commit-level review gates, and repeatable quality campaigns. See design-docs/development-meta-analysis.md for the full retrospective.

Documentation

Full docs at ferrumviz.com.

License

See LICENSE for details.