Generate it. Compare it. Keep the evidence.
A browser-based workbench for testing how language models turn the same idea into interactive HTML, p5.js sketches, and SVG artwork — plus agentic builders that write whole games, WebXR projects and 3D assets, and a set of developer tools.
Open the live site · The benches · Agentic builders · Developer tools · Quick start
Three focused test benches, one shared workflow: pick a prompt, run it through any model you like, and keep every result with the model, seed, and parameters that produced it. No accounts, no database, no telemetry — your work is written to a folder you choose on your own machine.
| Bring your own model | OpenRouter with your key, or a local LM Studio / OpenAI-compatible server. The browser talks to it directly — nothing is relayed through the site. |
| Keep the evidence | Every save records the prompt, provider, model, seed, and parameters. Saves are append-only by default, so a run never overwrites an earlier one. |
| Compare properly | Run one prompt across several models, put the results side by side, rate them, and export what you find. |
| Own your files | Pick a folder once; the apps create their own subfolders inside it and write there through the File System Access API. |
| Record a walkthrough | Each app has a built-in screen recorder for capturing what a model produced. |
Generate standalone interactive HTML from a prompt, preview it in a sandboxed frame, and keep the ones worth keeping.
- 62 starter prompts covering simulations, tools, games, and visualisations
- Streaming generation, batch runs across a whole prompt set, and self-healing retries
- Gallery, side-by-side comparison, ratings, refinement, and full metadata
Generate instance-mode p5.js sketches with reproducible seeds and live parameter controls.
- 24 ambitious starter prompts aimed at generative and emergent work
- Sandboxed live canvas, seed control, and tunable
ctx.params - Remix a sketch into a variant, explain it, compare lineages, capture video
Ask a model for vector artwork, then measure how close it got.
- 63 starter prompts, from simple icons to detailed illustrations
- Pixel-diff scoring against a reference image, plus manual scoring
- Structure inspection, batch runs across the full prompt set, and export
A model is given tools and a budget, writes a multi-file project, and the app checks the result instead of trusting it.
| App | What it does |
|---|---|
Game Forge (game-forge-v2/) |
Builds a complete multi-file game through an agentic file-writing loop, from a library of 339 briefs. Engines are copied into each project from a hash-pinned set. |
VR Forge (vr-forge/) |
Builds WebXR projects for the Meta Quest 3, then runs each in an emulated immersive session to measure whether it really entered VR and rendered both eyes. |
Understory Studio (understory-studio/) |
Turns one to three reference pictures into an editable 3D asset at five levels of detail; the model reviews renders of its own result against the reference. |
Code Morph Lab (code-morph-lab-v3/) |
Iterative write → run → fix loop in HTML or in-browser Python (Pyodide). Prompt Gallery and SVG bench results can be sent to it with Morph. |
| App | What it does |
|---|---|
Notebook Lab (notebook-lab/) |
Notebooks whose cells can be JavaScript, Python (Pyodide, with NumPy, pandas and matplotlib), C, Lua, HTML, live controls or Vega-Lite charts, all sharing one set of variables. A model writes cells, builds whole notebooks from one request, and repairs cells that fail. Ships 56 runnable tutorials and examples. |
| App | What it does |
|---|---|
| C Machine Lab | Steps a subset of C through a teaching machine with source, assembly, registers, stack, heap and memory side by side. |
| Algorithm Visualizer | Instruments JavaScript or Python and replays variable changes as an animated array, graph, tree or grid. |
| SQL Playground | SQLite in WebAssembly with a schema viewer, ER diagram, query plans and an SQL assistant. |
| AST Explorer & Refactor Lab | Syntax trees for JavaScript, TypeScript and Python, with model-proposed refactors reviewed as diffs. |
Nothing to install and nothing to build.
git clone https://github.com/Techdread/llm-test-bench.git
cd llm-test-bench
python3 -m http.server 8080Open http://localhost:8080 in Chrome or Edge.
Do not open the files with a
file://URL. ES modules and folder access need an HTTP(S) origin.
Then:
- Settings → Choose folder. Pick a folder you are happy for the apps to
organise. Each app creates its own subfolder inside it (
prompt-gallery/,game-forge-v2/, …) as you go. - Settings → connect a model. Either add your OpenRouter key inside an app, or point the Settings page at a local server (below).
- Open a bench and generate.
For LM Studio:
- Load a model and start the server with CORS enabled — Developer settings, or
lms server start --cors. - On the Settings page, add
http://localhost:1234. - Click Add & test and allow the browser's local-network permission prompt.
- Open any bench and pick the discovered model from its normal model picker. Batch mode uses the same selection.
Any OpenAI-compatible server works with the LM Studio endpoint type as long as it
exposes /v1/models and /v1/chat/completions and allows the site's origin
through CORS. Unsloth Studio has its own endpoint type.
Never commit an API key, and never paste one into an issue, screenshot, or recording. Keys live in your browser and are sent only to the provider you pick.
Native ES modules, Preact, and HTM tagged templates. No JSX, no bundler, no
transpilation, no package.json at the app level. Every runtime dependency is
vendored under shared/lib/ and served from the same origin — the site makes no
third-party requests at all.
prompt-gallery/ HTML generation and comparison
p5-sketch-gallery/ p5.js generation and gallery
svg-benchmark/ SVG generation and scoring
game-forge-v2/ agentic multi-file game builder
vr-forge/ agentic WebXR builder with emulated-session checks
understory-studio/ reference pictures → editable 3D asset
code-morph-lab-v3/ iterative code generation (HTML / Python)
notebook-lab/ polyglot notebooks with AI-written cells
c-machine-lab/ C on a visible teaching machine
algorithm-visualizer/ traced algorithm playback
sql-playground/ SQLite in the browser
ast-explorer-refactor-lab/ syntax trees and model-driven refactors
shared/ components, services, styles, and vendored runtimes
Tests use Node's built-in runner:
node --test prompt-gallery/tests/*.test.mjs
node --test p5-sketch-gallery/tests/*.test.mjs
node --test svg-benchmark/tests/*.test.mjsChrome and Edge are recommended. Other modern browsers can open the editors and
previews, but folder access and screen recording vary. The site must be served over
HTTPS or localhost — folder access, local-network access, and recording are all
secure-context features.
This repository is the static, hosted-safe edition. It supports local model servers but not local CLI coding agents, the Wan2GP image/video nodes or the Blender bridge, which depend on a Python bridge outside this release. Cross-app handoffs work between apps in this release (for example Prompt Gallery → Code Morph Lab) and are hidden where the target app is not included. Local models and local CLI agents are different connection types; only the latter is absent here.
Each app's toolbar has a Record button that captures a walkthrough. To put one in this README:
- Record the walkthrough in the app and save the file (the recorder produces MP4 where the browser supports it, otherwise WebM).
- Open this README in GitHub's web editor and drag the file into the text area.
GitHub uploads it and inserts a
https://github.com/user-attachments/assets/…URL. - Leave that URL on its own line where the matching
<!-- VIDEO: … -->comment is and delete the comment. GitHub renders it as an inline player.
Notes: GitHub caps attachment size (10 MB on free plans at the time of writing), so
keep clips short or trim them. Repo-relative <video> tags do not render in a
README — a committed animated GIF referenced with normal image syntax does, and is a
good fallback for anything longer.
Start with CONTRIBUTING.md. Small, focused pull requests with a short reproduction or test are easiest to review.
Generated code is untrusted input even when a model produced it. Previews run in sandboxed iframes, but review generated code before running it elsewhere or sharing it. See SECURITY.md, PRIVACY.md, and THIRD_PARTY_NOTICES.md.
MIT. Vendored dependencies keep their own licences.