Pimp My IDE / engine witnesses
Back to garage
Regex tools / executable diagrams / 18 Oct 2026

Pretty motion is not engine proof.

A 3D regex machine can teach the route. It still needs to name the engine, starting index, trace model, and exact match result.

Keep the spectacle. Bolt its explanation to a runtime receipt.
PatternEngineTraceResult

A rendered path explains one model. The runtime result checks what the current engine did.

The marble run earns attention.

Regex Marble Run turns a JavaScript pattern into a physical 3D machine. Its live interface accepts a pattern, test string, and the i, m, s, u, v, and y flags. The public repository describes backtracking and Pike-style execution, a trace log, keyboard controls, shareable URL state, and reduced-motion support.[1][2]

That is the right kind of visual ambition. Gates, branches, loops, and return rails can make an invisible control path inspectable. The machine should not become the authority it is explaining.

A diagram can show a route. Only the named engine can return its result.

There are several truths in one regex run.

The pattern text is one truth. The engine and flags are another. The current input position matters too. MDN documents that JavaScript regular expressions become stateful with the global or sticky flag because exec() stores lastIndex. A sticky match fails immediately if the pattern does not match at that exact index. A global match may scan forward.[3]

The execution model is a separate choice. Russ Cox shows how backtracking and Thompson-style NFA simulation can accept the same regular language while doing different amounts of work. His NFA simulation advances a set of reachable states together. Backtracking tries alternatives and returns after failure. Backreferences complicate that clean equivalence.[4]

The repository has an honest loose wire.

We checked revision beec6e9e94cf1f0fe4204c1a3e45064deb289eaf in an isolated directory with Node 22.22.2 and npm 10.9.7. Dependency installation completed with no reported audit vulnerabilities. The repository's full Vitest command ran 1,222 tests. It passed 1,215 and failed 7. The failures involved duplicate named groups, scoped modifier syntax, and differential cases where the local runtime rejected syntax expected by the tests.

This does not prove that the live browser demo is wrong. We did not run its Playwright suite or compare several browser engines. It does prove that the engine version belongs in the receipt. A green animation without a runtime name can hide a compatibility boundary.

Ship four linked records.

  1. Save the exact pattern, flags, input, and starting index.
  2. Name the engine and version that produced the result.
  3. Label the trace as native, reconstructed, sampled, or simulated.
  4. Record the match span, captures, ending lastIndex, and any timeout.

The switchyard below uses this browser's native JavaScript RegExp.exec(). It does not reproduce the Marble Run engine. It makes the browser result and state transition visible.

Interactive makeover / detent selector plus native runtime receipt

Regex witness switchyard

A normal tester says match or no match. This switchyard combines pattern input, execution mode, starting index, the live character rail, and a copyable browser-engine receipt.

Set the route

Every run stays in this browser. No text is sent anywhere.

Execution detent
0
Native browser result. This bench does not expose the engine's internal backtracking path. The character rail shows match spans and lastIndex, not hidden engine steps.
Browser JavaScript RegExp/a+/g
caaab
Ready to run.

The first exec starts at index 0.

  1. No result recorded.
Sources read / 18 Oct 2026

Evidence locker

Live artifact

Regex Marble Run

The public interface exposes pattern, string, examples, and JavaScript flags. Its page describes a 3D view of matching and backtracking.

Open the live machine
Exact repository revision

bottomless/regex-marble-run

Revision beec6e9 documents the two engine models, trace controls, accessibility work, local assets, limits, and test commands. We ran its Vitest command and recorded the result above.

Inspect the revision
Runtime reference

MDN RegExp.exec and sticky

Documents match arrays, stateful lastIndex, global scanning, sticky matching, and zero-length-loop hazards.

Read the exec reference
Engine model

Russ Cox on regex matching

Explains backtracking, Thompson NFA construction, parallel state simulation, and the boundary created by backreferences.

Read the engine explanation
Discovery record

Hacker News item 50122671

Maps the current discussion to the exact demo. Comments are reader reactions, not proof of engine correctness.

Read the discussion

Evidence boundary: this pass fetched the live page, inspected the exact public revision, and ran the repository's Vitest command under the runtime named above. We did not run the browser suite, measure WebGL performance, or certify parity across JavaScript engines. This switchyard uses the reader's current browser implementation.