rapid-fuzzy

Rust-powered fuzzy search and string distance for JavaScript/TypeScript.

Status: Work in progress. Not yet published to npm.

Features

• Fast: Up to 40x faster than fuse.js for large datasets (Rust + napi-rs)
• Universal: Works in Node.js (native), browsers (WASM), Deno, and Bun
• Zero JS dependencies: Pure Rust core with napi-rs bindings
• Type-safe: Full TypeScript support with auto-generated type definitions
• Drop-in: API compatible with popular fuzzy search libraries

Installation

npm install rapid-fuzzy
# or
pnpm add rapid-fuzzy

Runtime-specific notes

• Node.js (>=20): Uses native bindings via napi-rs for best performance.
• Browser / Deno / Bun: Falls back to a WASM build automatically.

Usage

String Distance

import { levenshtein, jaroWinkler, sorensenDice } from 'rapid-fuzzy';

levenshtein('kitten', 'sitting');     // 3
jaroWinkler('MARTHA', 'MARHTA');      // 0.961
sorensenDice('night', 'nacht');       // 0.25

Fuzzy Search

import { search, closest } from 'rapid-fuzzy';

// Find matches sorted by relevance
const results = search('typscript', [
  'TypeScript',
  'JavaScript',
  'Python',
  'TypeSpec',
]);
// → [{ item: 'TypeScript', score: 89, index: 0 }, ...]

// Find the single best match
closest('tsc', ['TypeScript', 'JavaScript', 'Python']);
// → 'TypeScript'

Benchmarks

Measured on Apple M-series with Node.js v22 using Vitest bench. Each benchmark processes 6 realistic string pairs of varying length and similarity.

Distance Functions

Note: For single-pair Levenshtein distance, fastest-levenshtein is faster due to its highly optimized pure-JS implementation that avoids FFI overhead. rapid-fuzzy provides broader algorithm coverage and excels in batch / search scenarios.

Search Performance

Closest Match (Levenshtein-based)

rapid-fuzzy is up to 3x faster than fastest-levenshtein for closest-match lookups on large datasets.

Why these numbers matter

• vs fuse.js: rapid-fuzzy is 13x faster on medium datasets and 41x faster on large datasets for fuzzy search.
• vs fastest-levenshtein: rapid-fuzzy wins on closest-match (1.5–3x faster) where batch FFI overhead is amortized.
• fuzzysort uses a different (substring-based) matching algorithm that is extremely fast but produces different ranking results. Choose based on your matching needs.

Run benchmarks yourself:

pnpm run bench        # JavaScript benchmarks
cargo bench           # Rust internal benchmarks

Why rapid-fuzzy?

License

MIT