amaranth.log
💻 개발

Pretext 라이브러리

서론

오늘은 최근 화제가 되었던 pretext 라이브러리에 대해 알아보고자 한다.

Pretext란

pretext
chenglou • Updated Jun 13, 2026
: DOM 접근 없이 Canvas API를 활용해 멀티라인 텍스트의 높이와 레이아웃을 계산하는 고속 순수 자바스크립트/타입스크립트 라이브러리
Pretext는 메타 출신의 개발자 Cheng Lou가 2026년 3월 말에 공개한 라이브러리로, 텍스트의 레이아웃 측정 시 레이아웃 리플로우를 유도하지 않아 기존 방식에 비해 렌더링 성능을 최대 100~500배까지 향상시킬 수 있다고 한다.

기존의 텍스트 레이아웃 계산 방식이 갖고 있던 한계

웹에서 텍스트의 레이아웃을 계산하기 위해 주로 사용되는 방식은 화면에 DOM 엘리먼트를 렌더링한 뒤 DOM API(scrollHeight와 scrollWidth 속성 혹은 getBoundingClient() 메서드)를 통해 실제 레이아웃 크기를 읽어오는 방식이었다.
이 방식이 가진 문제점은 실제 화면에 렌더링되는 요소가 변하지 않았는데도, 계산 과정에서 레이아웃 리플로우(Layout Reflow)를 유발한다는 것이었다. 브라우저는 레이아웃 관련 CSS 속성이 변경되면 내부적으로 레이아웃을 ‘무효화’하는데, 이 상태에서 scrollHeight와 같은 값을 읽으려 하면 브라우저는 최신 값을 보여주기 위해 레이아웃을 재계산(=리플로우)한다.
특히, 여러 요소의 높이를 한 번에 측정해야 하는 상황에서 쓰기와 읽기를 아이템마다 번갈아 수행하면 레이아웃 스레싱이 발생할 수 있다.
💡
레이아웃 스레싱
브라우저는 성능을 위해 스타일 변경을 일괄로 모아두었다 한 번에 처리하는데, 도중에 읽기 연산이 발생하면 강제 리플로우가 매 변경마다 트리거된다. 결과적으로 쓰기-읽기 횟수만큼 리플로우가 연달아 발생하게 된다. 즉, 1,000개의 아이템을 측정하면 1,000번의 리플로우가 발생한다.
이와 같은 이유로 렌더링 성능이 느려지는 현상을 레이아웃 스레싱이라고 한다.
// 아이템마다 쓰기 → 읽기를 반복 → N번 reflow items.map((el) => { el.style.height = "auto"; // write: 레이아웃 무효화 return el.scrollHeight; // read: 강제 reflow 발생 });
리플로우는 JavaScript 실행을 일시 중단하고 브라우저의 메인 스레드를 점유하는 무거운 작업이기 때문에, 렌더링 성능을 크게 저하시킨다.

Pretext의 원리와 특징

  • DOM 측정 없는 텍스트 측정: Pretext는 DOM 엔진의 getBoundingClientRect 대신 Canvas API의 폰트 렌더링 엔진의 measureText을 사용해 텍스트의 레이아웃을 계산한다.
  • 뛰어난 렌더링 성능: 계산 과정에서 DOM에 접근하지 않기 때문에 레이아웃 리플로우를 유발하지 않아 복잡한 애니메이션이나 실시간 텍스트 렌더링 상황에서 엄청난 성능 향상을 제공한다.
  • 픽셀 단위 정밀도: 폰트 엔진 기반의 자체 측정 로직을 통해 텍스트 줄바꿈과 배치(Layout)를 정확하게 계산한다.
  • 경량 라이브러리: 별도의 브라우저 환경 없이 서버 측 렌더링도 지원하는 가벼운 라이브러리이다.
Pretext가 제공하는 API는 두 단계로 구성된다.
  1. prepare(text, font): Canvas의 measureText()를 통해 세그먼트(단어) 단위의 글자 폭을 측정하고 캐싱한다. 이 단계에서만 브라우저(Canvas 요소)에 접근한다.
  1. layout(prepared, maxWidth, lineHeight): 캐싱된 데이터를 기반으로 순수 수학적 연산만으로 전체 텍스트의 높이와 줄 수를 계산한다. (DOM 접근X)
데이터(텍스트)가 변경될 땐 prepare()를 다시 실행하고, 텍스트 컨테이너의 너비만 바뀔 때는 layout()만 다시 호출하면 된다. 비용이 큰 연산과 가벼운 연산이 분리되어 불필요한 재계산을 최소화한 것으로 볼 수 있다.

Pretext가 왜 좋을까?

여기까지 읽었을 때 실제로 Pretext를 쓸 일이 얼마나 있을지, 어디에 어떻게 활용하면 되는지 감이 잘 잡히지 않을 수 있다. 그래서 Pretext의 성능을 기존 방식과 비교하고 측정할 수 있는 두 개의 예제를 마련했다.
구축한 테스트 환경을 배포해두었으니 원한다면 이 페이지에서 직접 테스트해볼 수도 있다.

성능 테스트: 동적 너비에 따른 텍스트 별 높이 재계산

notion image
좌측의 너비 슬라이더를 움직일 때마다 n개(기본값 1,000개)의 텍스트 컨테이너의 너비가 업데이트되며 높이를 재계산하고 재배치하는 예제이다.
직관적인 DOM 방식, batching 기법으로 최적화한 DOM 방식, 그리고 Pretext를 사용한 방식 세 가지를 구현해 비교했다.
  1. DOM 방식
    1. const heights = refs.current.map((el) => { if (!el) return 0; el.style.height = "auto"; // write: 레이아웃 무효화 return el.scrollHeight; // read: 강제 reflow 발생 }); // 측정 후 각 아이템에 높이·위치를 일괄 적용 refs.current.forEach((el, i) => { el.style.height = heights[i] + "px"; el.style.left = ...; el.style.top = ...; }); containerRef.current.style.height = totalHeight + "px"; // 컨테이너 높이 확정
      매 아이템마다 height: auto와 scrollHeight 접근을 교대로 수행하면서 n번의 동기 리플로우가 발생한다. 이후 측정된 높이를 바탕으로 각 아이템의 height, left, top과 컨테이너의 높이를 일괄 쓰기하면 브라우저는 이 변경 사항을 다음 페인트 직전에 한 번 더 반영해야 한다. 이 최종 레이아웃 반영이 1회의 리플로우를 한 번 더 발생시키기 때문에, 1,000개 아이템 기준 총 리플로우 횟수는 N(측정 루프) + 1(최종 배치 반영)=1,001회가 된다.
      notion image
      width를 업데이트할 때마다 화면이 굉장히 버벅거리는 것을 확인할 수 있다.(레이아웃 스레싱) 레이아웃 계산에 소요되는 시간과 렌더링 시간은 700ms 대로 측정된다. layout 횟수는 상술한 대로 1,001 회로 측정된다.
  1. batching 기법으로 최적화한 DOM 방식
    1. // 1. 쓰기 일괄 처리 → 레이아웃 무효화 1회 refs.current.forEach((el) => { if (el) el.style.height = "auto"; }); // 2. 읽기 일괄 처리 → reflow 1회로 모든 높이 측정 const heights = refs.current.map((el) => (el ? el.scrollHeight : 0)); // 3. 위치 배치 (쓰기만, reflow 없음) refs.current.forEach((el, i) => { /* height, left, top 적용 */ }); containerRef.current.style.height = totalHeight + "px";
      Batching이란 쓰기 연산을 한 번에 몰아서 처리한 뒤 읽기 연산을 한 번에 몰아서 처리하는 기법이다. 브라우저는 여러 개의 쓰기 연산을 일괄로 받으면 레이아웃을 한 번만 무효화하도록 최적화되어있다. 이 무효화된 상태에서 읽기 연산을 한 번에 몰아서 수행하면, 브라우저가 단 1회의 리플로우로 모든 값을 계산해 반환한다.
      이후 측정 결과를 바탕으로 아이템의 위치를 다시 쓰기하면, 최적화 전과 마찬가지로 페인트 직전 1번의 최종 리플로우가 발생한다. 즉, 총 리플로우 횟수는 1(읽기 시 강제 재계산) + 1(최종 배치 반영) = 2회가 된다.
      이렇듯 간단한 코드 리팩터링으로 N+1회의 리플로우 횟수를 단 2회로 줄일 수 있다.
      notion image
      최적화 전에 비해 렌더링이 눈에 띄게 매끄러워졌으며, 렌더링 시간은 10~20ms, 계산 시간은 수 ms로 측정되며 매 업데이트마다 layout이 두 번 일어난다.
  1. pretext를 사용한 방식
    1. // 1단계: 텍스트가 바뀔 때만 — 폰트 메트릭 계산 (DOM 접근 없음) const preparedTexts = useMemo( () => texts.map((text) => prepare(text, FONT, { whiteSpace: "pre-wrap" })), [texts] ); // 2단계: 너비가 바뀔 때만 — 줄바꿈 계산 (DOM 접근 없음) const layoutData = useMemo(() => { return preparedTexts.map((prepared, i) => { const textHeight = layout(prepared, contentWidth, LINE_HEIGHT).height; // height, top, left 계산 ... }); }, [preparedTexts, width]);
      prepare()는 텍스트의 각 문자별 폰트 메트릭(글자 너비, 어센더/디센더 등)을 Canvas API로 미리 계산해 캐싱한다. layout()은 이 캐싱된 메트릭을 바탕으로 주어진 너비에서의 줄바꿈 위치와 총 높이를 순수 JavaScript 연산으로 계산한다. 이 계산 과정에서 DOM에 접근하지 않기 때문에 측정 과정의 리플로우는 0회다. 최종적으로 계산된 높이&위치 값을 DOM에 한 번 적용할 때 리플로우가 한 번 발생한다. 즉, 업데이트 당 리플로우 횟수는 1회이다.
      notion image
      최적화 전의 DOM 방식에 비해 훨씬 매끄럽다. 렌더링 시간은 batching 방식과 비슷해보이지만, 매 업데이트마다 layout이 단 한 번씩만 일어나며 계산 시간도 단 1~2ms 정도로 측정된다.
🤔
최적화된 DOM이랑 pretext 방식에 성능 상 큰 차이가 없는 것 같은데, 굳이 pretext를 도입할 필요가 있을까요?
사실, Batching만으로도 단순 DOM 접근 방식에 비해 수십 배의 성능 개선이 가능하다. 별도 라이브러리 없이 코드 단에서 쓰기/읽기 단계를 나누는 것만으로도 대부분의 레이아웃 스래싱 문제를 해결할 수 있다는 점은 그 자체로 실무에서 유의미한 가치를 가진다.
하지만, Batching 기법은 리플로우 횟수를 줄일 수는 있어도 텍스트 컨테이너의 너비가 업데이트될 때마다 DOM에 접근해야 실제 높이를 알 수 있다는 구조적 제약을 극복할 수는 없다.
레이아웃 비용은 DOM 노드의 개수에 따라 증가하기 때문에, 기존 방식에서는 데이터 규모가 커지거나 업데이트가 빈번해질수록 레이아웃 비용이 누적될 수 있다. 반면, Pretext는 텍스트 레이아웃을 DOM이 아닌 계산으로 처리하므로, 동일한 입력 조건에 대해 렌더링 이전에 레이아웃 결과를 결정할 수 있다.
단순한 성능 개선 효과보다도, DOM 접근 방식으로 해결할 수 없는 구조적인 문제에 대한 대안이 될 수도 있다는 점에서 의미가 있다.
이를테면 다음과 같은 문제를 들 수 있다.
  • 가상 리스트: DOM 기반 접근에서는 아이템의 높이를 렌더링 이후에만 측정할 수 있기 때문에, 가상 리스트에서 아이템의 위치를 계산하기 위해 필요한 정보를 렌더링 전에 얻을 수 없다. 이로 인해 대부분의 구현은 추정값을 기반으로 초기 레이아웃을 구성한 뒤, 실제 측정 결과를 반영하며 보정하는 방식을 취한다. 이러한 방식은 스크롤 위치의 불안정성이나 레이아웃 시프트를 유발할 수 있으며, 특히 데이터 규모가 크거나 컨테이너 크기가 자주 변경되는 환경에서 비용이 누적된다.
  • 비동기 렌더링 환경에서의 불안정성: DOM 기반 측정은 브라우저의 실제 렌더링 결과에 의존하기 때문에, 비동기 렌더링 환경에서 불안정성을 내포한다. 특히 React의 Concurrent Rendering 환경에서는 render 단계에서 DOM이 존재하지 않으며, layout 측정은 commit 이후에만 가능하다. 이로 인해 레이아웃 계산이 항상 한 박자 늦게 수행되며, 추가적인 re-render나 일시적인 레이아웃 불일치를 유발할 수 있다.
  • 예측 불가능성: DOM 레이아웃은 폰트 로딩 상태, 브라우저 엔진, 서브픽셀 반올림 등 외부 요인의 영향을 받는다. 그 결과 동일한 입력에 대해서도 항상 동일한 측정 결과를 보장하지 않으며, 이는 캐싱 전략이나 서버-클라이언트 간 일관성을 유지하는 데 있어 한계를 만든다.
이 다음의 예제에서 가상 리스트의 사례를 보여줄 것이다.

UX 지표 비교(CLS, Scroll 안정성): 가상 스크롤 구현

notion image
3,000개의 가변 높이 아이템으로 구성된 목록을 가상 스크롤 기법으로 구현하고, 특정 인덱스의 아이템 위치로 스크롤을 이동하는 예제이다.
화면 상에 보이는 요소만 DOM에 출력하는 가상 스크롤 기법 특성 상, 화면에 보이지 않는 다음/이전 요소의 높이 값을 알고 있어야 정확한 렌더링이 가능하기 때문에 텍스트 높이 측정 방식이 UX에 직접적인 영향을 끼친다.
DOM 접근 방식으로 외부 라이브러리 없이 구현한 방식과, @tanstack/react-virtual 라이브러리를 사용해 구현한 방식, pretext를 활용해 구현한 방식을 각각 비교해보았다.
  1. DOM 접근 방식으로 구현한 가상 스크롤
    1. // ResizeObserver로 화면에 보이는 아이템의 실제 높이를 비동기 관찰 const ro = new ResizeObserver((entries) => { setMeasuredState((prev) => { const heights = { ...prev.heights }; for (const entry of entries) { const idx = Number(entry.target.dataset.index); const h = entry.borderBoxSize[0]?.blockSize ?? entry.contentRect.height; if (!isNaN(idx) && h > 0) heights[idx] = h; } return { texts, heights }; }); }); // 누적 오프셋: 측정된 높이가 있으면 실측값, 없으면 추정값(50px) for (let i = 0; i < texts.length; i++) { offsets[i] = acc; acc += (measuredHeights[i] ?? ESTIMATED_ITEM_HEIGHT) + ITEM_GAP; } // 점프 시: 측정된 누적 오프셋 사용 (미측정 범위는 추정값 기반) el.scrollTop = offsets[jumpTarget.index];
      아이템이 뷰포트에 진입하면 ResizeObserver가 실제 높이를 측정해 오프셋을 보정한다. 측정된 범위는 정확한 누적 오프셋을 사용하고, 한 번도 화면 상에 나타나지 않은 아이템은 추정값(50px)으로 채운다. 위로 충분히 스크롤하며 모든 아이템을 한 번씩 거쳤다면 이후 점프는 정확해지지만 처음 방문하는 먼 인덱스에서는 미측정 구간만큼 오차가 누적된다.
      notion image
      실제로 30번째 인덱스로 점프했지만 실제 화면 상에 보이는 스크롤 위치는 오차가 발생해 #30에 한참 못 미친다.
  1. @tanstack/react-virtual 라이브러리로 구현한 가상 스크롤
    1. notion image
      이번엔 정확한 위치에 스크롤이 이동하는 것을 확인할 수 있다. @tanstack/react-virtual 라이브러리는 이 문제를 어떻게 해결했을까?
      const virtualizer = useVirtualizer({ count: texts.length, getScrollElement: () => parentRef.current, estimateSize: () => ESTIMATED_ITEM_HEIGHT, // 고정 추정값(50px) measureElement: (element) => element.getBoundingClientRect().height, gap: ITEM_GAP, }); // 점프 시: 라이브러리의 scrollToIndex 활용 virtualizer.scrollToIndex(jumpTarget.index, { align: "start" });
      @tanstack/react-virtual은 내부적으로 아이템 별 실제 측정된 높이 값을 캐시로 저장해 관리한다. 아이템이 뷰포트에 진입하면 measureElement로 실제 높이를 측정해 내부 캐시를 갱신하고, 추정값과 다를 경우 캐시를 갱신한 뒤 영향을 받는 아이템들의 오프셋을 일괄적으로 재계산한다. 이후 스크롤 위치가 재계산된 오프셋과 어긋나 있으면 자동으로 보정한다. 이러한 캐시 기반 보정 방식을 통해 한 번이라도 뷰포트를 거친 아이템에 대해서는 정확한 위치를 보장할 수 있다.
      scrollToIndex()는 이 캐시를 참조해 이미 측정된 범위의 아이템은 실제 높이로, 미측정 아이템은 estimateSize 반환 값으로 위치를 계산해 스크롤 위치로 이동하는 함수이다. 라이브러리는 내부적으로 스크롤 위치와 실제 목표했던 위치를 비교해 오차를 계산하고, 오차가 0이 될때까지 scrollToIndex()를 반복 호출한다.
      즉, 캐시에 기반해 성능을 최적화한 라이브러리이긴 하나 아직 측정되지 않은 아이템으로 점프하는 경우 여전히 오차가 발생하고, 이 오차를 보정하는 과정에서 scroll 이벤트가 여러 차례 트리거된다. 당연히 렌더링도 여러 번 발생한다. 실제로 첨부한 gif에서도 스크롤 횟수가 3번으로 측정되는 것을 확인할 수 있다.
  1. pretext로 구현한 가상스크롤
    1. // 렌더링 전에 모든 아이템의 높이를 사전 계산 const { heights } = usePretextMeasurer(texts, itemWidth); // 누적 오프셋: 모든 아이템의 정확한 높이를 이미 알고 있음 for (let i = 0; i < heights.length; i++) { offsets[i] = acc; acc += heights[i] + ITEM_GAP; } // 점프 시: 정확한 누적 오프셋으로 scrollTop 직접 설정 el.scrollTop = offsets[jumpTarget.index];
      텍스트 요소가 렌더링되기 전에 모든 아이템의 정확한 높이가 확정되어 있기 때문에, 누적 오프셋 계산에 추정값이나 보정 단계가 따로 필요하지 않다. 점프 시 offsets[index]를 scrollTop에 직접 할당하면 아직 렌더링되지 않는 아이템에 대해서도 오차 없이 이동할 수 있다.
      notion image
      단 한 번의 스크롤만으로 정확한 위치로 스크롤이 이동하는 것을 확인할 수 있다.
이렇듯 pretext를 통해 복잡한 캐시 관리, 보정 로직 없이도 단순하고 정확하게 가상 스크롤 이동 기능을 구현할 수 있다.
실제 실무 사례로 본다면, 모든 말풍선이 동적 높이를 갖는 채팅 UI에서 “읽지 않은 첫 메시지로 이동”하는 기능을 구현하는 데 적용할 수 있을 것이다.

한계와 단점

  1. Rich Text 측정의 한계
    1. pretext는 ‘동일한 폰트 스타일을 가진 순수 텍스트(Plain Text)’를 측정하는데 특화되어 있기 때문에, 다양한 인라인 HTML 태그와 스타일이 섞여있는 텍스트의 경우 측정 로직이 기하급수적으로 복잡해진다. 때문에 에디터, 복합 스타일 텍스트에서는 적용하기 어렵다.(물론 안되는 건 아니다. 순수 텍스트에 비해 연산이 복잡할 뿐이지, 요소마다 연산을 적용하면 충분히 활용할 수 있다. 실제로 제작자도 Rich Text에 pretext를 적용한 예제를 공개하고 있다.)
  1. 웹 폰트의 로딩 시점 문제
    1. Pretext는 Canvas API를 사용해 글자 크기를 재는데, 만일 사용자 브라우저에서 커스텀 폰트가 완전히 다운로드되기 전에 pretext가 계산을 실행하면, FOUT 현상이 발생할 수 있다.
      💡
      FOUT(Flash of Unstyled Text)
      : 웹 폰트가 로드되기 전에 기본(fallback) 폰트로 텍스트가 먼저 보였다가 이후 실제 폰트로 바뀌는 현상
      때문에 document.fonts.ready 등을 활용해 폰트 로드가 완료된 시점을 보장한 후 레이아웃을 측정하는 등의 처리가 필요하다.
  1. 미세한 픽셀 오차(Canvas와 DOM)
    1. 브라우저의 렌더링 엔진(DOM)이 글자를 그리는 방식과 Canvas API가 글자를 그리는 방식 간에는 OS나 브라우저의 안티앨리어싱 처리 방식에 따라 미세한 차이가 있을 수 있다. 때문에 특정 폰트, 특정 브라우저에서는 실제 DOM 렌더링 결과와 Pretext의 계산 결과가 1~2px 정도 미세하게 어긋나는 엣지 케이스가 발생할 수 있다.

마무리

일련의 A/B 테스트를 통해 pretext가 텍스트 레이아웃 측정에 있어 확실한 성능 최적화와 DOM 접근 방식의 구조적 한계에 대한 대안을 제공해줄 수 있다는 것을 확인할 수 있었다. 대용량 데이터 시각화, 동적 가상화 환경(가상 리스트 등), 복잡한 채팅 UI와 같이 브라우저의 DOM 병목을 피하면서 텍스트 레이아웃을 정교하고 빠르게 제어해야 하는 경우 Pretext의 도입을 고려해볼 수 있겠다.

Reference