Three.js game analytics and observability tools

The Glitchless team · October 29, 2026 · three.js and React Three Fiber games in the browser, checked against each tool's docs on 29 October 2026

A Three.js game needs two kinds of tool: ones that show what a frame costs on your own machine while you build, and ones that collect what happens on players' devices once it ships. Lists of "best tools" tend to mix them up. These are the ones worth knowing in 2026, grouped the way you'd use them, with what each is best for and what it misses.

Glitchless is ours, so read its entry with that in mind. Every other entry was checked against the tool's own docs and pricing on 29 October 2026.

The short answer

On your machine: renderer.info and stats.js for counts and FPS, three-perf (r3f-perf in React Three Fiber) for CPU and GPU time, Spector.js to take one frame apart, and Chrome DevTools' Performance panel to see where a slow frame's time went.
Players' behaviour: PostHog for funnels, retention, canvas replays and experiments; GameAnalytics for progression and free-to-play KPIs.
Errors and the rest of your stack: Sentry for JavaScript errors and long animation frames; Datadog RUM if your studio already runs Datadog.
Where they meet: Glitchless times every frame on players' devices and names each hitch's likely cause, next to levels, errors and your own events, and gives your coding agent all of it over MCP.

At a glance

"Your machine" means it measures the device you're holding. "Players" means it collects from everyone who plays.

Checked against each tool's docs and pricing on 29 October 2026. Sources at the end.
Tool	Measures	Best for	Misses	Price
`renderer.info`	Your machine	Draw calls, triangles, geometries, textures and programs, read in code	Timing, and anything from players	Built into three.js
stats.js	Your machine	A live FPS and ms-per-frame panel	An average hides hitches; nothing from players	Free, MIT
three-perf, r3f-perf	Your machine	CPU, GPU and FPS graphs with geometry, texture and shader counts	Anything from players	Free, MIT
Spector.js	Your machine	Every WebGL call, state, texture and shader in one captured frame	One frame at a time, on your GPU	Free, MIT
Chrome DevTools Performance	Your machine	Where a slow frame's time went: scripts, garbage collection, rendering	Your device only	Free
PostHog	Players	Funnels, retention, canvas replays and experiments	Frame times and what caused a stutter	Free for 1M events and 5,000 web recordings a month, then usage-based
GameAnalytics	Players	Progression, economy, purchases and ad KPIs	Frame-by-frame times and a drop's cause	Free with no player cap; Pro $29 a month billed yearly
Sentry	Players	JavaScript errors with stack traces, long animation frames, web vitals	Levels, frame times and stutter causes	Free for 5,000 errors and 50 replays a month (1 user); Team from $26 a month billed yearly
Datadog RUM	Players	The game and its servers in one place, for studios on Datadog	Game concepts: frames, levels	Per 1,000 sessions: $0.15 to measure, $3 to investigate (billed yearly)
Glitchless	Players	Every frame with each hitch's cause, levels, errors and events, read by your coding agent	Feature flags, experiments and video replay	Free for 5,000 play sessions a month; from $19 a month; MIT to self-host

On your machine, while you build

These are free, and the first thing to reach for when a scene feels heavy. They all measure the device in front of you, so they tell you what a frame costs, not what players get.

renderer.info is built into three.js: renderer.info.render.calls and .triangles for the last frame, renderer.info.memory.geometries and .textures, and renderer.info.programs. Log it, or watch it climb to catch a leak.
stats.js, from three.js's author, draws a small panel with FPS and milliseconds per frame (and memory in Chrome with a flag). Quick, but it shows an average, and a 58 FPS average can hide a 120 ms hitch.
three-perf (vanilla three.js) and r3f-perf (React Three Fiber) draw CPU, GPU and FPS graphs with counts of geometries, textures and shaders. r3f-perf can also break programs down in detail. Both are MIT.
Spector.js captures one frame and lists every WebGL command, the state, textures and shaders behind it. Use it as a browser extension or from npm. It now has an MCP server too, so a coding agent can capture and inspect a frame on your machine.
Chrome DevTools' Performance panel records a few seconds and shows where each slow frame's time went: your scripts, garbage collection, layout or the GPU. The place to start when a hitch only happens sometimes.

From players: what they do

PostHog is product analytics with a large free tier. You send events (posthog.capture('level_completed', { level: 3 })) and get funnels, retention and paths, plus feature flags and experiments. Session replay records a WebGL canvas once you turn canvas recording on, at 4 frames a second by default. It doesn't know what a frame is, so frame time and stutters are only there if you send them.

GameAnalytics is built for games, mostly free-to-play. Its JavaScript SDK sends progression, resource, business, ad, design and error events, and its dashboards show retention, cohorts and monetisation KPIs, free with no cap on players. Health data such as FPS needs the Pro plan, and it doesn't say what caused a drop.

Which of the two fits a browser game, side by side: PostHog vs GameAnalytics for browser games.

From players: errors and the rest of your stack

Sentry catches JavaScript errors with stack traces, and its tracing records page loads, web vitals, long tasks and long animation frames (on by default). Canvas replay is opt-in, and a WebGL canvas needs preserveDrawingBuffer or manual snapshots. It's strong on errors and knows nothing about levels or frame times.

Datadog RUM collects sessions, views, actions, errors, resources, long tasks and web vitals. It makes sense when the studio already runs its servers on Datadog and wants the game in the same place; it doesn't model frames or levels. Glitchless can forward its data to Datadog or any OpenTelemetry backend, so the two work together.

Where they meet: Glitchless

Glitchless does what the tools on your machine do, on every player's device, and puts it next to what players do. Every frame is timed and merged across players by device, level and release, so you see the slowest frames real players get, not your laptop's average. Each hitch comes with its likely cause (a long script, a shader compiling the first time a material is drawn, garbage collection, an asset load) and the game's events in the second and a half before it. Errors come grouped with what the player did before them, levels come with funnels, death heatmaps and rage quits, and your own events with breakdowns.

It's built for games made with coding agents: the MCP server gives Claude Code, Codex or Cursor all of it on every plan, and playtest bots check a fix before it ships. It costs 33.7 KB gzipped and about 0.6 µs of work a frame (measured). It doesn't do feature flags, experiments or video replay; pair it with PostHog if you need those.

Which to use when

Prototyping: renderer.info and three-perf (or r3f-perf) always on in development, Spector.js when a frame looks wrong, DevTools when a hitch comes and goes.
First players: one tool that collects from players. Glitchless if what matters is how the game runs and plays and an agent is doing the fixing; PostHog if the game is a product with sign-ups and experiments; GameAnalytics if it runs on an economy and ads.
A studio on Datadog or Sentry already: keep them for errors and servers, and add Glitchless for frames and play, forwarding to Datadog if you want one place.

Which ones a coding agent can use

Most have an MCP server now, so the question is what the agent sees through it.

Spector.js: a frame captured on your machine.
PostHog: its whole product, free: SQL, insights, flags, experiments, errors and replays.
Sentry and Datadog: errors, issues and traces (Datadog's server is still in development).
GameAnalytics: aggregated KPIs through its Metrics API, on PipelineIQ (from $499 a month).
Glitchless: players' frame times, hitches and their causes, errors, levels and events, with tools built for finding and fixing what players hit, on every plan. More in an MCP server for game telemetry.

Glitchless in a Three.js or React Three Fiber game

Install glitchless from npm and add two calls once the renderer exists. Or paste the setup prompt into your coding agent and let it do this.

main.js

import * as THREE from 'three';
import { Glitchless, instrumentThree } from 'glitchless';

const glitchless = Glitchless.init({
  service: 'my-game',
  version: '1.0.0',
  intake: 'https://api.glitchless.gg',
  clientToken: 'gl_pub_…', // your game's client token
});

instrumentThree(glitchless, { renderer, scene, camera, THREE });
// React Three Fiber:
// <Canvas onCreated={({ gl, scene, camera }) => instrumentThree(glitchless, { renderer: gl, scene, camera, THREE })}>

Start free What to measure in a Three.js game

Frequently asked questions

Is stats.js enough for a Three.js game?

While you build, it's a fine start. It shows your own machine's average, though, and players leave over the slowest frames on their devices, which only a tool that collects from players shows.

What's the difference between three-perf and Glitchless?

three-perf shows your machine, live, while you build. Glitchless records every player's frames after you ship, with each hitch's likely cause and what the player was doing. Use both.

Can I use Sentry for a Three.js game?

Yes, for JavaScript errors, long animation frames and web vitals. It doesn't know about levels or frame times, and replaying a WebGL canvas needs preserveDrawingBuffer or manual snapshots.

Which of these work with React Three Fiber?

r3f-perf is made for it. PostHog's, GameAnalytics', Sentry's and Datadog's JavaScript SDKs work in any page. Glitchless takes the renderer, scene and camera from the Canvas's onCreated.

Which are free?

Every tool on your machine is free. For players: GameAnalytics is free with no player cap, PostHog for 1M events and 5,000 web recordings a month, Sentry for 5,000 errors a month on one seat, and Glitchless for 5,000 play sessions a month, or free to self-host.

Sources

Something wrong or out of date? Email support@glitchless.gg and we'll fix it. Glitchless isn't affiliated with the three.js authors, Poimandres (React Three Fiber), the Babylon.js team (Spector.js), Google (Chrome), PostHog, GameAnalytics, Sentry or Datadog; product names are their owners' trademarks.