bmb-algo — Blazing Fast Algorithms

Up to ~245× faster than pure Python on DP workloads (knapsack(100), median of 5 runs at v0.98, 2026-05-12). Scales to ~300× at n=300.

High-performance algorithms compiled from BMB, a language where compile-time contracts eliminate runtime overhead.

Installation

Python:

pip install bmb-algo

Node.js (via koffi FFI — no native build required):

cd ecosystem/bmb-algo/bindings/node && npm install

See bindings/node/README.md for full Node.js API documentation.

Benchmarks (vs Pure Python)

Measured at v0.98 (2026-05-12), median of 5 runs. Reproduce with python benchmarks/bench_algo.py --runs=5.

All timings include ctypes FFI overhead — 50-500-iteration mean per sample, 10-iter warmup. Inter-run variance ~5% on stable runs; edit_distance shows occasional outliers (1 of 5 measured 4.87× — Python L1-cache miss susceptibility).

Scaling behavior

BMB's advantage amplifies with input size, because FFI call overhead is amortized over more algorithmic work:

Reproduce with python benchmarks/bench_algo.py --runs=5 --scaling (adds ~30s).

Recommendation: use bmb-algo for inputs where algorithmic work ≫ FFI overhead. For DP workloads (knapsack, edit_distance), the advantage is already material at n≈10 and grows rapidly with state count. For sorting, the crossover where BMB clearly wins is around n≈30–50.

Historical measurements (archived)

bmb-algo v0.2.0 (2026-03-23) recorded knapsack 90.7× and nqueens(8) 181.6× vs Python. The knapsack 90.7× reproduces in scale (current median-of-5 puts knapsack(n=30) at ~119×, which is in the ballpark of the v0.2.0 number). The nqueens(8) 181.6× does not reproduce against the current py_nqueens baseline (n=8/10/12 all measure ~4-8× speedup) — likely a different bench configuration in v0.2.0.

A more recent intermediate measurement on 2026-05-12 (Cycle 2754) reported knapsack(100) ~450× and quicksort(15) ~0.9× SLOW. Neither reproduces against the current median-of-5 baseline — the Cycle 2754 sample was n=2 and appears to have hit unusual system conditions. The numbers in the table above (median of 5 back-to-back runs on the same machine, within 5% inter-run variance) are the durable baseline. See CHANGELOG.md for full re-baseline notes.

Quick Start

import bmb_algo

# Dynamic Programming
bmb_algo.knapsack([2, 3, 4], [3, 4, 5], 7)         # 9
bmb_algo.edit_distance("kitten", "sitting")          # 3
bmb_algo.lcs("ABCBDAB", "BDCAB")                    # 4
bmb_algo.coin_change([1, 5, 11], 15)                 # 3
bmb_algo.lis([10, 9, 2, 5, 3, 7, 101, 18])          # 4
bmb_algo.max_subarray([-2, 1, -3, 4, -1, 2, 1])     # 6

# Graph
bmb_algo.dijkstra([[0, 4, -1], [-1, 0, 2], [-1, -1, 0]], 0)  # [0, 4, 6]
bmb_algo.floyd_warshall([[0, 3, -1], [2, 0, -1], [-1, 7, 0]])
bmb_algo.bfs_count(adj_matrix, source=0)
bmb_algo.topological_sort(adj_matrix)

# Sort
bmb_algo.quicksort([5, 3, 1, 4, 2])                 # [1, 2, 3, 4, 5]
bmb_algo.merge_sort([5, 3, 1, 4, 2])                 # [1, 2, 3, 4, 5]
bmb_algo.heap_sort([5, 3, 1, 4, 2])                  # [1, 2, 3, 4, 5]
bmb_algo.counting_sort([3, 1, 4, 1, 5, 9])           # [1, 1, 3, 4, 5, 9]

# Number Theory
bmb_algo.nqueens(8)                                   # 92
bmb_algo.prime_count(100)                             # 25
bmb_algo.fibonacci(50)                                # 12586269025
bmb_algo.gcd(12, 8)                                   # 4
bmb_algo.modpow(2, 10, 1000)                          # 24

Full API (55 algorithms)

Dynamic Programming

Graph

Sort

Search

Number Theory

Matrix

Utility

How?

Written in BMB — a language where compile-time contracts prove correctness, then generate code faster than hand-tuned C. Safety isn't a separate goal; it's the natural consequence of pursuing maximum performance.

License

MIT