<p align="center"> <picture> <source media="(prefers-color-scheme: dark)" srcset="assets/brand/glitchless/logo/png/glitchless-lockup-dark.png"> <img src="assets/brand/glitchless/logo/png/glitchless-lockup-light.png" width="300" alt="Glitchless"> </picture> </p>

Glitchless

Coding agents can build a game. They can't see anyone play it. Glitchless lets them.

Glitchless is game observability for coding agents. Your agent adds it to the game, sees what real players hit (stutters, crashes, where they quit) and fixes the next build, then checks the fix. It works with Three.js, Phaser, Babylon.js and PlayCanvas games in the browser, and Godot 4.5+, Unity (6.3 LTS and later), Unreal Engine 5.8 and GameMaker (2024.2+) games on phones and desktops. Use it free on Glitchless Cloud (5,000 play sessions a month), or run it yourself: it's open source (MIT).

On Starlift, a Godot game on iPhone and Android, Glitchless showed that 1 in 4 players who skipped the tutorial quit without playing. The agent made a skip start a game, and all 26 who skipped since then played (the case study). In a web game the SDK adds 33.7 KB gzipped and about 0.6 µs of work a frame, with no measurable change in frame time (measured).

• Stutter. Every frame is timed on every player's device, and each hitch comes with its likely cause: a long script, a shader compile, garbage collection or an asset load.
• Crashes. Errors are grouped into issues, each with the gameplay just before it.
• Where players give up. Level funnels, death heatmaps and rage-quit detection.
• What players tell you. Playtesters press F8 in a web game to send a note with a screenshot, the level and the session behind it (opt-in).
• Your coding agent. An MCP server for production data, WebMCP tools exposed by the running game, and autoplay bots that check a fix before it ships.

It's open source and runs anywhere Node runs: one server with a file store, on a laptop, a VPS or in a container. It's anonymous by default (what it sends), and it can pass the same data on to Datadog or any OpenTelemetry backend.

Read more: a five-second first launch, found in player data and fixed (a Godot game's first week), what the SDK costs a web game, measured, debugging your game with real player data in Claude Code or Cursor, playtest bots in CI, and every guide.

<p align="center"> <img src="assets/brand/glitchless/diagram/glitchless-architecture.png" width="900" alt="Your game, with the Glitchless SDK, sends play sessions to Glitchless (dashboard and findings), which can export to Datadog or OpenTelemetry. Your coding agent reads player data from Glitchless over MCP and drives the running game over WebMCP."> </p>

The dashboard on simulated history from scripts/seed.js. Also: performance and death heatmaps.

What's in the box

| Path | What | | --- | --- | | packages/sdk | glitchless: SDK, Three.js, Phaser (3 and 4), Babylon.js and PlayCanvas adapters, overlay, WebMCP tools, Datadog RUM bridge. 138 KB as one <script> (44 KB gzipped); a Three.js game's bundle adds 34 KB gzipped (measured) | | godot | Glitchless for Godot 4.5+ (addons/glitchless): the same events from native Godot games, with errors through Godot's loggers, an anonymous mode and --glitchless-measure for agents. A demo game and end-to-end test sit alongside | | unity | Glitchless for Unity 6.3 LTS and later (gg.glitchless.sdk, installed by git URL): frame timing with the player loop split into update, physics and render, profiler counters, errors from Unity's log, scenes as levels, an offline outbox and --glitchless-measure for agents. A sample game and end-to-end test sit alongside | | unreal | Glitchless for Unreal Engine 5.8 (Plugins/Glitchless, C++ source): game, render, RHI and GPU times, hitches with their causes (pipeline states created on the spot, garbage collection, map and asset loads), ensures, Blueprint errors and crashes, maps as levels, bug reports, settings that need no code, and -glitchless-measure for agents. An optional toolset gives Unreal MCP Status and Measure tools. A demo with planted problems and an end-to-end test sit alongside | | gamemaker | Glitchless for GameMaker 2024.2+ (GML scripts, a local package or tools/install.mjs): frame windows from delta_time, hitches named by what GameMaker can see (texture pages, room changes, collections, instance bursts), instance, surface and DS counts for leaks, rooms as levels, crashes sent on the next launch, bug reports and -glitchless-measure for agents. A demo with planted problems, a Node test that runs the GML without GameMaker, and an end-to-end test sit alongside | | server | Intake, query API, findings and alerts: one Node 20+ server with a file store and no npm dependencies (npm run server, or the Docker image) | | apps/dashboard | The dashboard: Overview, Performance, Error Tracking, Bug Reports, Player Analytics, Heatmaps, Sessions & Replay, Versions, Live Tail, Agents | | apps/zoomies | Zoomies!, a vibe-coded Three.js platformer that ships with four realistic bugs for the demo | | apps/phaser-demo | Fetch!, a small Phaser runner (Phaser 3 or 4) with planted bugs, an autoplay bot and a playtest config (npm run game:phaser) | | apps/babylon-demo | Comet Garden, a small Babylon.js game with planted bugs (a shader per shard, a crash that stops the render loop), an autoplay bot and a playtest config (npm run game:babylon) | | apps/playcanvas-demo | Spark Run, a small PlayCanvas runner with planted bugs (a mesh per spark, a script error), an autoplay bot and a playtest config (npm run game:playcanvas) | | packages/mcp | Glitchless MCP server: glitchless_triage, glitchless_performance, glitchless_get_error, glitchless_player_funnel, glitchless_compare_versions, glitchless_bug_reports, … | | packages/playtest | glitchless-playtest: autoplay bots play every change and Glitchless compares it with a saved baseline. Also the glitchless_playtest MCP tool | | glitchless-deck (its own repo) | glitchless-deck: send a Godot, Unity, Unreal or web build from macOS, Windows or Linux to a Steam Deck on your network, start it, and measure it there against a saved baseline. Also the glitchless_deck MCP tool and the /glitchless:deck skill | | packages/sourcemaps | glitchless-sourcemaps: a CLI and a Vite plugin that upload a web build's source maps, so errors from minified builds show the original function, file and line | | plugin/glitchless | Claude Code plugin: /glitchless:instrument, /glitchless:dashboard, /glitchless:triage and /glitchless:deck skills + both MCP servers | | plugins/glitchless | The same instrument, dashboard and triage skills with the hosted MCP server, packaged for Codex and ChatGPT, Cursor and Antigravity | | plugins/dsh | glitchless-dsh: the same skills and the MCP server as a DeepSeek Harness plugin | | datadog | Datadog dashboard + monitors JSON and a setup script | | scripts/seed.js | Simulated player history generated from the game's real level data (tagged simulated) | | docs | Technical spec, set-up prompt for any coding agent |

More demos in other genres (an arena shooter, an arcade racer, a tower defense game and a metroidvania), each with its own events, planted problems, autoplay bot and dashboard, live in their own repo: The Glitch Arcade.

Quickstart: paste this into your coding agent

Open your game's folder in Claude Code, Codex, Cursor or any other coding agent and paste the prompt below. It starts a Glitchless server on your machine (with Docker, or Node), adds the SDK for your engine, connects the MCP server and builds a dashboard for your game. It asks you first about anything that needs a line in your privacy policy.

<!-- setup-prompt:start -->

Add Glitchless to this game. Glitchless shows how the game runs and plays for real players: stutters
and what causes them, crashes and errors, the game's own moments (modes, rounds, levels, purchases),
where players get stuck or quit, who comes back, lag and dropped players in an online game, and bug
reports players send. Its MCP server lets you, the coding agent, read that data, fix what players
hit and check that the fix worked.

1. Get the Glitchless agent kit, outside this project so it never gets committed:
   git clone --depth 1 https://github.com/glitchless-gg/glitchless ~/.glitchless
   If that folder already exists, run `git -C ~/.glitchless pull` instead.
   If the intake URL in step 2 starts with http://localhost, make sure a local Glitchless server is
   running there: if http://localhost:7777/v1/health answers, use it. Otherwise, with Docker, run
   `docker run -d --name glitchless -p 7777:7777 -v glitchless-data:/data ghcr.io/glitchless-gg/glitchless`
   (or `docker start glitchless` if that container already exists). Without Docker, in ~/.glitchless
   run `npm install && npm run build`, then `npm run server` in the background. The dashboard is at
   the same address.

2. Read ~/.glitchless/plugin/glitchless/skills/instrument/SKILL.md and follow it for this game. It
   covers Three.js (and React Three Fiber), Phaser 3 and 4, Babylon.js, PlayCanvas, Unity 6.3 or
   later, Godot 4.5 or later, Unreal Engine 5.8, and GameMaker 2024.2 or later; for Godot it sends
   you to ~/.glitchless/godot/addons/glitchless/README.md.
   Use these settings:
   - intake URL: http://localhost:7777
   - client token: gl_pub_dev (it's public and can only send data, so it's fine inside the game
     build). On Glitchless Cloud without a token for this game, do the sign-in in step 3 first and
     make the game with the glitchless_create_game tool: it returns the token.
   - privacy: keep the default anonymous mode. Ask me before turning on install mode (what
     retention, D1/D7/D30, needs) or full mode, because either needs a line in the game's privacy
     policy.
   If the game already reports its own analytics or counters, list them for me and send the same
   moments to Glitchless with track(), under the same names. Remove the old reporting only when I
   say so.
   If the game sells anything, send each purchase as track('purchase', { amount, currency, item }),
   so the dashboard can show revenue and conversion.
   Ask me whether players should be able to send bug reports from inside the game (a hotkey or a
   button, with a note and a screenshot). If yes, turn them on as the skill describes; the note is
   whatever the player types, so it needs a line in the privacy policy too.
   If the game has a settings or options menu, add a "Share performance data" toggle there, wired to
   Glitchless's off switch as the skill describes, so players can turn it off and back on at any
   time. If I