I made Tabloaf, a pixel cat for Chrome and Firefox. It walks across whatever page you have open, sits on pictures and headings, and chases a ball of yarn.
TL;DR: while the cat walks, Chrome's GPU process went from 15–17% of a core to ~7%, and Firefox's page process from 19–20% to ~2%.
Chrome renders the page in a renderer process and composites layers in a separate GPU process. In Firefox the page (content) process is roughly the renderer. Every percentage here is CPU time as a share of one core, not GPU load.
The default cat is 60×48 CSS pixels. A rectangular hit box would also catch clicks in the empty space around its ears and tail, so I clipped the clickable area to the cat's outline with clip-path.
I put that clip on the canvas that was already moving.
Moving the walk off the frame loop
An earlier version saved CPU by stepping the walk one art pixel at a time, but it looked jerky. I went back to moving it on every display frame with requestAnimationFrame (rAF).
Then I moved straight walks and runs to Element.animate(). JavaScript wakes only to redraw the legs (the next sprite frame) and to decide what the cat does next. Everything else (the yarn game, dragging, jumps) still runs on rAF.
With Element.animate() the browser moves the cat, so my code computes its x from the animation's start time and speed. If you grab the cat halfway across the screen, I cancel the animation and pin the cat where it was drawn.
In Chrome the renderer dropped. The GPU process barely moved.
The clip on the moving canvas
I thought image-rendering: pixelated was the expensive part. Turning it off did almost nothing. Taking the clip off the moving canvas cut the GPU process by more than half. I didn't dig into why.
So I split the cat into two elements: the canvas with pointer-events: none, and an empty hit element that carries the outline and gets the clicks. Both move on the same animation clock:
canvas.style.pointerEvents = "none"; // the picture ignores the pointer hit.style.clipPath = outlinePath; // an empty div takes the clicks for (const el of [canvas, hit]) el.animate(frames, opts).startTime = now; // same clock for both Chrome, one walking sample per stage (a separate session):
| Stage | Renderer | GPU process |
|---|---|---|
| rAF, clip on the canvas | ~12% | ~14% |
| Web Animations, clip on the canvas | ~8% | ~13% |
| Web Animations, separate hit element | ~8% | ~6% |
In Firefox, the big win came from the earlier step: the move to Web Animations alone cut its page process by more than two-thirds.
The legs were still changing the hit outline
The hit outline still changed with every leg position, and a walk cost ~4–5% in Firefox's page process. With the hit element hidden it was ~2%: useless, since you can't grab the cat, but it showed the floor.
I kept the outline but stopped changing it with the legs: during an animated walk, the hit outline is one shape that covers every leg position. That leaves about a quarter of the empty space in the cat's box clickable while it walks. Other states keep their exact outlines.
Firefox's page process came down to the same ~2% as with the hit element hidden. In Chrome the single outline made no measurable difference.
Why not test the pixel mask in JavaScript and skip clip-path? The browser decides whether a touch scrolls the page by looking at the element under the finger, before any of my handlers run. Without a real element shaped like the cat, a touch on the cat would scroll the page. The grab cursor also has to change when the cat walks under a still mouse. I haven't benchmarked that approach.
Before and after
The older build used rAF with the clip on the canvas. The optimized one has all three changes: Web Animations, the separate hit element, and one outline for the walk. I alternated them twice in each browser; one optimized Firefox run didn't complete.
| Walk | Older | Optimized |
|---|---|---|
| Chrome renderer | 12–13% | ~8% |
| Chrome GPU process | 15–17% | ~7% |
| Firefox page process | 19–20% | ~2% |
It didn't get any less smooth. In a Chrome trace, the 95th-percentile frame time on walks stayed at ~17.5 ms before and after, with no frame over 20 ms.
The yarn game is still the expensive part: its thread is redrawn on every frame.
About the measurements
- October 20, 2026, a MacBook Air M4, 60 Hz display at DPR 2, real browser windows.
- Playwright's Chromium build and Firefox 157.
- en.wikipedia.org/wiki/Cat, the cat at its default size, 10–12 seconds per sample.
- Chrome numbers come from CDP process info, Firefox numbers from
ChromeUtils.requestProcInfo()over the debugging connection. - As a control, I moved a plain 60×48 canvas with rAF in every session. It read about the same each time, so the sessions are comparable.
- The numbers include the live page. I measured dev builds, not what's in the stores now.
AI agents helped me implement the alternatives and write the benchmark harnesses. They also helped with the sprites and with looking up which coat patterns are common in different parts of the world, so there's a good chance one looks like your cat.

