From C# to Rust: Porting MathFlow to Create MathCore – A Symbolic Math Library Journey

August 30, 2025

This content originally appeared on DEV Community and was authored by Berkant

# From C# to Rust: Building a Symbolic Math Library

Hey DEV community! Today I want to share my journey of porting a symbolic math library from C# to Rust, and what I learned along the way.

## The Story

Last year, I built MathFlow – a symbolic math library for C#. It worked great, but I was curious about Rust’s performance claims. So I decided to rebuild it as
MathCore in Rust.

The results? Mind-blowing!

## Quick Comparison

C# (MathFlow) Rust (MathCore)


  var expr = MathExpression
      .Parse("x^2 + 2*x + 1");

  var derivative = expr
      .Differentiate("x");

  var result = expr
      .Evaluate(new { x = 5 });

  let expr = MathCore::parse(
      "x^2 + 2*x + 1"
  )?;

  let derivative = MathCore::differentiate(
      &expr, "x"
  )?;

  let result = math.calculate(
      &expr, &[("x", 5.0)]
  )?;

Performance Results

I was shocked by these numbers:

| Operation | C# (MathFlow) | Rust (MathCore) | Difference |
|——————|—————|—————–|—————-|
| Parse Expression | 245 µs | 89 µs | 2.7x faster |
| Differentiate | 1,230 µs | 456 µs | 2.7x faster |
| Solve Equation | 890 µs | 234 µs | 3.8x faster |
| Memory Usage | 847 MB | 124 MB | 6.8x less |

Key Differences I Discovered

1⃣ Error Handling

  C# Way (Exceptions):
  try {
      var result = MathExpression.Parse("invalid");
  } catch (ParseException e) {
      Console.WriteLine($"Oops: {e.Message}");
  }

  Rust Way (Result Type):
  match MathCore::parse("invalid") {
      Ok(expr) => println!("Success!"),
      Err(e) => println!("Oops: {}", e),
  }

Insight: Rust forces you to handle errors. No more surprise crashes in production!

2⃣ Memory Management

C#:

Garbage collector handles everything
Random GC pauses
Unpredictable performance

Rust:

Predictable performance
No GC pauses
Must think about ownership

3⃣ Real-World Example

Let’s solve a physics problem – projectile motion with air resistance:


  // Calculate trajectory
  var equation = @"
      y = v0*sin(θ)*t - 
          0.5*g*t^2
  ";

  var solver = new MathEngine();
  var trajectory = solver
      .Parse(equation)
      .Substitute(new {
          v0 = 100,
          θ = Math.PI/4,
          g = 9.81
      });

  // Calculate trajectory
  let equation = "
      y = v0*sin(θ)*t - 
          0.5*g*t^2
  ";

  let math = MathCore::new();
  let trajectory = math
      .calculate(equation, &[
          ("v0", 100.0),
          ("θ", PI/4.0),
          ("g", 9.81),
      ])?;

Architecture Evolution

From OOP to Functional

  C# (Object-Oriented):
  public abstract class Expression {
      public abstract double Evaluate();
  }

  public class AddExpr : Expression {
      private Expression left, right;

      public override double Evaluate() {
          return left.Evaluate() + right.Evaluate();
      }
  }


  Rust (Algebraic Data Types):
  enum Expr {
      Number(f64),
      Add(Box<Expr>, Box<Expr>),
  }

  fn evaluate(expr: &Expr) -> f64 {
      match expr {
          Expr::Number(n) => *n,
          Expr::Add(l, r) => evaluate(l) + evaluate(r),
      }
  }

Why this matters: Pattern matching eliminated entire class hierarchies!

Cool Features in Both

Features Comparison

Try Them Out!

For .NET Developers:

dotnet add package MathFlow

  using MathFlow;

  var math = new MathEngine();
  var derivative = math.Differentiate("sin(x^2)", "x");
  Console.WriteLine(derivative); // Output: 2*x*cos(x^2)

For Rust Developers:

cargo add mathcore

  use mathcore::MathCore;

  fn main() {
      let derivative = MathCore::differentiate("sin(x^2)", "x").unwrap();
      println!("{}", derivative); // Output: 2*x*cos(x^2)
  }