GODRICH
#css애니메이션#버튼#로딩#전환효과#스크롤#대시보드#실전ui#디자인트렌드

will-change transform 성능 가이드 — 프레임 비용 9장면 실측

will-change transform 같은 힌트보다 먼저 움직일 속성을 transform 과 opacity 로 고르고, 나머지는 측정으로 이득이 보일 때만 쓴다.

CSS 애니메이션 성능은 합성 속성이 가른다 — 속성부터 고른다

zip 구성과 여는 법

합성 속성은 브라우저가 이미 그려 둔 면을 다시 칠하지 않고 위치나 투명도만 바꿔 화면에 얹을 수 있는 속성으로, 대표가 transform 과 opacity 다.

같은 거리를 움직이는 방법은 여러 가지인데 속성마다 브라우저가 다시 해야 하는 일이 다르다. left·top·height 는 주변 상자의 배치까지 다시 계산하게 만들 수 있고, filter 와 box-shadow 는 다시 칠하는 면적을 키운다.

이 글의 아홉 장면은 이 차이를 한 칸씩 짝지어 잰다. A 칸과 B 칸은 거리·시간·요소 수가 같고 속성만 다르며, 프레임 시간은 화면 아래 숫자로 바로 읽힌다.

will-change transform 은 준비를 앞당기는 힌트다

will-change transform meaning 을 한 문장으로 풀면 transform 을 바꿀 요소라고 브라우저에 미리 알려 주는 힌트다. 힌트는 움직임을 빠르게 만드는 속성이 아니라 준비 시간을 움직임 앞으로 옮기는 속성이다. 이 글의 측정에서는 요소가 소수일 때 득이 보이지 않았고 많아지면 스크립트 시간이 조금 늘었다.

측정은 한 프레임 안에서 이렇게 한다

데모는 rAF 콜백이 올 때마다 쓰기와 레이아웃 읽기에 걸린 시간을 performance.now() 로 모은다. 아래가 그 부분으로, sceneStep 이 A 또는 B 칸의 속성을 바꾸고 getBoundingClientRect() 읽기가 스타일 계산과 레이아웃을 이 시간 안으로 끌어온다.

        const t1 = performance.now();
        sceneStep(mode, (clockMs / periodMs) % 1);
        // 레이아웃을 강제로 읽어 쓰기가 만든 계산 비용을 이 스크립트 시간 안으로 끌어온다 — 두 칸 모두 같은 읽기
        void rootEl.getBoundingClientRect().width;
        const t2 = performance.now();
        if (roundIdx > 0) {
            pushCap(stats[mode].sc, t2 - t1);
        }

두 칸이 같은 읽기를 하므로 차이는 쓴 속성이 만든 일에서만 나온다. css gpu 가속 이야기가 나올 때 흔히 빠지는 것이 이 구분이고, 이 시간에는 페인트·래스터·합성이 들어가지 않는다는 점이 아래 해석 전체의 전제다.

프레임 비용 9종 — 위치·투명도·필터·레이어·격리

표의 값은 도구/demo.py 가 아니라 데모 안에서 직접 잰 것이다. 무대는 480×300 고정 좌표이고, 한 왕복은 1.2초이며, A 칸 한 바퀴 40프레임과 B 칸 한 바퀴 40프레임을 번갈아 돌려 바퀴 첫 프레임을 뺀 간격과 스크립트 시간을 칸마다 최근 240개까지 모은다.

렌더는 playwright 로 연 Chrome 헤드리스이고 GPU 는 없을 수 있다. 조절값 최소·기본·최대를 각각 8초(07 은 한 번 스윕 16초) 돌리는 렌더를 두 세션 했고, 표본 N 은 칸마다 232~234개가 대부분이다. 앞 세션은 옆에서 다른 렌더가 돌던 시간대라 값이 약 3배 높았다.

그래서 이 글은 밀리초 단위 값을 쓰지 않고 두 세션에서 같은 방향으로 나온 A 대비 B 상대 비교만 쓴다. 헤드리스의 rAF 는 약 60Hz 로 묶여 프레임 간격이 16.7ms 근처에 붙으니, 한 프레임 작업이 그보다 작으면 두 칸의 간격은 같아 보이고 차이는 스크립트 시간에서만 나온다.

합성 속성이 아끼는 페인트·래스터·합성 시간은 스크립트 시간에 들어가지 않아 이 렌더 환경에서는 미확인이다. 데모가 실제로 움직였는지는 도구/demo.py 가 Chrome 으로 480×300 화면을 2초 동안 24장 찍어 이어지는 두 장의 차 23개를 비교해 확인했다.

누적면적은 24장 중 한 번이라도 첫 장과 달라진 픽셀의 점유율이고 강도는 그 픽셀의 색 차이 평균(0~255)이며, 이 값은 성능이 아니라 움직임이 화면에 있다는 확인이다.

장면 누적면적 움직인 프레임 강도 평균
01 위치 30.0% 23/23 155.6
02 투명도 30.6% 23/23 97.9
03 그리기 31.9% 23/23 99.5
04 will-change 27.6% 23/23 158.6
05 레이어 28.1% 23/23 151.3
06 스래싱 30.8% 23/23 135.3
07 요소 수 32.2% 23/23 141.7
08 격리 15.1% 23/23 138.5
09 화면 밖 37.2% 23/23 140.0

누적면적이 가장 좁은 것은 08 의 15.1% 이고 가장 넓은 것은 09 의 37.2% 다. 아래 표가 두 칸의 프레임 비용 비교이다.

장면 A 칸 B 칸 A 대비 B 스크립트 시간 읽는 법
01 위치 transform left·top 0.98~1.55배 큰 차이 없음
02 투명도 opacity height 2.3~2.8배 height 가 길다
03 그리기 blur 고정 blur·shadow 변화 1.57~1.77배 변화 쪽이 길다
04 will-change auto transform 4개 범위 겹침, 40·320개 1.20~1.31배 소폭
05 레이어 레이어 0 요소마다 will-change 1.10~1.23배 소폭
06 스래싱 읽고 바로 쓰기 읽기 모아 쓰기 0.13~0.15배(40개)·0.04배(160개)·0.02배(320개) 모으는 쪽이 훨씬 짧다
07 요소 수 transform left·top 최대 1.2배 600개까지 작은 차이
08 격리 contain 없음 contain strict 0.93~1.04배 이득 없음
09 화면 밖 일반 content-visibility 스크립트 같음, 800장 끊김 8~9회에서 0회 첫 렌더 프레임이 갈린다

06 은 A 가 느린 쪽이라 값이 1보다 훨씬 작다. 이 행은 값이 작을수록 B 가 짧다는 뜻이다.

01위치 이동 — transform 과 left·top

moveByTransform 은 translate 로, moveByLeftTop 은 left·top 값으로 같은 거리를 움직였고 요소 20~240개에서 스크립트 시간이 크게 갈리지 않았다. 이 데모의 상자는 position: absolute 라 left·top 이 이웃 상자를 밀지 않으므로, 흐름 안의 상자에는 이 결과를 옮겨 쓰지 않는다.

흐름 배치 상자의 left·top 대 transform 은 이 글에서 미확인이다.

위치 이동 — transform 과 left·top 의 프레임 시간
전체 코드 새 창에서 열기

01 · 위치 이동 — transform 과 left·top 의 프레임 시간 — 측정 누적면적 30.024% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

transformleftms
    // 합성 쪽 — transform 으로 옮긴다(left·top 은 그대로)
    function moveByTransform(els, ms, ph, tx, ty) {
        for (let i = 0; i < els.length; i += 1) {
            els[i].style.transform = 'translate(' + dxOf(ms[i], ph, tx).toFixed(2) + 'px,' + dyOf(ms[i], ph, ty).toFixed(2) + 'px)';
        }
    }
    // 레이아웃 쪽 — left·top 값을 바꿔 같은 거리를 옮긴다
    function moveByLeftTop(els, ms, ph, tx, ty) {
        for (let i = 0; i < els.length; i += 1) {
            els[i].style.left = (ms[i].x + dxOf(ms[i], ph, tx)).toFixed(2) + 'px';
            els[i].style.top = (ms[i].y + dyOf(ms[i], ph, ty)).toFixed(2) + 'px';
        }
    }

02투명도 — opacity 와 height 전환

열고 닫는 패널을 opacity 로 투명도만 바꾸는 칸과 height 를 바꾸는 칸으로 비교하면, height 칸은 카드 수가 늘수록 레이아웃을 다시 계산하느라 스크립트 시간이 길어졌다. 프레임 간격은 두 칸 모두 한 프레임 안에 들어와 이 환경에서는 끊김으로 드러나지 않았다.

높이 자체가 정보인 패널은 height 가 필요하니 opacity 로 바꾸라고 권하지 않는다.

투명도 — opacity 와 height·visibility 전환
전체 코드 새 창에서 열기

02 · 투명도 — opacity 와 height·visibility 전환 — 측정 누적면적 30.597% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

opacityheightlayout
    // 펼침 정도 e(0 에서 1) — 카드마다 조금씩 어긋나 물결로 열린다
    function openOf(i, ph) { return smooth(tri(ph + (i % 4) * 0.06)); }
    function sceneStep(m, ph) {
        const els = details[m];
        for (let i = 0; i < els.length; i += 1) {
            const e = openOf(i, ph);
            if (m === 0) {
                els[i].style.opacity = e.toFixed(3);
            }
            else {
                els[i].style.height = (DETAIL_H * e).toFixed(2) + 'px';
            }
        }
    }

03그리는 비용 — blur 와 shadow 변화

filter: blur() 와 box-shadow 크기를 프레임마다 바꾸는 B 칸은 한 번만 정하는 A 칸보다 스크립트 시간이 길었고, 블러 반경 4px 와 24px 두 조절값에서 같은 방향이었다. 래스터 비용은 이 환경에서 미확인이라 숫자는 스타일 쪽 비용만 보인다. 흐림·그림자를 움직일 때는 값을 바꾸는 횟수를 줄일 수 있는지 먼저 따진다.

그리는 비용 — filter blur 와 box-shadow 애니메이션
전체 코드 새 창에서 열기

03 · 그리는 비용 — filter blur 와 box-shadow 애니메이션 — 측정 누적면적 31.885% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

filtershadowpaint
    function sceneStep(m, ph) {
        moveByTransform(boxes[m], movers, ph, TRAVEL_X, TRAVEL_Y);
        if (m === 1) {
            for (let i = 0; i < BOX_N; i += 1) {
                const k = BLUR * smooth(tri(ph * 2 + movers[i].ph));
                boxes[1][i].style.filter = 'blur(' + k.toFixed(2) + 'px)';
                boxes[1][i].style.boxShadow = shadowOf(k);
            }
        }
    }

04힌트 — will-change 를 줄 때와 안 줄 때

sceneRoundStart 는 B 바퀴에서만 willChange = 'transform' 을 얹고 A 바퀴에서는 auto 로 되돌려, 힌트를 얹은 직후의 첫 프레임을 따로 잰다. 요소 4개에서는 두 칸의 범위가 겹쳤고 40개와 320개에서 B 가 조금 길었으며 첫 프레임 간격은 같았다.

움직일 요소가 소수일 때는 will-change 를 쓰지 않고, 레이어 생성 비용은 미확인이다.

힌트 — will-change 를 줄 때와 안 줄 때
전체 코드 새 창에서 열기

04 · 힌트 — will-change 를 줄 때와 안 줄 때 — 측정 누적면적 27.581% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

will-changefirsthint
    // 바퀴가 시작될 때 B 칸에만 힌트를 얹고, A 바퀴에서는 B 칸 힌트를 걷는다 — 힌트를 얹은 직후의 첫 프레임이 따로 잡힌다
    function sceneRoundStart(m) {
        for (let i = 0; i < boxes[1].length; i += 1) {
            boxes[1][i].style.willChange = m === 1 ? 'transform' : 'auto';
        }
    }

05레이어 수 — 합성 레이어가 너무 많아질 때

LAYERS 개 요소마다 will-change: transform 을 주면 레이어가 그 수만큼 만들어지고, 스크립트 시간은 레이어 0 칸보다 조금 길었다. 레이어 메모리는 가로×세로×4바이트로 어림한 추정치일 뿐 브라우저가 잡는 실제 값이 아니다. 화면의 요소 전체에 한꺼번에 will-change 를 거는 방식은 쓰지 않는다.

레이어 수 — 합성 레이어가 너무 많아질 때
전체 코드 새 창에서 열기

05 · 레이어 수 — 합성 레이어가 너무 많아질 때 — 측정 누적면적 28.142% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

layersmemorycount
        tags[0].textContent = '레이어 0';
        tags[1].textContent = fill('레이어 {a}', String(LAYERS));
        movers = makeMovers(LAYERS, 525, SIZE, TRAVEL_X, TRAVEL_Y);
        boxes = [buildBoxes(arenas[0], movers, SIZE, ''), buildBoxes(arenas[1], movers, SIZE, '')];
        for (let i = 0; i < LAYERS; i += 1) {
            boxes[1][i].style.willChange = 'transform';
        }
    }

06레이아웃 스래싱 — 읽기와 쓰기를 섞을 때

섞는 A 칸은 요소마다 offsetWidth 를 읽을 때 직전 쓰기를 레이아웃으로 풀어야 해서 요소 수만큼 레이아웃이 일어나고, B 칸은 읽기를 모두 모은 뒤에 쓴다. 320개에서 A 의 평균 프레임 간격은 약 41ms 로 올라 B 의 16.7ms 와 갈렸으며 이 값은 이 렌더 환경 기준이다. JS 로 여러 요소를 읽고 쓰는 반복문에 맞는다.

레이아웃 스래싱 — 읽기와 쓰기를 섞을 때
전체 코드 새 창에서 열기

06 · 레이아웃 스래싱 — 읽기와 쓰기를 섞을 때 — 측정 누적면적 30.819% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

readwritebatch
        if (m === 0) {
            // 칸 하나마다 폭을 읽고 바로 쓴다 — 읽을 때마다 레이아웃을 다시 푼다
            for (let i = 0; i < els.length; i += 1) {
                const cur = els[i].offsetWidth;
                els[i].style.width = (targetW(i, ph) + (cur < 0 ? 1 : 0)).toFixed(2) + 'px';
            }
        }
        else {
            // 폭을 전부 먼저 읽고 나서 전부 쓴다 — 레이아웃은 마지막에 한 번
            const seen = [];
            for (let i = 0; i < els.length; i += 1) {
                seen.push(els[i].offsetWidth);
            }
            for (let i = 0; i < els.length; i += 1) {
                els[i].style.width = (targetW(i, ph) + (seen[i] < 0 ? 1 : 0)).toFixed(2) + 'px';
            }
        }

07요소 수 — 많은 요소를 한꺼번에 움직일 때

요소 수를 100에서 600까지 올려도 transform 칸과 left·top 칸의 스크립트 시간은 같은 기울기로 늘었고 left·top 쪽이 최대 1.2배였다. ladders 눈금은 단계마다 잰 시간을 막대 높이로 쌓아 꺾이는 지점을 보여 주지만 이 범위에서는 꺾임이 없었다.

파티클·카드를 수백 개 띄울 때 transform 을 고르되 600개를 넘는 구간은 미확인이다.

요소 수 — 많은 요소를 한꺼번에 움직일 때
전체 코드 새 창에서 열기

07 · 요소 수 — 많은 요소를 한꺼번에 움직일 때 — 측정 누적면적 32.174% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

countscaleknee
    function build() {
        movers = makeMovers(COUNT, 527, SIZE, TRAVEL_X, TRAVEL_Y);
        for (let k = 0; k < 2; k += 1) {
            boxes[k] = buildBoxes(arenas[k], movers, SIZE, '');
            const lad = mk('div', 'pf__ladder', arenas[k]);
            ladders[k] = [];
            for (let j = 0; j < COUNT_LIST.length; j += 1) {
                ladders[k].push(mk('i', '', lad));
            }
        }
    }

08격리 — contain 으로 다시 계산 범위 줄이기

buildCards 가 B 칸 카드에 contain: strict 를 주면 한 카드 안의 변화가 밖으로 퍼지지 않게 가두지만, 카드 50~400장에서 스크립트 시간은 두 칸이 사실상 같았다. 카드 크기가 고정이라 가두어도 모양이 바뀌지 않는 조건이다. 이 범위에서는 이득이 안 보여 contain 을 쓰지 않는다.

격리 — contain 으로 다시 계산 범위를 줄이기
전체 코드 새 창에서 열기

08 · 격리 — contain 으로 다시 계산 범위를 줄이기 — 측정 누적면적 15.131% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

containscopelayout
            const card = mk('div', 'pf__card', grid);
            if (contained) {
                card.style.contain = 'strict';
            }
            const inner = mk('i', 'pf__in', card);
            if (i < LIVE_CARDS) {
                out.push(inner);
            }

09화면 밖 — content-visibility 로 그리기 건너뛰기

content-visibility: auto 와 contain-intrinsic-size 를 준 B 목록은 화면 밖 카드를 그리지 않아, 800장에서 일반 목록이 만든 끊김이 사라졌다. 스크롤 스크립트 시간은 두 칸이 같아 스크롤로 카드가 들어올 때의 지연은 보이지 않았다. 60장에서는 두 칸 모두 끊김이 0회라 이 속성을 쓰지 않는다.

화면 밖 — content-visibility 로 그리기 건너뛰기
전체 코드 새 창에서 열기

09 · 화면 밖 — content-visibility 로 그리기 건너뛰기 — 측정 누적면적 37.237% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

content-visibilityrenderskip
        for (let i = 0; i < CARDS; i += 1) {
            const item = mk('div', 'pf__item', box);
            for (let k = 0; k < CELLS_PER_CARD; k += 1) {
                mk('i', '', item);
            }
            if (m === 1) {
                item.style.setProperty('content-visibility', 'auto');
                item.style.setProperty('contain-intrinsic-size', 'auto 20px');
            }
        }

어떤 속성으로 움직일까 — 고르는 기준은?

고르는 순서는 그 움직임이 레이아웃을 바꾸는지부터 묻는 것이다. 위치와 나타남이 전부이면 transform 과 opacity 로 하고, 크기가 뜻이면 레이아웃 비용을 알고 고르며, 힌트와 격리는 그다음에 측정으로 이득을 확인한 것만 남긴다.

하려는 일 먼저 고를 것 근거 절
위치 이동 transform 01·07
나타남·사라짐 opacity 02
높이가 뜻인 열고 닫기 height, 비용을 알고 02
흐림·그림자 변화 값을 바꾸는 횟수 줄이기 03
시작을 아는 소수 요소 will-change, 효과 확인 뒤 04·05
여러 요소의 크기 읽고 쓰기 읽기를 모아서 쓰기 06
긴 카드 목록의 첫 렌더 content-visibility 09
독립 위젯이 많은 화면 contain, 효과 확인 뒤 08

한 화면에 여러 일이 겹치면 가장 큰 비용부터 줄인다. 이 글의 표에서 가장 크게 벌어진 것은 06 의 읽기·쓰기 섞기였고, 다음이 02 의 height 였다.

카드 테두리와 입체감을 transform 으로 움직이는 쪽은 CSS 3D 큐브 캐러셀 틸트에서 볼 수 있다.

긴 목록의 자리 표시를 다루는 쪽은 지연 로딩 플레이스홀더 UI 패턴에서 같은 선택을 실제 화면으로 이어 볼 수 있다.

브라우저가 한 프레임을 그리는 순서 — 동작 흐름

스타일 계산과 레이아웃이 먼저 일한다

값이 바뀌면 브라우저는 먼저 어느 규칙이 적용되는지 다시 계산하고, 크기나 위치가 달라졌으면 그 요소와 이웃의 배치를 다시 계산한다. 06 의 읽기가 이 단계를 앞당겨 강제로 일으키는 이유가 여기에 있다.

페인트와 래스터가 그다음이다

배치가 끝나면 어떤 픽셀을 어떤 색으로 칠할지 그림 목록을 만들고, 그 목록을 실제 픽셀로 바꾼다. 03 의 filter·box-shadow 는 이 칠하는 일을 키우는 쪽이지만, 이 일은 스크립트 시간에 안 들어가서 이 글은 방향만 말한다.

합성은 면을 쌓아 한 화면으로 만든다

칠해 둔 면을 겹쳐 한 화면으로 만드는 마지막 단계에서 transform 과 opacity 는 면을 다시 칠하지 않고 위치와 투명도만 바꿀 수 있다. will-change 는 이 면을 미리 따로 만들어 두라는 힌트이고, 05 처럼 면이 늘면 합쳐야 할 것도 늘어난다.

실제 화면에 붙이는 법 — 라이브러리 없이 쓰기

움직이는 속성은 두 개로 시작한다

애니메이션 키프레임에는 transform 과 opacity 만 쓰고, 위치는 처음 한 번 left·top 으로 잡은 뒤 움직임은 translate 로만 옮기는 구성이 01 데모와 같은 구조다. 높이 전환이 꼭 필요하면 02 처럼 그 요소 하나에만 두어 비용이 퍼지지 않게 한다.

will-change 는 움직이기 직전에 켜고 끝나면 끈다

will-change transform css 를 스타일시트에 늘 걸어 두기보다, 포인터가 올라오는 것처럼 움직임이 곧 시작될 때 element.style.willChange = 'transform' 로 켜고 transitionend 에서 auto 로 되돌린다.

04 데모가 바퀴 시작에서 켜고 A 바퀴에서 걷는 흐름이 이 순서이고, 켜고 끄는 시점을 잡기 어려운 요소는 힌트를 주지 않는 쪽이 낫다.

읽기와 쓰기는 두 번의 반복문으로 나눈다

여러 요소를 다룰 때는 첫 반복문에서 offsetWidth 같은 읽기를 배열에 모으고 둘째 반복문에서 쓰기를 한다. 06 의 B 칸이 이 구조이며 요소 수가 늘수록 이 차이가 커진다.

긴 목록은 content-visibility 와 크기 힌트를 한 쌍으로 준다

화면 밖 카드에 content-visibility: auto 를 주면 건너뛴 카드의 높이가 0 이 되어 스크롤바가 흔들리므로, 09 처럼 contain-intrinsic-size 로 대략의 높이를 함께 준다. css contain layout 처럼 격리하는 속성은 08 처럼 이득을 먼저 재 보고 남긴다.

성능이 깨지는 함정 — will-change 남발과 레이어 폭증

요소마다 will-change 를 걸어도 이득은 보이지 않았다

05 에서 레이어 20개와 200개 모두 요소마다 will-change 를 준 칸의 스크립트 시간이 레이어 0 칸을 웃돌았고, 04 의 요소 40개와 320개도 마찬가지였다. 이득이 확인된 구간은 이 글에 없다. 힌트는 소수의 요소에서, 움직이기 직전에, 끝나면 끄는 것이 안전하다.

레이어가 늘면 메모리가 요소 수에 비례한다

레이어 메모리는 가로×세로×4바이트를 레이어 수만큼 더한 어림 추정치이며 실제로 브라우저가 잡는 값이 아니다. 05 데모의 30×30 상자 200개는 1배 화면 기준 약 703KB 로 어림되며, 요소가 소수일 때는 이 값이 작아 문제로 드러나지 않는다.

읽기와 쓰기를 섞으면 프레임이 밀린다

06 에서 A 칸은 요소 160개에서 끊김이 1~2회 나오기 시작했고 320개에서는 평균 간격이 41ms 대로 올라 프레임 하나 길이의 두 배를 넘겼다. 이 값은 이 환경의 상대 비교이며, 기기가 느리면 같은 반복문이 한 프레임을 넘기는 요소 수가 줄어들 수 있다.

값을 바꿔 본 차이

요소 수·레이어 수·블러 반경을 하나씩 바꿔 본 결과를 표로 모았다. 위 함정의 수치는 이 표에서 반복하지 않았다.

이름 바꾼 값 느낌
움직이는 요소 수를 늘려 07 COUNT 100 → 600 두 칸 모두 스크립트 시간이 약 4배로 올라 같은 기울기로 늘고, 600개까지 꺾임은 보이지 않는다
레이어 수를 바꿔 05 LAYERS 20 → 200 두 칸의 비가 1.10~1.20배에서 1.20~1.23배로 조금 올라 차이가 약간 커진다
블러 반경을 키워 03 BLUR 4px → 24px 스크립트 시간 비는 1.69~1.77배에서 1.67~1.71배로 거의 같고, 반경이 커질 때의 페인트 비용은 미확인이다

세 값이 건드리는 대상은 서로 다르다. COUNT 는 반복문의 길이, LAYERS 는 합성할 면의 수, BLUR 는 칠하는 범위이므로 하나씩 바꿔 어느 값이 숫자를 움직였는지 본다.

소스 전체와 react 판은 아래 상자의 zip 에 들어 있고, 열 때 쓰는 암호는 845ng2t7 이다.

브라우저 호환 — Chrome·Safari·Firefox·Edge

데모는 모든 계산을 스크립트와 인라인 스타일로 하므로 이 표의 지원 여부와 상관없이 돈다. 표는 실제 화면에 옮길 때 어느 버전부터 되는지를 mdn/browser-compat-data JSON 에서 읽은 것이다.

기능 Chrome Safari Firefox Edge
will-change 36 9.1 36 Chrome 값을 따름
contain 52 15.4 69 Chrome 값을 따름
content-visibility 85 18 125 Chrome 값을 따름
contain-intrinsic-size 83 17 107 Chrome 값을 따름

표의 숫자는 각 브라우저에서 해당 속성이 처음 지원된 버전이다. Edge 칸에는 별도 버전이 없고 Chrome 의 값을 그대로 쓰라는 mirror 표시만 있어 「Chrome 값을 따름」 으로 적었다.

각주: 위 표에서 Edge 는 네 행 모두 browser-compat-data 의 mirror 항목이다.

출처: MDN will-change · MDN contain

출처: MDN content-visibility · MDN contain-intrinsic-size

수치 원본은 browser-compat-data 의 css/properties/will-change.json·contain.json·content-visibility.json·contain-intrinsic-size.json이다.

어느 행을 보고 쓸까

가장 늦은 칸은 content-visibility 의 Safari 18 과 Firefox 125 다. 지원 전 브라우저는 이 속성을 읽지 않아 목록을 평소대로 그리므로 09 의 이득만 빠지고 모양은 같다.

contain 은 Safari 15.4 부터이고 08 에서 이득도 안 보였으니, 호환 때문에 고민할 이유가 없다. 힌트인 will-change 는 지원 전 브라우저에서 읽히지 않아도 모양이 바뀌지 않는다.

성능 접근성 — 느린 기기와 움직임 줄이기 설정

모든 장면은 시간표로만 움직이는 자동 시연이라 조작 없이 끝까지 볼 수 있다. 프레임 시간이 화면 숫자로도 표시되어 움직임을 못 보는 사용자도 두 칸의 비교값을 읽는다.

일시정지는 Space·Enter·P, 처음부터는 R, 조절값은 방향키이고 탭이 숨으면 루프가 멈춘다. 상태 줄은 aria-live="off" 로 시연 중에 읽히지 않으며, 낭독 문장은 일시정지·움직임 줄이기·조절값이 바뀔 때만 role="status" 문단에 쓴다.

움직임 줄이기가 켜져 있으면 루프를 돌리지 않고 같은 쓰기를 PROBE_N 번 동기로 반복해 스크립트 시간만 채우며, 프레임 간격은 재지 않고 화면에는 움직임이 없다. 독자의 화면에는 아래처럼 붙이면 된다.

@media (prefers-reduced-motion: reduce) {
    .scene * { animation: none; transition: none; }
}
const reduce = window.matchMedia('(prefers-reduced-motion: reduce)');
reduce.addEventListener('change', function () {
    if (reduce.matches) { cancelAnimationFrame(rafId); }
});

위 앞부분은 CSS 이고 뒷부분은 JS 이며, 움직임 줄이기가 켜지면 장식 애니메이션을 끄고 측정 루프도 멈춘다. 선택자와 rafId 이름은 자기 화면에 맞게 바꾼다.

느린 기기에서는 같은 반복문이 한 프레임을 넘기는 요소 수가 줄 수 있으므로, 06 처럼 요소 수에 비례해 느려지는 반복문은 요소 수를 줄이거나 읽기를 모으는 것이 먼저다.

성능 FAQ — GPU 가속이면 빨라지나

GPU 가속이면 빨라지나요

이 렌더 환경에서는 GPU 가 없을 수 있어 가속의 이득은 확인하지 못했다. opacity 칸은 height 칸보다 스크립트 쪽 비용(스타일 계산·레이아웃)이 짧았고, will-change 로 면을 따로 만든 칸은 오히려 조금 길었다. 합성이나 래스터가 얼마나 빨라지는지는 이 글에서 미확인이라, 속성 선택과 레이어 수가 어떻게 영향을 주는지는 자기 화면에서 재 보고 정한다.

will-change 는 언제 쓰나요

움직임이 곧 시작될 것을 알고 요소가 소수일 때, 시작 직전에 켜고 끝나면 끈다. 이 글의 04·05 측정에서 요소를 늘릴수록 이득이 나타나지 않았으므로, 효과를 재 보지 않은 채 스타일시트에 걸어 두지 않는다.

contain 은 쓸 만한가요

08 의 카드 50~400장 범위에서는 이득이 안 보였다. 독립 위젯이 훨씬 많거나 한 위젯의 변화가 잦은 화면은 이 글에서 미확인이라, 자기 화면에서 같은 방식으로 재고 정한다.

출처 문서는 MDN 의 will-change 항목과 contain 항목이다.

압축 비밀번호를 입력하세요

비밀번호는 이 글 본문 안에 있습니다. 읽다 보면 나옵니다.