Scientific Compting in Rust Monthly

Scientific Computing in Rust Monthly #20

24 Jul 2026 12:00:00 GMT

Welcome to this month's issue of Scientific Computing in Rust Monthly.

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: derive_more

crates.io ~ docs.rs ~ source

Rust has a lot of nice traits that are implemented for basic types, however, require usually some boilerplate to implement for your own types. The derive_more crate can help you with many of these implementations as it allows you to derive various traits for your types! Attributes allow you to specify the details of the derive and thus you can focus on your code instead on implementing traits.

New releases

interpn v0.11.2

InterpN is a crate allowing N-dimensional interpolation/extrapolation methods. Recent changes include the addition of B-spline methods for regular and rectilinear grids, implement analytic gradients for multidimensional methods, and speedups in other routines. See also the recent talk by James Logan for details on InterpN.

NSGA-RS v1.3.0

NSGA RS is a Rust framework for solving multi-objective optimisation problems using the NSGA family of multi-objective evolutionary algorithms (MOEAs). The crate includes:

Three built-in algorithms: NSGA2, NSGA3 (Deb & Jain, 2014) and AdaptiveNSGA3.
Flexible problem definition: minimise or maximise any number of objectives; constrained or unconstrained
Parallel evaluation: multi-threaded evaluation via Rayon
Resumable runs: export the full population history as JSON and resume from any checkpoint
Python bindings: exposes a PyO3 interface so you can wrap the library in your own Python package
Hypervolume metric: calculate hypervolume directly from individuals, values, or serialised JSON files
Flexible stopping conditions: stop by generation count, function evaluations, elapsed time, or combinations using Any / All

oximo v0.5.0

oximo is an algebraic modeling library for solving optimization problems in Rust. This release adds an automatic differentiation engine using std::autodiff (Enzyme, nightly only), a Pounce backend, IIS support, pretty-printing, and many other improvements including bug fixes, and quality-of-life changes.

syn v3.0.3

One of the most downloaded crates got a major update. Syn is a parsing library for parsing streams of Rust tokens into a syntax tree of Rust source code. The version 3 release contains adjustments to the syntax tree in order to account for ongoing language changes. A full changelog can be found here.

Publications

Matsakis N., Battery packs: Let's talk about crates, baby

Battery packs are an idea Niko has been kicking around on how to curate "starter packs" of crates for specific topics. This could surely be very interesting for scientific computing in Rust.

Trappitsch R., Testing drivers in instrumentRs v0.2.0

This is the second blog post in the instrumentRs series on designing a toolkit to write drivers for (scientific) instruments in Rust. This post discusses how to test drivers by mocking the communication interface and asserting that all expected bytes have been read and written.

Trappitsch R., Lakeshore 336 Temperature Controller Driver with instrumentRs v0.2.0

This is the third blog post in the instrumentRs series on designing a toolkit to write drivers for (scientific) instruments in Rust. This post discusses takeaways from implementing an instrument driver for a Lakeshore 336 temperature controller and presents required improvements to the instrumentRs design.

Jobs

PhD, Postdoc and Software Engineering positions, Aachen, Germany

We are looking for candidates with experience in the Rust programming language 🦀 for several positions at different levels!

Wanted expertise (you do not need to meet all criteria):

Programming language Rust 🦀 (most important)
Software development
Computer simulations
GPU/CUDA programming
Computational fluid dynamics (CFD)

Some of our current research topics:

Computational fluid dynamics
Acoustofluidics / Microfluidics
Sound-propelled microrobots
Ultrasound-controlled 3D-bioprinting
Acoustic levitation
Artificial neural networks

Where we work (Aachen, Germany):

Type of positions:

Software Developer / Research Software Engineer
Doctoral Researcher (PhD position)
Postdoctoral Researcher
Student Research Assistant (Bachelor/Master student)
Planned startup/spin-off 🚀
...

Availability of positions: Some positions now, more positions in the upcoming years.

You can find out more about our research topics here. If you're interested in a position as a scientist you can find more information here and if you're interesting in working as a software engineer take a look at our open positions here.

Miscellaneous

Scientific Computing in Rust 2026: Recordings

Recordings of talks given at the Scientific Computing in Rust 2026 workshop are now available on the YouTube channel. If you prefer a different view, the timetable of the workshop has also been updated to provide links to the recordings.

Scientific Computing in Rust Monthly #19

30 Jun 2026 12:00:00 GMT

Welcome to this month's issue of Scientific Computing in Rust Monthly.

This year's Scientific Computing in Rust annual workshop is just over a week away. The schedule for the workshop is available at scientificcomputing.rs/2026/timetable and it's not too late to register at scientificcomputing.rs/2026/register.

Crate of the month: hyperreal

crates.io ~ docs.rs ~ source hyperreal is a crate that provides exact rational arithmetic, symbolic real values, lazy computable real approximation, and conservative structural facts for the hyper ecosystem. If you'd like to hear more about hyperreal, be sure to attend this year's Scientific Computing in Rust annual workshop.

New releases

cog3pio v0.1.0

The first minor release of cog3pio - a Rust/Python library for reading GeoTIFF raster data - is out! Main highlight is the ability to do GPU-accelerated decoding of TIFF data via bindings to nvTIFF (see nvtiff-sys crate). The tensor data in CUDA memory can then be zero-copied across the Rust/Python boundary through the DLPack interchange protocol (using dlpark crate). Read more about the technical details and background motivation in this three-part blog series.

diffsol v0.14

diffsol is a Rust crate for solving ordinary differential equations (ODEs) and differential-algebraic equations (DAEs). The latest version includes:

Hybrid ODE support - the classical example is the bouncing ball, but other examples are dosing schedules for pharmacological models or policy-based switching for epidemic models
diffsol-c crate with dynamic dispatch & C FFI APIs for wrapping diffsol in other languages. pydiffsol is a Python wrapper that provides a nice example of how diffsol-c can be used in practice

ferreus_bbfmm v0.2.0

A black-box fast multipole method crate.

1D binary trees, 2D quadtrees, and 3D octrees
Adaptive and non-adaptive tree structures
Optimised low-rank M2L interactions using symmetry and compression
Support for multiple right-hand sides
User-defined kernels via traits
Optional simultaneous evaluation of kernel values and gradients, new in this release

ferreus_rbf v0.2.2

A fast global radial basis function interpolator.

Support for 1D, 2D, and 3D input domains
Scales to datasets with more than 1,000,000 source points, subject to hardware
Optional global trend transforms for capturing large-scale structure in the data
Fast 3D isosurface extraction using a surface-following regularised marching tetrahedra method
Optional simultaneous evaluation of RBF values and gradients
Built on faer for linear algebra, avoiding complex external dependencies

ferreus_rmt v0.1.0

A new regularised marching tetrahedra isosurfacing crate, now used by ferreus_rbf.

Regularised marching tetrahedra with vertex clustering
Surface-following extraction to reduce evaluation counts compared with full-volume sampling
Improved triangle quality compared with standard marching tetrahedra
Manifold, self-intersection-free mesh generation
Optional watertight extraction against an axis-aligned bounding box

oximo v0.3.0

oximo is a Rust algebraic modeling library for solving optimization problems, similar to Pyomo (Python) and JuMP (Julia).

At the moment, oximo supports building and solving LP/MILP models, with NLP/MINLP support planned for future releases. From a user perspective, only the main oximo crate is needed. However, the broader ecosystem is structured into multiple crates to simplify development and enable extensibility.

I would really appreciate any feedback, particularly on the API design. Having an ergonomic API with Rust's type system is hard, especially since I'm trying to avoid macros for now.

Events

Scientific Computing in Rust 2026, 8-10 July, held virtually

This year's Scientific Computing in Rust annual workshop is just over a week away.

The workshop features 10 minute talks on the use of Rust in a wide range of application areas, alongside tutorials, discussions and two longer invited talks. This year's invited talks will be given by:

Tom Meltzer, who will talk about using the mdb debugging tool with MPI parallelised Rust codebases.
Timothy Schmidt, who will talk about hyperreal and the hyper ecosystem.

You can register to attend by visiting scientificcomputing.rs/2026/register.

SciPy India x Rust Delhi Meetup, 22 August 2026, Noida, India

SciPy India and Rust Delhi are co-organising a technical meetup on scientific computing in Rust and Python. The sessions dig into real-world scientific problems and how people are solving them. The meetup runs from 2:00 PM to 5:00 PM at Essentia.dev in Noida, and the CFP is open to researchers, scientists, and developers (or anyone working at the intersection of Rust and Python) who want to present their work. You can submit a proposal or register at scipy.in/sci-py-rs.

Publications

Zhiqiu L., Agentics for Scientific Computing

Agentics is an open-source platform for executable computational-science challenges. This post discusses how Agentics can support Rust-based scientific-computing tools and research workflows by turning suitable problems into executable challenges where agents and humans can submit attempts, compare results, and preserve useful failures.

Trappitsch R., instrumentRs v0.2.0 design ideas

Blog post discussing design ideas for instrumentRs v0.2.0, a toolkit to develop drivers to control scientific instrumentation from Rust.

Help wanted

tenferro-rs

tenferro-rs is a Rust-native differentiable tensor stack for scientific computing, with dense tensors, eager and traced automatic differentiation (grad/vjp/jvp), NumPy/JAX-style einsum, linear algebra and FFT operation crates, and explicit CPU/CUDA/WebGPU backend control. The first crates were published to crates.io as v0.1 this month (a preview ahead of a stable 1.0), and the project leans on systematic validation: AD reference oracles, finite-difference checks, runnable examples, CI, and reproducible benchmarks. It is already the engine under tensor4all-rs, a Rust tensor-network stack.

We are looking for scientific-computing feedback and independent validation on real workloads: trying the examples and docs, reviewing AD and numerical behavior, checking backend limitations, and reviewing benchmark methodology in tenferro-benchmark. See the launch post for an overview.

Scientific Computing in Rust Monthly #18

22 May 2026 12:00:00 GMT

Welcome to this month's issue of Scientific Computing in Rust Monthly.

Crate of the month: hotpath

crates.io ~ docs.rs ~ source ~ www

Hotpath-rs is an easy-to-configure Rust performance profiler. It shows exactly where your code spends time, burns CPU, and allocates memory. Hotpath-rs helps you distinguish between functions that are slow because they wait on I/O and those that are CPU-intensive. Trying hotpath-rs out in self-profiling mode is as easy as typing ssh demo.hotpath.rs.

New releases

burn v0.21.0

After five pre-releases over the last three months, burn v0.21.0 was recently released. The gains span distributed workflows for training large models all the way down to small-model inference, where the reduced framework overhead becomes especially noticeable. Full release notes can be found on the GitHub release page.

cuda-oxide v0.1.0

Cuda-oxide is an experimental rustc backend for compiling CUDA GPU kernels written in pure Rust to PTX. It supports single-source Rust GPU programs where host and device code live together and are built through cargo oxide.

delaunay v0.7.8

Delaunay v0.7.8 provides D-dimensional Delaunay triangulations and convex hulls (2D through 5D explicitly tested) with PL-manifold (default) or pseudomanifold guarantees on finite point sets with Euclidean and toroidal global topologies. It uses exact predicates, Simulation of Simplicity, and Hilbert curves for robust degeneracy handling, deterministic insertion ordering, and efficient spatial indexing. It provides a 4-level validation hierarchy covering elements, data structure validity, manifold topology, and Delaunay adherence. It supports Pachner moves up to D=5 via bistellar flips, vertex insertion/deletion, and bounded flip/rebuild conversion of non-Delaunay triangulations. Auxiliary data may be stored in vertices and simplices, with external secondary maps for algorithm use, and the data structure is serializable/deserializable. Written in safe Rust with no unsafe code, it is inspired by CGAL and Spade and aims to be a lightweight, rigorous Rust-native option for workflows needing explicit topology settings, validation levels, deterministic construction controls, and repair behavior.

numra v0.1.4

numra is the umbrella crate of the Numra workspace, which consists of twenty native-Rust crates such as differential equations, optimization, sensitivity analysis, uncertainty quantification, linear algebra, and more. Dense linear algebra builds on faer; the rest is native Rust with no FFI to C or FORTRAN.

pluot v0.1.0

Pluot is a crate intended to facilitate the development of visualizations that can be rendered from multiple programming languages. This currently includes Rust, Python, and JavaScript. Further, Pluot aims to support both static and interactive use cases. For some demonstrations, see also the pluot website.

rayon v1.12.0

This new version of rayon contains a bug fix in parallel Range and added a new method ParallelSlice::par_array_windows. Details can be found in the release notes.

Events

Scientific Computing in Rust, 8-10 July 2026, held virutally

This year's scientific computing in Rust workshop is taking place on 8-10 July. The deadline for talk submissions is Friday 5 June: you can submit your talk at scientificcomputing.rs/2026/submit-talk.

Publications

Keller Mark S. and Gehlenborg Nils, Pluot: Towards 'write once, run everywhere' visualization software, arXiv 2605.14118

This manuscript describes Pluot, a crate to facilitate write-once, render in many places visualizations.

Pastel Arthur, 5× faster `fast_blur` in `image-rs`

An interesting algorithm discussion on a new fast_blur implementation in image-rs. The article discusses the algorithm itself, profiling of the previous implementation, as well as the design choices in the new version. Especially interesting is the analysis and discussion of how fast various CPU instructions are in comparison with each other.

Scientific Computing in Rust Monthly #17

27 Apr 2026 12:00:00 GMT

Welcome to this month's issue of Scientific Computing in Rust Monthly.

We're very excited to announce that this year's Scientific Computing in Rust virtual workshop will take place on 8-10 July. See the Events section below for more details.

Crate of the month: pastey

crates.io ~ docs.rs ~ source

The paste crate is a great tool for creating small macros. It very useful when (for example) wanting to write lots of tests with small differences between each test.

pastey is a well maintained fork of paste that allows you to do everything that paste did without relying on an unmaintained dependency.

New releases

kuva 0.1.6

kuva is a scientific plotting library for Rust that renders to SVG. It supports 30 plot types including specialised bioinformatics visualisations such as Manhattan plots, UpSet plots, and phylogenetic trees. A CLI is included for terminal-based rendering, with PNG and PDF output available via feature flags.

la-stack 0.4.1

la-stack is a library providing fast, stack-allocated linear algebra for fixed dimensions in Rust. Key recent changes:

Exact determinants are now up to ~40x faster according to benchmarking, and exact linear solves are up to ~3x faster in my measurements.
Stack-based exact arithmetic kernels
IEEE 754 bit decomposition, exact BigRational
Integer-only Bareiss determinant kernels
Hybrid Bareiss exact solve: fraction-free forward elimination in BigInt on (A | b), then back-substitution in BigRational
Direct use of f64_decompose in production exact-arithmetic paths

Example: D=5 det_exact has sped up from 164µs to 4.2µs (~39×)

ndelement, ndmesh and ndfunctionspace 0.4.0

ndelement, ndmesh and ndfunctionspace are three crates that handle fundamental parts of the finite element method: ndelement can be used to define and evaluate basis functions on a reference cell, ndmesh can handle meshes of polygonal and polyhedral cells, and ndfunctionspace can create function spaces by assigning global degrees-of-freedom (DOFs) to every cell in a mesh.

Note: in previous releases, ndmesh was named ndgrid.

unirand 0.2.0

The Marsaglia's Universal Random Number Generator was used in Fortran and C and this port to Rust started out so the author could port a C Simulation which used a Marsaglia RNG. New for version 0.2.0:

Implemented Iterator which enables idiomatic use of Rust iterator adaptors
Implemented rand_core::RngCore which integrates with the Rust random number ecosystem

unirand is based on "Toward a universal random number generator" by George Marsaglia, Arif Zaman, Wai Wan Tsang.

Events

Scientific Computing in Rust, 8-10 July 2026, virtual

This year's Scientific Computing in Rust virtual workshop will take place on 8-10 July. The three days of this workshop will feature a mixture of talks, tutorials and demos, and discussion sessions about a wide range of scientific topics. The workshop takes place between 13:00 BST and 17:00 BST each day, with the talks recorded and released on the Scientific Computing in Rust YouTube channel.

Talks and tutorials can be submitted at scientificcomputing.rs/2026/submit-talk. The deadline for submissions is Friday 5 June.

More information, free registration, and talk and tutorial submission forms can be found on the workshop's website at scientificcomputing.rs/2026.

RustMeet, 12-14 June 2026, Kraków, Poland

Second edition of RustMeet, the first Rust-dedicated programming conference in Poland. The three-day event features talks, workshops, and lightning talks, with online streaming available alongside the in-person programme.

Publications

Kyle M. Douglass, Ray-Surface Intersections with the Newton-Raphson Algorithm

A deep dive on ray-surface intersection calculations with the Newton-Raphson algorithm from a mathematical point of view. The article also discusses how the tracing crate helped find the issue and improve the Cherry Ray Tracer.

Scientific Computing in Rust Monthly #16

19 Mar 2026 12:00:00 GMT

Welcome to this month's issue of Scientific Computing in Rust Monthly.

Crate of the month: rstest

crates.io ~ docs.rs ~ source

rstest is a fixture based test framework for Rust. It uses procedural macros to allow writing of fixtures on table-based tests. This can be very useful, when you want to, e.g., test multiple values without rewriting the tests.

New releases

Cherry

Cherry is a sequential ray tracer for optical systems design that runs entirely in the browser and is written in Rust. An updated version of Cherry was recently published in which the original Javascript user interface was replaced with egui, an immediate mode GUI for Rust with WASM support. To try Cherry, click the link above and enjoy designing!

complex-bessel 0.1.0

A pure Rust implementation of the Amos (TOMS 644) algorithm for computing Bessel, Hankel, and Airy functions of complex argument and real order. No Fortran/C FFI dependencies required.

la-stack 0.3.0

la-stack is a fast, stack-allocated linear algebra package for fixed dimensions in Rust. Recent changes for v0.3.0 can be found here.

polars v0.53.0

Polars is an analytical query engine written for DataFrames. It is designed to be fast, easy to use and expressive. Highlights of this release include the addition of extension types. A full list of changes can be found here.

vforce 1.0.0

Vforce provides safe, no_std Rust bindings for the VForce family of hardware-accelerated vectorized math functions in the Accelerate framework on MacOS. It is generic over single and double-precision floats, and automatically chunks over very large arrays. Useful for speeding up transcendental functions on Apple hardware when working with 1-d arrays.

zarrs v0.23.6

zarrs is a Rust library for the Zarr storage format for multidimensional arrays and metadata. Recent changes since v0.23.0 (Feb 1, 2026), can be found here.

Publications

N. R. Posner, When Vectorized Arrays Aren't Enough

An exploration of Rust optimizations made to a Python astrophysics simulation, from bytecode to assembly. Provides examples and builds intuition on how and when to deploy lower-level solutions to avoid NumPy's intermediate allocations.

Scientific Computing in Rust Monthly #15

13 Feb 2026 12:00:00 GMT

Welcome to this month's issue of Scientific Computing in Rust Monthly.

Crate of the month: approx

crates.io ~ docs.rs ~ source

approx is a really useful crate for whenever you're writing unit tests for scientific code, as it contains helpful macros like assert_relative_eq that check if two items are equal within a given tolerance. If you like the approx crate, keep reading, as there's an opportunity to help with its maintenance in the "help wanted" section below.

New releases

Polyfit 0.10.1

Polyfit is a high-performance, easy-to-use polynomial fitting library for Rust, designed to make curve fitting accessible to software engineers without a background in statistics. It is generic over data type, as well as 11 choices of basis. It supports symbolic calculus, root-finding, and a spectral energy filter for orthogonal bases. It is high-performance, able to perform a 100-million-row 3rd-degree Chebyshev fit in ~1s on moderate consumer hardware.

Help wanted

approx `0.6.0`

The approx crate is planning a new release 0.6.0 with a large set of new features. This update contains many improvements such as derive macros and additional implementations for core and external types (i.e. Option, OrderedFloat etc.). Due to the amount of additions, we are hoping for testers of the release candidates 0.6.0-rc2 and following before releasing 0.6.0 into the wild.

Scientific Computing in Rust Monthly #14

21 Jan 2026 12:00:00 GMT

Welcome to this month's issue of Scientific Computing in Rust Monthly and happy 2026 to everyone!

Crate of the month: measurements

crates.io ~ docs.rs ~ source

The measurements crate allows you to represent physical quantities. You can get your quantities in different, compatible units and perform arithmetic operations. measurements is no-std compatible. Thus, you can even use proper units in your embedded projects! This crate has a small footprint and is highly useful to avoid common errors of, e.g., forgetting unit conversions, which can be very costly (e.g., Mars Climate Orbiter).

New releases

Bevy 0.18.0

Bevy is a data-driven game engine built in Rust. This release includes numerous new features, bug fixes, and quality-of-life improvements. A detailed blog post can be found here.

Burn 0.20.0

Burn is a tensor library and deep learning framework optimized for numerical computing,m model interference, and model training. This release features major performance improvements thanks to the introduction of CubeK.

InterpN 0.11.0

InterpN is an n-dimensional interpolation/extrapolation methods library that is no-std compatible. This release provides some behind-the-scenes improvements. Notably, all methods are now compatible with static analysis of memory usage and early bounds checks were improved.

rlst 0.6.1

The Rust Linear Solver Toolbox rlst provides dense and sparse linear algebra routines in Rust. Since the last newsletter, version 0.5 and 0.6 have been released, adding various methods, functions, and interfaces. Details can be found in the release notes here.

Publications

Irving B., et al., Mantaray: A Rust Package for Ray Tracing Ocean Surface Gravity Waves, Journal of Open Source Software, 10(116)

Mantaray is a open-source Rust package with a Python interface that solves the ray equations for ocean surface gravity waves. It is designed for performance, robustness, and ease of use. Mantaray can currently be applied to idealized and realistic wave propagation problems.

Wenger, A. (@fasterthanlime), The science of loudness

In this blog post, Amos walks the reader through the physics of the science of sound, loudness, noise, and the associated units. The follow up article Making our own spectrogram builds on this and shows how to make a spectrogram in Rust. This is a very accessible introduction and contains many fun animations and code snippets.

Help wanted

Goombay-rs

Goombay-rs is the Rust implementation of my Goombay library. Goombay is a sequence alignment library with over 20 algorithms written entirely in python. My initial goal with Goombay-rs is to implement the algorithms that are present in the python version of the library. The secondary goal of the library would be to speed up computation time where possible while still maintaining the core fundamentals of each algorithm. A tertiary goal of the project is to include the ability to pip install the project to be used in Python. Spindalis (which also has open issues) is the primary dependency for Goombay-rs used for matrix manipulation.

Miscellaneous

CocoIndex

An open-source, data transformation framework with its core engine written in Rust, designed for building and maintaining continuously updated indexes over large datasets. CocoIndex supports incremental processing and provides data lineage tracking, making it well-suited for scientific workflows involving evolving research data. Potential applications include indexing academic papers with structured metadata extraction, building knowledge graphs from research outputs, and creating semantic search capabilities over scientific literature. The framework uses a dataflow programming model and integrates with various databases including PostgreSQL and vector databases for semantic search applications. Community discussion and support available on Discord.

Scientific Computing in Rust Monthly #13

22 Dec 2025 12:00:00 GMT

Welcome to this month's issue of Scientific Computing in Rust Monthly.

Crate of the month: num

crates.io ~ docs.rs ~ source

A crate that includes a collection of types and traits for different number types including big integers, rational numbers and complex numbers, as well as general numeric properties like Integer.

New releases

crate2bib 0.7

Convert a given crate and (optional) version number to a BibLaTeX entry. It scans for existing CITATION.cff files within the repository and also generates entries from the information available at crates.io. The tool can be used as a webapp, python package, command-line utility or Rust crate (see also preprint).

DeepCausality 0.12

DeepCausality started out as a project in advanced computational causality for static and dynamic multimodal causal models, but its most recent release contains a new foundation that comes combined with multiple unified math libraries for:

Geometric Algebra
Differential Topology
Sparse Matrix representation
Tensor Operations including ein_sum

Geometry, topology, sparse matrices, and tensor operations seamlessly compose with each other and thus form the foundation of the new physics crate, a pure Rust implementation of physics formulas across different fields, such as:

Astrophysics: Astrophysics kernels (Schwarzschild radius, orbital velocity, luminosity, Hubble's law, etc.).
Dynamics: Classical mechanics (Kinematics, Newton's laws), state estimation (Kalman filters), and Euler integration.
Electromagnetism: Maxwell's equations, Lorentz force, Poynting vectors, and gauge fields using Geometric Algebra.
Fluids: Fluid dynamics (Bernoulli's principle, Reynolds number, viscosity, pressure).
Materials: Material science properties (Stress, Strain, Hooke's Law, Young's modulus, thermal expansion).
Relativity: Einstein tensors, geodesic deviation, spacetime intervals.
Thermodynamics: Heat diffusion, entropy, partition functions.

The DeepCausality project provides a rich set of code examples for a variety of use cases:

Classical Causal inference, e.g., CATE, DBN, Granger, RCM, SCM
Multi-physics simulations, e.g., Electromagnetism, GRMHD, Particle Physics, etc.
Medicine, e.g., Protein Folding, MRI Tissue Classification, etc.
Material science, e.g., Metamaterials, Topological Insulator, etc.
Avionics: MagNav, Geometric TCAS, etc.

The DeepCausality project invites, physicists engineers, and scientific computing experts from all fields of science and technology to collaborate with us on advancing Rust for scientific computing. The DeepCausality Discord Server is the best place to get started.

ferreus_bbfmm 0.1.0

ferreus_bbfmm is a parallel implementation of the Black Box Fast Multipole Method (BBFMM). BBFMM is a kernel‑independent, hierarchical algorithm for rapidly evaluating all pairwise interactions in a collection of particles.

While originally developed as the fast evaluator for radial basis function (RBF) interpolation, this crate has been generalised to support a broad range of FMM use‑cases where the kernel is smooth (i.e. non‑oscillatory).

Features - 1D (binary tree), 2D (quadtree) and 3D (octree) trees - Optimised low‑rank M2L interactions that leverage symmetries and compression - Adaptive and non‑adaptive tree structures - Support for multiple right‑hand sides - Designed to work with user‑defined kernels via traits - Built on faer for linear algebra, avoiding complex external dependencies - Python bindings and docs available

ferreus_rbf 0.1.0

ferreus_rbf is a fast, memory-efficient, global radial basis function (RBF) interpolation crate written in Rust.

Direct RBF solvers based on dense linear algebra require O(N²) memory and O(N³) work, which quickly becomes impractical beyond tens of thousands of points. ferreus_rbf provides a scalable alternative suitable for millions of points in up to three dimensions.

Features - Supports 1D, 2D and 3D input domains - Scales to datasets with over 1,000,000 source points (subject to hardware) - Optional global trend transforms to capture large‑scale structure in the data - Fast 3D isosurface extraction using a surface‑following, non‑adaptive Surface Nets method - Built on faer for linear algebra, avoiding complex external dependencies - Python bindings and docs available

rsl-interpolation v0.1.16

A re-write of GSL's Interpolation in Rust, a library for interpolating over 1D and 2D arrays, with 1st, 2nd and mixed derivative calculation and 1D numerical integration.

Implemented features:

'Linear', 'Cubic', 'Akima', 'Akima Periodic' and 'Steffen' 1D interpolation types
'Bilinear' and 'Bicubic' 2D interpolation types.
Index look-up Acceleration
Low level interface (interpolation functions)
High level interface (splines)

All of GSL's tests have been transferred, and new ones have been added with values calculated directly from GSL's routines, ensuring that the results are in agreement with GSL to machine precision.

rlst v0.4.0

rlst (Rust Linear Solver Toolbox) 0.4 is the first release of the library that we consider suitable for external users.

It is a feature-rich linear algebra library that includes:

A multi-dimensional array type, allowing for slicing, subviews, axis permutations, and various componentwise operations
Arrays can be allocated on either the stack or the heap. Stack-allocation well suited for small arrays in performance critical loops where heap-based memory allocation should be avoided.
BLAS interface for matrix products, and interface to a number of Lapack operations for dense matrix decompositions, including, LU, QR, SVD, symmetric, and nonsymmetric eigenvalue decompositions
Componentwise operations on array are using a compile-time expression arithmetic that avoids memory allocation of temporaries and efficiently auto-vectorizes complex componentwise operations on arrays.
A sparse matrix module allowing for the creation of CSR matrices on single nodes or via MPI on distributed nodes
Distributed arrays on distributed sparse matrices support a number of componentwise operations
An initial infrastructure for linear algebra on abstract function spaces, including iterative solvers. However, for now only CG is implemented. More is in the work.
Complex-2-Complex FFT via interface to the FFTW library.
A toolbox of distributed communication routines built on top of rsmpi to make MPI computations simpler, including a parallel bucket sort implementation.

Publications

Carl Kadie, Nine Rules for Scientific Libraries in Rust: How to Build Scientific Libraries that are Correct, Usable, and Fast

Scientific Computing in Rust Monthly #12

14 Nov 2025 12:00:00 GMT

Welcome to this month's issue of Scientific Computing in Rust Monthly.

Crate of the month: InterpN

InterpN provides numerical interpolation for realtime and bare-metal embedded systems. It is available as a Rust crate and as a Python package. InterpN achieves up to 200x speedup when compared to SciPy, a general standard in the scientific community. More information can be found in this very recent blog post by James Logan.

crates.io ~ docs.rs ~ source

New releases

Burn 0.19.1

Burn is both a tensor library and a deep learning framework optimized for numerical computing, model inference, and model training. The 0.19.0 and 0.19.1 releases bring major improvements to enable efficient distributed training, quantization, and CPU support.

interpn v0.8.1

InterpN is a low-latency numerical interpolation library for realtime and bare-metal embedded systems and scientific computing.

This month's releases significantly improve performance, now surpassing all methods used in Scipy and numpy including the specialized methods for 1D and 2D across all conditions.

ndarray 0.17.1

ndarray provides an n-dimensional container for general elements and numerics in Rust. This release introduces a new array reference type.

measurements 0.11.1

A lean library to handle physical quantities as typed measurements. Measurements is [no_std] compatible and supports simple unit conversions and operator overrides to work with measurements directly. The 0.11.1 release adds support for additional pressure units.

Polars 0.52.0

Polars is an analytical query engine written for data frames. Highlights of this release include the addition of LazyFrame.{sink,collect}_batches and deterministic import order for Python Polars package variants.

Zarrs 0.22.7

Zarrs is a Rust library for the Zarr storage format for multidimensional arrays and metadata. Mutliple releases add functionality to Array, node, Group, and DataType, as well as hierarchy module.

Events

Scientific Computing Track @ Rust NYC UnConf 2025, 5 December 2025, New York City

Join us to explore the emerging world of scientific computing in Rust. We'll discuss interoperability with other languages, improving accessibility for scientists, best practices, community, and more. We invite you to come and share experiences, challenges, and ideas for shaping this field. Registration, more info, and a complete list of tracks are available at www.meetup.com/rust-nyc/events/311757146/

Publications

Heim G. M., GlobalSearch-rs: A multistart framework for global optimization written in Rust

This paper presents GlobalSearch-rs, an open-source library written in Rust that implements a multistart framework for global optimization of NLP problems.

Hovey C. B. and Buche M. R., automesh: Automatic mesh generation in Rust

This paper presents automesh, an open-source Rust software program that uses a segmentation that is typically generated from a 3D image stack to create a finite element mesh composed either of hexahedral (volumetric) or triangular (isosurface) elements.

Logan J., InterpN: Fast Interpolation

A blog post describing the algorithms and performance engineering behind interpn, with reusable patterns applicable to almost any high-performance Rust or Rust-Python scientific computing library.

Come for the compile-time loop unrolling, stay for the profile-guided optimization!

Scheidwasser N., et al., phylo2vec: a library for vector-based phylogenetic tree manipulation

This paper presents the latest release of phylo2vec, a high-performance software package for encoding, manipulating, and analyzing binary phylogenetic trees.

Stöckli L. L., et al., THz Image Explorer - An Interactive Cross-Platform Open-Source THz Image Analysis Tool

This paper presents a ThZ time-domain spectroscopy analysis tool for interactive data analysis written in Rust.

Help wanted

Seq.rs

Seq.rs is a website that is a showcase of the work being done in bioinformatics using Rust. Each month, there is a theme with related crates, a research paper summary, and a monthly coding challenge.

I specifically need help with coming up with coding challenges, which will then be posted to the companion GitHub, but help with any part of the project would be greatly appreciated! The easiest way to get involved is through the GitHub discussions page or on discord!

spindalis

Spindalis is a bioinformatics-focused library for numerical modeling, optimization, data analysis, and simulation written. This library is still in early-stage development but is intended to make working with algorithms commonly used in bioinformatics (and other areas) as simple to use as possible.

There are issues posted for the next items to be added to the library. If you're interested in helping, don't hesitate to check out the repository! Any help, ideas, or questions are welcome!

Scientific Computing in Rust Monthly #11

16 Oct 2025 12:00:00 GMT

Welcome to this month's issue of Scientific Computing in Rust Monthly.

Crate of the month: Rayon

Rayon is a data-parallelism library that helps users to convert computations from sequential into parallel. If you've not used Rayon before, we recommend starting by watching Gonzalo Brito's talk about using Rayon from Scientific Computing in Rust 2023.

crates.io ~ docs.rs ~ source

New releases

argmin 0.11.0

argmin is a pure Rust library for numerical optimization.

This release includes various bug fixes and improvements. With the release of argmin-math 0.5.0, argmin now supports new versions of ndarray and nalgebra versions as well as faer.

linfa 0.8.0

linfa is a Rust crate that aims to provide a comprehensive toolkit to build Machine Learning applications with Rust.

This release includes new algorithms, improvements to existing algorithms, various bug fixes and support for ndarray 0.16.0.

globalsearch 0.3.0

globalsearch is a Rust library for global optimization.

This release includes new Python bindings and support for new local solvers as well as various bug fixes and improvements.

Help wanted

InstrumentRs

InstrumentRs is a library in early-stage development that provides a framework for communicating with scientific instruments and equipment. The main goal is to provide a simple framework with good templates to rapidly develop new drivers to control instruments with Rust. Many design and direction questions are open, e.g.:

Should we provide synchronous or asynchronous drivers?
Could we provide both?
Should instrument control, e.g., for individual channels of a device, be shareable between threads/tasks?
How can we make the library such that std is optional and drivers would work as well on embedded devices?

If you are interested in driving scientific equipment with Rust, please check out the repository, join existing discussions, and/or open new ones to discuss ideas! Any help, ideas, questions are welcome and help!

multicalc

The main goal for multicalc is to provide high accuracy solutions for single and multi-variable calculus. We're looking for contributors who enjoy doing math, and love writing rust. The github repository has an extensive README and a comprehensive suite of tests.

If you are interested in helping, please check out the repository, join discussions, and/or open new ones to discuss ideas! Any ideas or questions are welcome!

Scientific Computing in Rust newsletter editors

We're looking for an additional 1-2 people to become editors of this newsletter. Being an editor of the newsletter means taking charge of putting together an issue of the newsletter every few months, by encouraging and reviewing items added by the community. If you're interested in becoming one of the editors, please email Matthew Scroggs at rust@mscroggs.co.uk. If you have any queries or questions, you can email or message Matthew on the Rust-SciComp Zulip chat.

Scientific Computing in Rust Monthly #10

10 Jul 2025 12:00:00 GMT

Welcome to this month's issue of Scientific Computing in Rust Monthly.

It's been a busy month since the last newsletter, with this year's annual Scientific Computing in Rust workshop taking place in July - if you missed it, you can find recordings of all the talks on the Scientific Computing in Rust YouTube channel.

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. We're looking for volunteers to become editors of this newsletter: if you're interested, you can find more information in the "Help wanted" section below.

Crate of the month: cargo-upgrades

crates.io ~ docs.rs ~ source

This month's crate of the month isn't explicitly a scientific computing tool, but it's still really useful. cargo-upgrades is a cargo extension that can be used to check if your crate's dependencies are up to date with the most recent stable releases. We recommend getting your CI to run this to give you a nudge when one of your dependencies has a new release you can update to.

New releases

approx-derive 0.2.6

Derive macros for the popular approx crate.

approxim 0.6.6

Fork of the approx crate which includes many PRs and extended functionality (such as derive macros, support for optionals, etc.) The original crate has not been updated since ~3 years.

indexing_fmt 0.1.1

A helper crate for formatting superscripts and subscripts. Especially helpful when formatting variable names automatically.

ndelement 0.3.0

A new version of the finite element definition library ndelement has been released. This new version adds implementations of Piola transforms to map element values to physical cells, and DOF transformations as described in this 2022 paper by Scroggs et al.

Quant-Iron 1.1.0

A high-performance, hardware-accelerated modular quantum computing simulator library with a focus on physical applications. Quant-Iron provides tools to represent quantum states, apply standard and customised quantum gates, perform measurements in multiple bases, build quantum circuits, implement quantum algorithms and represent and evolve quantum many-body systems using Ising models, Heisenberg models, and Trotter-Suzuki decomposition and time evolution.

repgenerate v0.1.0

repgenerate is a Rust library that can generate illumina sequencing reports for any Illumina genetics sequencing platform.

sequenceprofiler v0.1.0

seqeuenceprofiler is a Rust library for genetics sequencing.

Events

Scientific Computing in Rust 2025, recordings of talks

It's just over a month since this year's Scientific Computing in Rust virtual workshop took place. Recordings of all the talks from the workshop are available on the Scientific Computing in Rust YouTube channel, or you can find links to all the recordings at scientificcomputing.rs/2025/timetable

Publications

Jonas Pleyer, Christian Fleck, "cellular_raza: Cellular Agent-based Modeling from a Clean Slate", Journal of Open Source Software (JOSS)

cellular_raza is a cellular agent-based modeling framework which allows researchers to construct models from a clean slate. In contrast to other agent-based modeling toolkits, cellular_raza was designed to be free of assumptions about the underlying cellular repre- sentation. This enables researchers to build up complex models while retaining full control over every parameter introduced. It comes with predefined building blocks for agents and their physical domain to quickly construct new simulations bottom-up. Furthermore, cellular_raza can be used with the pyo3 and maturin packages and thus act as a numerical backend to a Python package.

Help wanted

Scientific Computing in Rust newsletter editors

Scientific Computing in Rust Monthly #9

3 Jun 2025 12:00:00 GMT

Welcome to this month's issue of Scientific Computing in Rust Monthly.

It's the week of this year's workshop! It's taking place from 13:00 to 17:00 BST (UTC+1) on Wednesday to Friday. If you've not registered to attend yet, head over to scientificcomputing.rs/2025/register.

Crates of the month: Bevy and Burn

Bevy

crates.io ~ docs.rs ~ source

Bevy is a game engine built in Rust. As well as being used to make games, it's being used for scientific simulations and visualisations. Alice Cecile, one of the developers of Bevy will be giving an invited talk at this year's workshop.

Burn

crates.io ~ docs.rs ~ source

Burn is a deep learning framework written in Rust. Nathaniel Simard, one of the developers of Burn will be giving an invited talk at this year's workshop.

New releases

ensemblcov v0.1.0 and vcfilter v0.1.0

ensemblcov and vcfilter are multithreaded tools for handling ensembl and vcf files.

Events

Scientific Computing in Rust, 4-6 June 2025, held virtually

The 2025 edition of the Scientific Computing in Rust virtual workshop will take place on 4-6 June 2025. Sessions will run between 13:00 and 17:00 BST each day. Registration is free and can be done at scientificcomputing.rs/2025/register.

The full timetable for the workshop can be found at scientificcomputing.rs/2025/timetable.