nanoexpr: math expression evaluator for embedded Rust

Parse and evaluate math formulas typed at run time, on a microcontroller, without a heap. nanoexpr is a tiny no_std math expression parser and evaluator for Rust and C: it computes "2 * (3 + 4) ^ 2 / sqrt(16)" in a single pass, with zero heap allocation, bounded stack use and errors that point at the faulty part of the input.

assert_eq!(nanoexpr::evaluate::<f64>("2 * (3 + 4) ^ 2 / sqrt(16)"), Ok(24.5));

Why nanoexpr?

Letting users type a formula is common: a calculator app, a sensor conversion set in the field (raw * 0.0125 - 40), an alarm threshold, a spreadsheet cell, a game stat. Most expression crates are built for desktops: they need std, allocate a syntax tree and strings on every call, and turn bad input into NaN or a panic. On a microcontroller that means heap fragmentation, unpredictable memory use and crashes. nanoexpr is built for those constraints instead, and is faster than the others even on a desktop.

Use it for:

• Calculator apps on handhelds, watches and embedded GUIs, with TI-style decimal numbers and a percent key.
• Sensor formulas and unit conversions configured without reflashing the firmware.
• Thresholds, scaling and business rules stored as text in a configuration file or a database.
• WebAssembly and plugins, where a small binary and no allocator matter.

Features

• No heap, ever. No alloc, no syntax tree, no token buffer: the expression is computed while it is parsed. A test with a counting allocator checks it.
• Bounded stack. Nesting is limited (32 levels by default, configurable) so hostile input cannot overflow the stack, and call arguments live in a fixed-size array.
• Any number type. f32, f64, every primitive integer, or your own type (fixed-point...) through the Number trait. Integers report overflow instead of wrapping.
• Calculator-exact decimals. The optional Decimal type computes in decimal like TI and Casio calculators: 14 significant digits and exponents up to ±99 by default, so 0.1 + 0.2 is exactly 0.3.
• Variables and functions from your code. The evaluator asks a Context for each name it meets: implement the trait, pass (name, value) pairs, or wrap closures. Contexts compose as tuples.
• Scientific functions included. Math provides pi, e, sqrt, sin, cos, tan, exp, ln, log, min, max, clamp, rounding and more.
• Errors you can show. A Copy error with a kind to match on (and translate) and the byte span of the input that caused it. Division by zero, domain errors and overflow are errors, not silent NaN or infinities.
• Calculator-friendly syntax. ^ and ** are right-associative (2^3^2 = 512), -2^2 = -4, and % can be a percentage (200 * 15% = 30) instead of the remainder.
• C and C++ bindings with a header and a CMake project, still allocation-free.
• No dependencies besides the optional libm, and no unsafe code in the evaluator.

Usage

[dependencies]
nanoexpr = "0.1"

Variables and functions

use nanoexpr::{ErrorKind, Functions, Math};

let variables = [("raw", 2150.0), ("offset", -40.0)];
let functions = Functions(|name: &str, arguments: &[f64]| match (name, arguments) {
    ("celsius", [kelvin]) => Some(Ok(kelvin - 273.15)),
    ("celsius", _) => Some(Err(ErrorKind::ArgumentCount)),
    _ => None,
});
let context = (variables, (functions, Math));

assert_eq!(nanoexpr::evaluate_with("raw * 0.0125 + offset", &context), Ok(-13.125));
assert_eq!(nanoexpr::evaluate_with("round(celsius(300))", &context), Ok(27.0));

For full control, implement Context on your own type:

use nanoexpr::Context;

struct Sensors {
    readings: [i32; 4],
}

impl Context<i32> for Sensors {
    fn variable(&self, name: &str) -> Option<i32> {
        let index: usize = name.strip_prefix("s")?.parse().ok()?;
        self.readings.get(index).copied()
    }
}

let sensors = Sensors { readings: [12, 30, 7, 1] };
assert_eq!(nanoexpr::evaluate_with("(s0 + s1 + s2) / 3", &sensors), Ok(16));

Errors

use nanoexpr::{ErrorKind, Span};

let error = nanoexpr::evaluate::<f64>("1 + 4 / (2 - 2)").unwrap_err();
assert_eq!(error.kind, ErrorKind::DivisionByZero);
assert_eq!(error.span, Span::new(4, 15));
assert_eq!(error.to_string(), "division by zero at 4..15");

Calculator mode and limits

use nanoexpr::{Evaluator, Math, PercentSign};

let calculator = Evaluator::<_, 4>::new(&Math)
    .percent_sign(PercentSign::Percentage)
    .max_depth(16);

assert_eq!(calculator.evaluate::<f64>("200 * 15%"), Ok(30.0));
assert_eq!(calculator.evaluate::<f64>("10 mod 4"), Ok(2.0));

The second generic parameter is the most arguments a call can take (8 by default).

Decimal numbers, like a pocket calculator

Binary floats cannot represent most decimal fractions, so 0.1 + 0.2 is 0.30000000000000004 as an f64. Calculators compute in decimal instead. With the decimal feature, Decimal does the same: a decimal floating-point number of 14 significant digits with exponents up to ±99 by default, as on TI-83 and TI-84 calculators. Each operation rounds its exact result once, half to even, and checks against Python's decimal module show they match.

[dependencies]
nanoexpr = { version = "0.1", features = ["decimal"] }

# #[cfg(feature = "decimal")] {
use nanoexpr::Decimal;

let sum: Decimal = nanoexpr::evaluate("0.1 + 0.2").unwrap();
assert_eq!(sum.to_string(), "0.3");

let one: Decimal = nanoexpr::evaluate("1 / 3 * 3").unwrap();
assert_eq!(one.to_string(), "0.99999999999999");
assert_eq!(format!("{one:.10}"), "1");

let price: Decimal = nanoexpr::evaluate("19.99 * 3").unwrap();
assert_eq!(price.to_string(), "59.97");
# }

Like a calculator, keep more digits than you show: formatting with a precision such as {:.10} rounds to that many significant digits, which hides the rounding of intermediate results. Choose other sizes with the generic parameters, such as Decimal<10, 99> or Decimal<18, 9999>.

Arithmetic, powers with integer exponents, abs, sign, floor, ceil, round, trunc, min, max and clamp are computed in decimal. The other functions of Math, such as sqrt, sin or ln, go through f64, so their results are accurate to about 15 digits, except very close to a zero of the function, such as sin(pi).

C and C++

The ffi directory of the repository holds C bindings that evaluate double expressions, still without allocating. Variables and functions come from callbacks, and the built-in math functions remain available:

#include <string.h>
#include "nanoexpr.h"

static bool variable(void *user_data, const char *name, size_t name_length, double *value) {
    if (name_length == 3 && memcmp(name, "raw", 3) == 0) {
        *value = *(const double *)user_data;
        return true;
    }
    return false;
}

double raw = 2150, result;
nanoexpr_error error;
nanoexpr_options options = nanoexpr_default_options();
options.variable = variable;
options.user_data = &raw;

const char *input = "raw * 0.0125 - 40";
if (nanoexpr_evaluate_with(input, strlen(input), &options, &result, &error) != NANOEXPR_OK) {
    printf("%s at %zu..%zu\n", nanoexpr_status_description(error.kind), error.start, error.end);
}

The header is ffi/include/nanoexpr.h. With CMake, add the directory and link the nanoexpr target, which builds the static library with cargo:

add_subdirectory(nanoexpr/ffi)
target_link_libraries(app PRIVATE nanoexpr)

Without CMake, cargo build --release -p nanoexpr-ffi builds target/release/libnanoexpr_c.a (and a shared library). cargo rustc --release -p nanoexpr-ffi -- --print native-static-libs lists the system libraries to link with it. For a microcontroller, build without the standard library and link the archive into your firmware:

cargo rustc --release -p nanoexpr-ffi --target thumbv7em-none-eabihf --no-default-features --crate-type staticlib

Without std the library brings its own panic handler, which loops forever, so build it with panic = "abort", the default of bare-metal targets. The evaluator does not panic on any input.

Syntax

From the loosest to the tightest binding:

Numbers are written 42, 3.14, .5, 5. or 1.5e-3. Names start with a letter or _ and continue with letters, digits or _.

Footprint

Sizes of a WebAssembly module exporting one evaluation function, built with opt-level = "z", LTO and panic = "abort":

Most of the f64 size is core's float parsing, which any crate reading float literals pays for.

Comparison with other Rust expression evaluators

How nanoexpr compares with other expression evaluators on crates.io, as of their latest release in October 2026:

And what each is best at:

nanoexpr parses each time it evaluates. To evaluate the same formula millions of times on a desktop, a crate that compiles expressions first, such as fasteval or exmex, will be faster.

Performance

Each crate parses and evaluates three expressions from a string, once per call:

Median time per evaluation:

Heap use per evaluation, as allocations / bytes allocated / peak live bytes:

Size of a WebAssembly module exporting one function that evaluates a string with each crate, built with opt-level = "z", LTO, panic = "abort" and symbols stripped. The baseline module only unwraps an Option, which pulls in the standard library's panic and formatting code that every other module also contains:

These modules use std, unlike the no_std builds in Footprint.

Measured on an Apple M2 Pro with rustc 1.99.0, in October 2026. Every call parses the expression again: none is compiled once and reused. fasteval, exmex and meval can compile an expression once and then evaluate it much faster, so for a formula evaluated many times they can beat nanoexpr. Times vary by a few percent between runs. Heap use is counted by a global allocator wrapper; exp-rs installs its own global allocator, so its heap use cannot be measured that way. To reproduce, from the comparison directory of the repository:

cargo run --release --features all --bin bench
cargo run --release --features exp-rs --bin bench
./size.sh

Feature flags

Frequently asked questions

How do I evaluate a math expression from a string in Rust? Add nanoexpr and call nanoexpr::evaluate::<f64>("1 + 2 * 3"). Use evaluate_with to provide variables and functions.

Does it work without std or an allocator? Yes. The crate is #![no_std], never uses alloc, and needs no global allocator, so it runs on bare-metal microcontrollers.

Why is 0.1 + 0.2 not 0.3? With f64, no binary float can hold 0.1 exactly. Use the decimal feature and Decimal to compute in decimal like a pocket calculator.

Can a user crash the device with a malicious formula? It is designed not to: evaluation never allocates, nesting depth is bounded, arithmetic is checked, and malformed, deep or overflowing input returns an error.

Is it a scripting language? No: it evaluates numeric expressions only. For strings, booleans and assignments, see the comparison below for crates that do more.

License

MIT