FlashFuzzy

01Overview

Fuzzy search, shipped as 3 KB of WebAssembly. FlashFuzzy is a complete fuzzy search runtime that runs entirely in the browser — no server, no API calls, no network traffic after load. It combines a Bloom pre-filter with Bitap matching to deliver typo-tolerant, accent-insensitive search over any array, object, or JSON dataset.

FlashFuzzy exposes a single class, FlashFuzzy, that wraps the WebAssembly module. All search logic runs in the WASM sandbox; the JS surface is intentionally thin. Built with Rust, targeting wasm32-unknown-unknown.

Built for the browser edge

02Install

Ship fuzzy search today. No backend required — the runtime is delivered as an npm package and runs entirely in the browser. Pick your package manager:

npm install flashfuzzy
pnpm add flashfuzzy
yarn add flashfuzzy
cargo add flashfuzzy
pip install flashfuzzy

03Quick start

Up in under a minute. Three steps, no server:

1. Drop — feed any array, JSON, or text. No network, no server.
2. Index — tokenizer + Bloom filter. Unicode fold, 64-bit filter, tokens stored in the BSS pool.
3. Search — Bloom skips, Bitap finishes. O(1) skip, O(n·k) match.

import { FlashFuzzy } from "flashfuzzy";

const ff = await FlashFuzzy.create();

ff.index([
  { id: 1, name: "React Hooks", tags: ["react", "js"] },
  { id: 2, name: "Vue Composition API", tags: ["vue", "js"] },
]);

const hits = ff.search("raect hoks");  // typo-tolerant

for (const h of hits) {
  console.log(h.id, h.score, h.snippet);
}

04Query syntax

The query language supports fuzzy single tokens, AND, exact phrases, and OR — composable in a single string.

05API reference

The whole surface is one class and four calls.

FlashFuzzy.create()

import { FlashFuzzy } from "flashfuzzy";

const ff = await FlashFuzzy.create();
console.log("FlashFuzzy ready");

ff.index()

ff.index([
  { id: 1, name: "React Hooks", tags: ["react", "js"] },
  { id: 2, name: "Vue Composition API", tags: ["vue", "js"] },
]);

ff.search()

const hits = ff.search("raect hoks");  // typo-tolerant
for (const h of hits) {
  console.log(h.id, h.score, h.snippet);
}

The Hit type

ff.clear()

ff.clear();
console.log("Index cleared, ready for new records");

06Architecture

The runtime topology is seven nodes and six edges, split across an ingest lane and a search lane. A query traverses the whole graph in under a millisecond:

Input → Tokenizer → Bloom Builder → Index → Store → Pipeline → Results

Ingest lane

Search lane

Memory layout

All state lives in static BSS memory — no allocator, no heap, no GC pressure. The store is split into four segments:

• BSS pool — 3 KB text pool
• Tokens — 50k token chunks
• Bloom bits — the 64-bit filter scratch
• Doc index — record name table

07Search pipeline

Four stages, one pass. Every query runs Bloom → Bitap → Score → Rank in a single traversal of the index.

08Formats & capacity

What goes in

Default limits

09Guides

From install to first fuzzy hit in under 60 seconds — the same recipe in plain ESM/TypeScript, React, Vue, and Svelte.

ESM / TypeScript

npm install flashfuzzy
# or
pnpm add flashfuzzy

import { FlashFuzzy } from "flashfuzzy";

const ff = await FlashFuzzy.create();

ff.index([
  { id: 1, name: "React Hooks", tags: ["react", "js"] },
  { id: 2, name: "Vue Composition API", tags: ["vue", "js"] },
]);

const hits = ff.search("raect hoks");
for (const h of hits) {
  console.log(h.id, h.score, h.snippet);
}

// Clear and re-index
ff.clear();
ff.index(newRecords);

// OR query
const results = ff.search("typescript | javascript");

// Phrase query
const exact = ff.search('"fuzzy search"');

// Typo-tolerant single token
const fuzzy = ff.search("javsacript"); // matches javascript

React hook

npm install flashfuzzy

import { useEffect, useRef, useState } from "react";
import { FlashFuzzy } from "flashfuzzy";

export function FuzzySearch({ records }) {
  const ffRef = useRef(null);
  const [hits, setHits] = useState([]);

  useEffect(() => {
    FlashFuzzy.create().then(ff => {
      ff.index(records);
      ffRef.current = ff;
    });
  }, [records]);

  function handleSearch(q) {
    setHits(ffRef.current?.search(q) ?? []);
  }

  return (
    <div>
      <input onChange={e => handleSearch(e.target.value)} />
      {hits.map(h => <div key={h.id}>{h.snippet}</div>)}
    </div>
  );
}

Vue composable

npm install flashfuzzy

import { ref, onMounted } from "vue";
import { FlashFuzzy } from "flashfuzzy";

export function useFuzzySearch(records) {
  const ff = ref(null);
  const hits = ref([]);

  onMounted(async () => {
    ff.value = await FlashFuzzy.create();
    ff.value.index(records);
  });

  function search(query) {
    hits.value = ff.value?.search(query) ?? [];
  }

  return { hits, search };
}

Svelte store

npm install flashfuzzy

import { writable } from "svelte/store";
import { FlashFuzzy } from "flashfuzzy";

export function createFuzzyStore(records) {
  const hits = writable([]);
  let ff = null;

  FlashFuzzy.create().then(instance => {
    ff = instance;
    ff.index(records);
  });

  function search(query) {
    hits.set(ff?.search(query) ?? []);
  }

  return { hits, search };
}

Query syntax quick reference