Skip to content
← Projects

ries-rs

Active

A modern Rust RIES implementation with CLI, Python bindings, Rust crate, WebAssembly, and browser app.

Canonical landing page

This page frames the project and embeds the demo. The repository carries releases, docs, and citation metadata; the standalone app lives at /projects/ries-rs/app/.

Live — running in your browser

What it is

RIES finds algebraic equations from their solutions. Feed it a number and it searches for equations where that number is the answer.

ries-rs is a ground-up Rust reimplementation of Robert P. Munafo’s original RIES program. The goal is not merely to preserve a historical binary; it is to make the search engine legible, reproducible, and usable across multiple surfaces.

The repository carries the full technical detail. This page is the short version.

A quick example

Feed it a number and it searches for simple equations that produce it. Give it 2.506628274631 and one of the first things it finds is √(2π). Give it 3.141592653589793 (π) and it enumerates candidate relations at the complexity level you choose.

The live app above runs the same solver in your browser; the repository holds CLI usage, presets, and the full result format.

Why it matters

Most constant-recognition software survives as an old binary, a partial port, or a one-off demo. ries-rs treats the solver as modern software: documented architecture, regression coverage, conservative benchmarks, explicit parity notes, and packaging that makes the same core available from the command line, as a Rust library, through Python, and directly in the browser.

That makes it useful both as a tool and as a reference implementation.

What ships today

  • command-line search for inverse equations and algebraic identities
  • a reusable Rust crate built on the same core solver
  • Python bindings for notebook and scripting workflows
  • a browser/WASM app that runs the solver client-side
  • deterministic runs, structured JSON output, and emitted manifests for reproducible workflows
  • an optional turbo mode that parallelizes the match phase across cores for large speedups when reproducibility isn’t required

The browser build covers the main search flow, quick constants, presets, shareable URLs, and export/copy actions. PSLQ remains a CLI-only surface for now.

Reproducibility and parity

Deterministic mode, machine-readable output, and run manifests are first-class because the project is meant to support repeatable work, not just one-off terminal sessions.

Compatibility is tracked explicitly against historical behavior, with public parity notes and benchmark artifacts in the repository. The remaining work is quality and polish work, not a question of whether the project has become a serious implementation.

Where to go next

If you want the fastest path in, use the live app above or open the standalone browser build.

If you want release artifacts, package installs, docs, or citation metadata, the repository is the source of truth.

For the performance story — profiling, ranking fixes, and the turbo-mode contract — read Making ries-rs fast.

The site page is for framing. The repository is for depth.

Related Writing

Notes and writeups connected to this project

View all →

Making ries-rs 4–21× faster without breaking reproducibility

How I took ries-rs from tens of seconds to a few seconds: profiling first, fixing ranking, then adding turbo.

Building ries-rs: A Rust rewrite of the inverse equation solver

Why I rewrote a 25-year-old C program in Rust, what changed in the search engine, and how WASM made the browser version possible.