Scientific Computing in Rust Monthly #23
Welcome to this month's issue of Scientific Computing in Rust Monthly.
Scientific Computing in Rust Monthly can be viewed online at scientificcomputing.rs/monthly, you can sign up to receive an email copy at mailinglist.scientificcomputing.rs, or you can subscribe using the RSS feed at scientificcomputing.rs/monthly/rss.xml.
Items can be added to the next issue of the newsletter by opening a pull request to the Scientific Computing in Rust Monthly repository on GitHub. You can find more information about adding items here.
Crate of the month: pyo3
pyo3 is a crate providing Rust bindings for Python, and includes everything you need to get Rust code talking to Python code. If you want to write a Python interface to your Rust code, you should start by reading the examples in the pyo3 README.
New releases
Aphid 0.12.4 (mbb.cnrs.fr/aphid/)
Aphid is a statistical method described in doi.org/10.24072/pcjournal.359 to distinguish gene flow from incomplete lineage sorting in sibling species, answering whether discordant genetic ancestry is better explained by uneven recollection of shared ancient evolutionary events or by recent horizontal gene transfers.
dogleg 0.1.0
The dogleg crate offers backend-agnostic Rust-native high quality unconstrained
nonlinear least-squares minimization. It currently supports the faer and
nalgebra backends and achieves the same result as Googles Ceres library
on the test suite.
Fastmash 0.2.0
Fastmash brings fast, repeatable statistics to shell pipelines. Written in Rust, it summarizes, groups and reshapes delimited text and quoted CSV, with percentiles, correlations, weighted means and pivot tables. It accepts GNU datamash’s command language, so existing scripts can often switch by changing one word. Software arithmetic keeps numerical results identical across supported machines for the same input, settings and version. Use it to summarize experimental data, compare datasets or check table health without writing a separate analysis program.
ferreus_rbf_rs 0.3
ferreus_rbf_rs is a collection of Rust crates for high-performance Radial Basis Function (RBF)
interpolation, Fast Multipole Method (FMM) evaluation and isosurface extraction, with Python bindings.
The project comprises three main crates:
ferreus_rbf – Fast, memory-efficient global RBF interpolation in 1D, 2D and 3D.
ferreus_bbfmm – Parallel black-box Fast Multipole Method implementation for efficient kernel evaluation.
ferreus_rmt – Fast, surface-following isosurface extraction using regularised marching tetrahedra.
Version 0.3 introduces significant performance and memory improvements, alongside several new capabilities:
RBF fitting: Improved domain decomposition, automatic problem sizing and more efficient handling of smaller datasets, with six additional RBF kernels.
FMM evaluation: Optimised tensor-product operators, adaptive tree refinement, parallel evaluation and reduced memory usage. Added efficient regular-grid evaluation of values and gradients.
Isosurface extraction: Faster parallel extraction, reduced redundant evaluations and support for transformed sampling lattices, improving extraction of surfaces with thin features.
Performance: Significant improvements across fitting, evaluation and isosurface extraction, with benchmarks demonstrating up to 4.4× faster RBF fitting, approximately 4× faster evaluation and isosurface extraction, and reduced peak memory consumption compared with previous versions.
Community contributions: This release also welcomes two new contributors to the project, helping improve and expand its capabilities.
See the full release notes for further details.
la-stack 0.5.2
la-stack provides linear algebra for small, fixed dimensions in Rust, with a stack-backed floating-point core, no runtime dependencies by default, and optional arbitrary-precision arithmetic. Since v0.4.5, previously featured in August, it has expanded its support for exact computation and certified numerical bounds:
- Certified scalar calculations: Dot products and affine expressions such as axis · (left − right) now expose error bounds for sign and threshold decisions. Release details.
- Exact rational inputs and reductions: RationalMatrix and RationalVector support exact determinants and solves directly from rational inputs. New exact dot products also accept borrowed rational slices without an intermediate floating-point conversion. Rational inputs, exact dot products.
- Interval arithmetic and solution enclosures: Outward-rounded arithmetic supports determinant-sign certification through dimension seven, division by intervals excluding zero, and linear solution enclosures covering every system admitted by the input intervals. Inconclusive results explicitly leave room for caller fallback. Determinant certification, division and solves.
- Polynomial determinants: The optional exact feature now computes sparse univariate rational polynomial determinants through order eight, preserving cancellation exactly and enforcing caller-selected combinatorial work budgets. Release details.
- Rectangular column selection: A new allocation-free API selects candidate basis columns using an explicit absolute tolerance. Its numerical rank is provisional; exact certification remains the caller’s responsibility. Release details.
- Vector and geometry helpers: New capabilities include const-evaluable Gram matrices, overflow-safe Euclidean norms, and allocation-free unsigned vector angles that accommodate extreme magnitudes and tiny separations. Norms and angles return approximate results without certified error bounds. Norms and Gram matrices, vector angles.
Upgrading from v0.4.5 requires Rust 1.99.1. API changes include norm2_sq() → norm_squared(), inf_norm() → norm_inf(), and Matrix::solve_exact() returning RationalVector<D>. Migration details, toolchain update.
oximo v0.7.0
oximo is an algebraic modeling library for solving optimization problems in Rust. This release adds SOS1/SOS2 and indicator constraints, expands nonlinear expression support, and improves expression evaluation, sparse automatic differentiation, and large indexed model construction.
RustScenic 0.5.1
RustScenic exposes Rust implementations of gene-network inference, motif enrichment and activity scoring through Python. An interactive example lets readers inspect predicted regulator-target connections before installing the package.
The dense GRN binding
accepts a read-only NumPy array, obtains an ndarray view, and calls py.detach around inference;
the Rust core
parallelizes target jobs with Rayon.
Validation notes describe measured output
differences from the original SCENIC tools.
Publications
Manuel Drehwald, When Safe Code is Fast - Scientific Computing in Rust, Talk at RustConf 2026
The talk explores two new features of Rust:
computing derivatives with std::autodiff
and running code on GPUs via std::offload.
In both cases, safe Rust fares a lot better than unsafe Rust.
geo-ant, Powell’s Dogleg for Least Squares Minimization from Scratch
Everything you ever needed to know and more about actually implementing a nonlinear
least squares solver using the Dogleg method by the author of the
dogleg crate. Needs no prerequisites
and goes from the basics down to the nitty-gritty implementation details that
are often left out of such tutorials.
Alan Yuan, Hardware-Aware Programming in Rust
This post discusses practical tips for optimizing Rust code for high performance computing with respect to the hardware it runs on, with a specific focus on Apple M4 Pro Chips.
