fru: a Rust random forest for R and Python, up to thousands of times faster than scikit-learn

2026-08-11

A Rust random forest for R and Python that keeps only ntree/mtry, runs a few to thousands of times faster than scikit-learn as cores scale, and adds a novel fast permutation-importance algorithm.

What problem this solves

Random forest remains one of the most reliable tools for tabular data. Gradient-boosted trees stole the spotlight, but random forest is still a first pick when samples are modest, features are messy, and interpretability matters. The catch is the implementations: R's randomForest is single-threaded and slow on larger data; scikit-learn's version scales poorly and can get slower as threads increase; ranger is fast, but the three disagree on how importance is scored, so results do not line up across libraries.

Kursa is familiar to R users as the author of Boruta, a feature-selection method. This SoftwareX paper introduces fru, a random forest he built with Piwoński from the ground up in Rust. The goal is not another benchmark winner; it is a forest that is stable, correct, fast, and able to scale across cores and into production. The R package is on CRAN, and Boruta already uses fru as its backend.

Method

fru's philosophy is "expose only the original hyperparameters": just trees (count, default 500) and tries (features tried per split, i.e. mtry). No extra-trees, no extra regularization. Fewer knobs means stable, reproducible behaviour across versions and languages.

Key engineering choices:

• Rust core, multi-language bindings. The forest algorithm is factored into a generic crate, xrf; the R package fru and the Python package fru-arrow both sit on top of it. The Python side ingests polars, pandas, and pyarrow directly via Arrow PyCapsule, skipping serialization.
• Reproducible parallel randomness. fru uses the pcg32 PRNG with independent streams, so the same data and seed grow the same forest regardless of thread count. Tree order may differ, but OOB predictions and importance scores match within numerical error. This is the common footgun in multicore forests, and fru turns it into a contract.
• A redone permutation importance. Permutation importance is more trustworthy than Gini importance but costly, since it must reshuffle and rescore each feature. fru ships a custom, highly optimized algorithm to cut that cost, a clear differentiator.
• Careful split rules. Numeric features scan all thresholds exhaustively; unordered factors with up to five levels enumerate every binary partition, and with six or more fall back to numeric handling; logical features split on true/false but still enter the weighted-Gini scoring so they compete fairly. Max tree depth is hard-coded at 512.

Results

The paper reports relative speed; the exact per-dataset timing tables are in the ScienceDirect full text, which blocked the datacenter IP and was not retrieved directly. The magnitude below comes from the authors' own project docs, the same source as the benchmark:

The point is the trend, not a fixed multiplier: scikit-learn's forest scales poorly across threads, while fru keeps consuming cores, so the larger the data and the more the cores, the bigger fru's edge. Exact per-dataset numbers belong to the paper's full text.

Why it matters

For anyone running scikit-learn or R on tabular models, fru is a much faster drop-in backend, especially for workloads that retrain repeatedly: feature selection (Boruta is exactly repeated forest training), hyperparameter search, batch scoring in production. Boruta's switch to fru means this popular feature-selection method now ships Rust speed by default.

The engineering posture is the other lesson: factor the algorithm into a crate shared by R and Python, make importance a reproducible parallel implementation, and deliberately narrow the API to its minimum. That is a clean template for rewriting classic algorithms in a systems language beyond Python and R. Gradient boosting and nearest neighbors, old algorithms whose value lives in the implementation, fit the same mold.

Limitations

• The exact timing tables are in the ScienceDirect article, which blocked the datacenter IP; the magnitude here comes from the authors' project docs, same source as the benchmark but not checked line by line against the paper.
• Only permutation importance is offered, no Gini importance. Permutation importance is more robust but heavier; workflows that want only a rough ranking may find it costly, mitigated but not removed by fru's custom acceleration.
• No NA support (you must impute first); only the original Breiman forest, no extra-trees variant; max tree depth hard-coded at 512, a ceiling for very deep structures.
• Maturity: the CRAN release is still 0.0.x (0.0.7), early stage, and requires a Rust toolchain (rustc and Cargo >= 1.85), an extra build dependency for pure R or Python users.

Terms

• Random forest: Breiman's 2001 ensemble: grow a decision tree on each bootstrap sample, split on a random subset of features at each node, then vote.
• Out-of-bag (OOB) prediction: the samples a tree never drew act as its test set, giving the forest a built-in cross-validation without a held-out set.
• Permutation importance: shuffle one feature's values and measure the score drop; a more honest measure of contribution than Gini importance, which high-cardinality features can game.
• pcg32: a fast, memory-light, statistically sound PRNG; fru uses it to keep results reproducible across threads.
• Arrow PyCapsule: Apache Arrow's zero-copy interface, letting the Python side hand polars or pandas frames to the Rust core without serialization.

Source

• Paper

What people are saying

• Rust-Based Random Forest 'Fru' Outperforms scikit-learn by Hundreds of Times kpiwonski

All paper explainers