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

crates.io ~ docs.rs ~ source

Proptest is a hypothesis-like property-based testing and shrinking crate. It allows you define various strategies and combined strategies to bring your crate testing to the next level.

We recommend checking out the proptest book to get started.

New releases

cauchy-ode v0.1.0

This package numerically solves Cauchy's initial value problems for ordinary differential equations and systems. Its solver integrates expressions with the adaptive England, Lawson, and Rosenbrock methods.

fearless_simd v1.0.0

After eight years of prototyping, fearless_simd has gone v1.0.0. This package enables high-performance SIMD without forcing you to abandon safety or readability.

Publications

Kim Tae-Geun et al., Peroxide: A Batteries-Included Numerical Computing Library for Rust, JOSS, 11(124)

Peroxide is a Rust numerical computing library that integrates eight domains in one crate: linear algebra, ordinary differential equation (ODE) solving, adaptive quadrature, spline interpolation with exact polynomial calculus, root-finding, forward-mode automatic differentiation (AD), statistics, and multi-format DataFrame I/O.

Koundinyan Sri, Elibol Melih, and Bentz Jonathan, Introducing CUDA Rust: Two Tracks for Writing GPU Kernels

A brief introduction on writing GPU kernels with hands-on examples on using cutile-rs and cuda-oxide.

Otálvaro Julián D. et al., pharmsol: A high-performance Rust library for pharmacokinetic and pharmacodynamic modeling and simulation, JOSS, 11(124)

Pharmsol is a library for pharmacokinetic/pharmacodynamic (PK/PD) simulation. It provides the necessary tools and frameworks for defining, solving, and analyzing compartmental models, with support for differential equations, their analytical solutions, and experimental support for stochastic differential equations.

Shnatsel, Fearless SIMD v1.0 is here

A blog post that goes along with the fearless_simd v1.0.0 release, see above.

Trappitsch Reto, Controlling an SMC HRR chiller via MODBUS

This is the fifth blog post in the instrumentRs series on designing a toolkit to write drivers for (scientific) instruments in Rust. This post discusses writing a driver for SMC HRR chillers, which communicate via MODBUS RTU.

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

crates.io ~ docs.rs ~ source

CubeCL is a Rust language extension, a Just-in-Time compiler, and a set of runtimes for writing high-performance compute kernels. Functions defined using #[cube] can be compiled on demand to CUDA, HIP, Metal, SPIR-V, WGSL, or CPU SIMD.

We recommend starting by looking at the examples in the CubeCL GitHub repository.

New releases

AXbit v0.1.0

AXbit is an experimental visual astrodynamics lab for SPICE/SBDB-based Solar System exploration, small-body trajectory propagation, and close-approach analysis and visualization. It is built with wgpu.

It combines NASA/JPL SPICE ephemerides and SBDB small-body data with numerical propagation and interactive 3D visualization. The first packaged release currently targets Apple Silicon Macs.

The project is still at an early stage: the feature set is limited, the visuals are not so stunning, and substantial work remains on numerical validation and accuracy.

AXbit is looking for contributors interested in numerical validation, astrodynamics and reference frames, low-level graphics and visualization, and the development of useful analysis tools.

delaunay v0.8.1

delaunay provides D-dimensional Delaunay triangulations and convex hulls with exact predicates, deterministic degeneracy handling, and explicit topology validation. Highlights of v0.8.1 include:

• Verified scientific checkpoints with SHA-256 digests, exact coordinate bits, topology and proof metadata, complete f-vectors, and Euler characteristics. Restoration rejects malformed or tampered evidence and revalidates the result through all five validation levels.
• A clearer proof-oriented API: Triangulation owns Levels 1–4, through valid geometric realization, while DelaunayTriangulation adds Level 5 Delaunay certification. Failure-atomic builders govern transitions between these layers.
• Faster validation: certified Euclidean point sets gain a linear-in-simplices Level 5 reporting path with exhaustive fallback diagnostics. Optimized Level 4 realization checks are independently cross-validated in 2D–5D.
• Improved diagnostics through named public error fields and more specific typed failures.

This release includes breaking API changes and raises the MSRV to Rust 1.98. See the full release notes.

et-rs et-k-rs et-abi v0.2.0

Pure-Rust tooling for the Esperanto ET-SoC-1 RISC-V accelerator: a host driver, a device-side kernel library, and the ABI they share.

| Crate | Library | Side | Role | |-------|---------|------|------| | et-abi/ | et_abi | shared (no_std) | Launch-argument structs plus shared constants (cache line, geometry), defined once so host and device cannot drift. | | et-rs/ | et_soc1 | host (std) | Loads kernels, launches them on shires, moves results over DMA, decodes trace buffers. Pure Rust, no vendor C++ runtime. | | et-k-rs/ | et_kernel | device (no_std) | Library for writing ET-SoC-1 compute kernels in Rust, plus demo kernels. |

et-rs and et-abi are host crates and form the workspace; default-members makes bare cargo commands operate on et-rs. et-k-rs cross-compiles to riscv64imac with its own target configuration, so it is excluded from the host workspace and built from its own directory. Both et-rs and et-k-rs depend on et-abi; neither depends on the other.

There is also an example/tutorial on GitHub to get you started: github.com/mathsDOTearth/test-et-rs

la-stack 0.4.5

la-stack provides fast, stack-allocated linear algebra for fixed dimensions in Rust, with no runtime dependencies by default and optional exact arithmetic. v0.4.5 focuses on numerical correctness and reproducible performance evidence:

• Determinant overflow is now surfaced even when the corresponding error-bound terms underflow.
• Checked determinant queries for D≥5 aggregate range proofs before a single scaled replay, reducing overhead while preserving existing error behavior.
• Performance reports are now retained as deterministic CSV with schema-versioned provenance, allowing published benchmarks to be validated and re-rendered from the measured artifacts.
• The MSRV is now Rust 1.98.0. The new algebraic floating-point operations are intentionally forbidden in repository-owned numerical code to preserve documented evaluation order, error bounds, exact fallbacks, and reproducibility.

The full changes are available in the v0.4.5 release notes.

oximo v0.6.0

oximo is an algebraic modeling library for solving optimization problems in Rust. This release expands its model interchange, solver result reporting, and solving stack with readers for LP, MPS, and NL files, automatic convex solver routing in POUNCE, more cross-backend result metadata, and Enzyme automatic differentiation support for WebAssembly.

PhastFT v0.4

PhastFT is a performant Fast Fourier Transform implementation in pure Rust with no unsafe code.

Full details of the latest release can be found in this Reddit post.

Events

RustConf, 8-11 September 2026, Montreal, Canada & Online

RustConf is turning 10! The original Rust programming language conference is taking place September 8–11 in Montréal, Canada, with both in-person and virtual attendance options.

The schedule is packed with technical talks, hands-on workshops, project updates, a Career Crawl, an UnConference, and lots of community discussions covering the latest developments across the Rust ecosystem.

Join us to see what the Rust community is building, dig into the topics defining the next decade of computing, and discover ideas you can bring back to your own projects.

Publications

Sergey "Shnatsel" Davidoff, Safe SIMD in Rust, even on the inside

M. S. Drehwald, M. Dominguez, K. Sala, A. Aspuru-Guzik, J. Doefert, GPU Offload in Rust: Portable, Safe, and Fast

R. Trappitsch, InstrumentRs: #[derive(Parameter)]

This is the fourth blog post in the instrumentRs series on designing a toolkit to write drivers for (scientific) instruments in Rust. This post discusses the implementation ans usage of a derive macro that makes makes instrument control with new types simple.

Help wanted

oximo

The project is looking for contributors interested in mathematical programming. There are good first issues available for contributors who would like to get started.

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

• RWTH Aachen University
• DWI - Leibniz Institute for Interactive Materials

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.

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.

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

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: 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<char> 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.

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.

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: 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<Item = f32> 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.

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

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: 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<T>, OrderedFloat<F> 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.

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

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

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

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

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