Knowledge baseExam Center
ENEnglish
Choose language13

CKTIS / CSS

Rendering performance in DevTools: screenshots, FPS, Paint flashing and Layers

Screenshots show appearance, FPS describes frame rate, Paint flashing marks painted regions, and Layers shows compositing structure. None of these signals is a performance guarantee you can derive from CSS alone.

Version: Browser DevTools workflow; UI and feature availability vary by browser and version

Syntax

Performance, Screenshots, FPS, Paint flashing and Layers are DevTools diagnostics, not CSS syntax. Their names, availability and interfaces depend on the browser and its version; CSS specifications define the animation and media query used in the example, not the diagnostic tools. The example uses `animation: move-left 2s linear infinite alternate;` inside `@media (prefers-reduced-motion: no-preference)`. Replace `move-left` with `move-transform` in that declaration for the comparison.

“DevTools Performance/Screenshots, FPS, Paint flashing i Layers” groups four diagnostics, not four names for the same measurement. A Performance recording gives you a timeline where you can look for style, layout and paint events. Screenshots, when available, add a filmstrip of sampled page appearances. Line up those snapshots with the trace: they are neither a record of every frame nor a measure of rendering cost.

FPS means frames per second. Check individual frame timings too: a good average can hide occasional stutter. A 60 Hz display has about 16.7 ms between refreshes; that is not a universal frame budget. Paint flashing highlights regions being painted or repainted while you watch; it does not time the work. No flashing does not mean no rendering work: the compositor may be combining previously painted content.

Layers shows the layers used by the compositor, not CSS cascade layers (@layer) or stacking contexts. A non-none transform creates a stacking context for a regular CSS box, but does not guarantee a separate compositing layer. will-change is an optimization hint, not a command to create a layer; extra layers can cost memory.

Compare the same movement using left and transform. Changing left can require layout and paint, while animating transform may be handled by compositing alone. Treat those as hypotheses to test, not CSS guarantees. Repeat under matching conditions and check results on target devices. Tool names and availability vary by browser and version.

Examples

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Rendering performance comparison</title>
  <style>
    #square {
      position: relative;
      left: 0;
      width: 48px;
      height: 48px;
      background: #2563eb;
    }

    @media (prefers-reduced-motion: no-preference) {
      #square {
        animation: move-left 2s linear infinite alternate;
      }
    }

    @keyframes move-left {
      from { left: 0; }
      to   { left: 120px; }
    }

    @keyframes move-transform {
      from { transform: translateX(0); }
      to   { transform: translateX(120px); }
    }
  </style>
</head>
<body>
  <div id="track"><div id="square"></div></div>
  <p><output id="observation"></output></p>
  <script>
    const track = document.querySelector('#track');
    const square = document.querySelector('#square');
    const observation = document.querySelector('#observation');
    const motion = matchMedia('(prefers-reduced-motion: no-preference)');
    const variants = ['move-left', 'move-transform'];
    const origin = track.getBoundingClientRect();
    const { width, height } = square.getBoundingClientRect();
    const { animationName, backgroundColor } = getComputedStyle(square);
    const close = (a, b) => Math.abs(a - b) < 0.01;

    function check(condition, message) {
      if (!condition) throw new Error(message);
    }

    // Sample the actual CSS animation at known times, before profiling it.
    function measure(name) {
      square.style.animationName = name;
      const [animation] = square.getAnimations();
      check(animation?.animationName === name, `Missing animation: ${name}`);
      animation.pause();

      const { duration, direction, iterations } = animation.effect.getTiming();
      check(duration === 2000 && direction === 'alternate' && iterations === Infinity,
        `Unexpected timing: ${name}`);

      const offsets = [0, 0.5, 1, 1.5, 2].map(step => {
        animation.currentTime = step * duration;
        const rect = square.getBoundingClientRect();
        check(close(rect.top, origin.top), `Unexpected vertical movement: ${name}`);
        return rect.left - origin.left;
      });
      check(offsets.every((x, i) => close(x, [0, 60, 120, 60, 0][i])),
        `Unexpected horizontal movement: ${name}`);
      return { distance: Math.round(offsets[2] - offsets[0]), seconds: duration / 1000 };
    }

    try {
      check(width === 48 && height === 48 && backgroundColor === 'rgb(37, 99, 235)',
        'Unexpected square size or color');

      if (motion.matches) {
        check(variants.includes(animationName), 'The media query did not activate a comparison variant');
        let measured;
        try {
          measured = measure(animationName);
          measure(variants.find(name => name !== animationName));
        } finally {
          // Remove the paused test animation and let the stylesheet start a fresh one.
          square.style.animationName = 'none';
          square.getAnimations();
          square.style.removeProperty('animation-name');
        }
        const { distance, seconds } = measured;
        observation.textContent = `When the media query matches, a blue ${width} × ${height} CSS-pixel square moves ${distance} CSS pixels to the right in ${seconds} seconds and back in ${seconds} seconds, repeating in either variant. Otherwise it stays at the starting position. No specific FPS, paint pattern, timing cost or layer configuration is expected across browsers and devices.`;
      } else {
        const rect = square.getBoundingClientRect();
        check(animationName === 'none' && square.getAnimations().length === 0 &&
          close(rect.left, origin.left) && close(rect.top, origin.top),
          'The square is not static at its starting position');
        observation.textContent = `The media query does not match. The blue ${width} × ${height} CSS-pixel square stays at the starting position.`;
      }
    } catch (error) {
      observation.textContent = error.message;
      throw error;
    }
  </script>
</body>
</html>

Result

When the media query matches, a blue 48 × 48 CSS-pixel square moves 120 CSS pixels to the right in 2 seconds and back in 2 seconds, repeating in either variant. Otherwise it stays at the starting position. No specific FPS, paint pattern, timing cost or layer configuration is expected across browsers and devices.

Change only the animation name from `move-left` to `move-transform`. Check that the square travels the same distance in the same time, then compare the traces. If `prefers-reduced-motion: no-preference` does not match, the square stays still.

Related lessons

  • CSS · Lesson 29 · Advanced · Version: 2

Sources