Skip to content
yceffort
PostsSeriesTagsAbout🧪 Research
KO

Tweaks

theme
accent palette
film grain
minimal mode
12 POSTS

Browser 1

  • â—† Improving number-flow · Part 2
    #web-performance#animation#browser

    Improving number-flow Performance: Moving Animations onto the Compositor Thread

    In the number-flow fork I built to support old browsers, animations in modern browsers were still recalculating styles on every frame. This post records how 0.2.0 moved additive compositing into transform and opacity keyframes, how the change was measured, and the costs that remain in the mask and in interruptions.

    2026-10-07·24 min read
  • #pwa#caching#service-worker

    Saving Marp Slides from a Next.js App for Offline Use

    From running the existing Marp viewer offline to fixing what deployments, networks, and the presenter window exposed along the way.

    2026-09-30·23 min read
  • #web-performance#javascript#browser

    I Grew Never-Executed JavaScript to 10MiB

    How much do you lose when 10MiB of functions you never call ships to the browser? I ran 855 measurements to separate the cost created by bytes from the cost created by the shape of the code. Uncalled declarations cost about 21ms per MiB and did not grow when I slowed the CPU by 4x, while initialization code that runs the moment the file is read added 201ms per MiB to the main thread. With real libraries, merely importing a module was enough to evaluate it.

    2026-09-16·32 min read
  • #browser#design-patterns#css

    Running One Web on Multiple WebViews: Folding Environment Branches into Adapters

    We supported the iOS and Android WebViews of our own app and of a partner app, and gathered the scattered environment branching into adapters. This is a record of how we organized insets, the bridge, and CSS, along with the problems we hit with the SSR seed and hydration.

    2026-09-09·Updated 2026-09-30·27 min read
  • â—† Service Worker Caching Deep Dive · Part 3
    #service-worker#web-performance#caching

    Measuring the Cost of Going Through a Service Worker: Building in the Lab the Control Group GA4 Could Not Give Me

    I set out to confirm the 500 ms hint that part 2 left behind, but the hard reloads that would form the control group arrive at under one a day. So I built the control group myself, with Playwright and a shaping proxy, and found that going through the worker costs 2 ms on a navigation, and that the cost is not latency but the bytes the worker fetches in the background on every click. The gap I had left between the lab and the field turned out, only after the post was written, to be a measurement definition difference created by 103 Early Hints. Third part of the service worker caching deep dive series.

    2026-08-28·Updated 2026-09-02·50 min read
  • #animation#web-performance#debugging

    Killing Frame Drops in a framer-motion Banner: Two Wrong Turns and One Easing Function

    A banner built with framer-motion made the entire home screen stutter for the 0.6 seconds it took to open. The record of guessing the cause from the code, having that guess overturned twice by measurement, and finally removing the reflow with a single easing function. Plus what the work left behind: the gap between declaration and execution, the principle that properties decide performance, preserving mechanisms, suspecting your instruments first, and proving sameness with a curve.

    2026-08-15·30 min read
  • â—† Service Worker Caching Deep Dive · Part 1
    #service-worker#caching#browser

    How Service Worker Caching Works: The Proxy, the Lifecycle, and Five Strategies

    A service worker is a programmable proxy standing between your site and the network. Where does it stand, why does the cache rot, why am I seeing the old version after deploying, what goes in under which strategy, and so, should you use it? Holding on to five questions you actually meet in practice, this post goes down to the details of state transitions and to a real measurement in which a 104KB opaque response was accounted as 6.6MB of storage. It is the general theory that did not fit into the cache chapter of Frontend Performance Optimization Deep Dive (published in Korean), and the first post of the Service Worker Caching Deep Dive series.

    2026-08-12·Updated 2026-09-02·24 min read
  • â—† Improving number-flow · Part 1
    #browser#animation#oss

    Porting number-flow to Old Browsers: Five Decisions and Two Reversals

    The minimum versions where number-flow turns animations on are Chrome 125 and Safari 17.2. A record of the decisions made while building a fork that lowers this floor to Chrome 66 and WebKit 16.4, the two judgment calls I ended up reversing, and the Safari bug investigation that made me give up on automatic downgrading.

    2026-08-11·Updated 2026-10-07·26 min read
  • #animation#react#browser

    React's <ViewTransition>: Browser-Native Animation, Done the React Way

    What happens when React wraps the View Transition API

    2026-03-02·16 min read
  • #memory#web-performance#design-patterns

    Preventing Memory Leaks with IntersectionObserver Singleton Pattern and WeakMap

    How to efficiently observe hundreds of elements while preventing memory leaks

    2026-01-17·13 min read
  • #browser#web-performance#ai

    WebGPU Is Finally Available in Every Browser

    In July 2025, the browser GPU API changed generations for the first time in 14 years

    2025-12-30·12 min read
  • â—† Web Service Performance Analysis · Part 4
    #web-performance#browser

    Web Service Performance Analysis (4)

    If you find yourself thinking "maybe I should try this too..." — reach out right now!!

    2025-07-19·21 min read
mailMail icongithubtwitter
yceffort
•
© 2026
•
https://yceffort.kr