GitHub published a September 23, 2026 engineering deep dive describing how the GitHub Copilot app handled an extreme pull request with about 2,200 files, more than one million changed lines and over 400 inline review comments. The durable lesson is not a GitHub-specific implementation recipe: large review surfaces need bounded DOM work, a clear geometry contract, lazy correction for variable-height content, data streaming that does not block first useful paint, and objective health signals that reproduce jank under load. GitHub describes keeping code rows virtualized while treating comments as variable-height blocks, deferring expensive work until it is needed, caching a limited number of recently viewed diffs, and using structured instrumentation plus unattended flows to find regressions. Apply those principles as a diagnosis framework, then validate them against your own framework, browser engines, accessibility requirements and workload rather than assuming GitHub's internal thresholds are universal.
A large code-review or diff page freezes, drops frames or consumes excessive memory
Virtualized code rows scroll smoothly until threaded comments, images or reply composers appear
Expanding a details block or loading an image makes content jump or leaves blank space around comments
Returning to a recently viewed large diff redraws the shell quickly but leaves the main document empty for seconds
Performance bugs reproduce only at deep scroll positions, on one browser engine or after a specific sequence of interactions
Possible causes
A virtualizer assumes row heights are known before paint while comments and other rich blocks can change height after rendering
Resize measurement writes back into layout too frequently and creates reflow or observer feedback loops
Data loading, syntax highlighting or comment hydration blocks the visible surface instead of streaming or deferring work
Caches retain too much or too little: keeping every huge document wastes memory, while discarding all recent work makes navigation feel broken
Teams rely on ad hoc logs and visual inspection instead of repeatable health signals tied to real scroll and render behavior
HOW TO FIX IT
Work from the safest step to the harder repair.
Step 1. Define the workload before optimizing. Capture representative small, medium and worst-case diffs, including variable-height review threads, images, expandable sections and inline editors. Record file count, changed-line count, comment count, viewport size and browser engine so later measurements are comparable.
Step 2. Keep the mounted DOM bounded. Virtualize large code-row collections so work scales primarily with the viewport rather than the total diff size. Do not infer that the exact row count or overscan used by another product is appropriate for your component tree or accessibility model.
Step 3. Write down the geometry contract. Fixed-height code rows can use deterministic offsets; rich comments cannot. Treat variable-height blocks as a separate class whose estimates can be corrected after render rather than forcing all content into one fixed-height assumption.
Step 4. Batch reads before writes. When measuring mounted variable-height blocks, collect layout reads together and apply corrections in a controlled phase. Avoid a ResizeObserver callback that immediately writes layout on every event, because that can create repeated reflow or feedback loops.
Step 5. Gate expensive measurement around active scrolling. GitHub describes avoiding normal correction work while a scroll is in flight and rechecking once the visible range settles. Use your own frame-time and interaction data to choose the appropriate idle or post-scroll strategy.
Step 6. Measure only the relevant neighborhood. Prioritize mounted and near-viewport blocks; allow distant content to keep an estimate until it approaches. This keeps correction work tied to what the user can reach soon rather than the total document length.
Step 7. Handle user-caused visible resizes deliberately. Expanding details, opening a reply composer or loading an image can require a same-frame anchored correction so the visible content does not visibly move in two stages. Limit synchronous commits and suppress them during active scrolling if measurements show they create jank.
Step 8. Stream structure before expensive decoration. Render file metadata and navigable structure as soon as reliable data is available, then defer syntax highlighting, large markdown bodies and other per-item work that does not need to block first useful interaction.
Step 9. Move CPU-heavy decoration off the main thread when the platform allows it, but measure serialization and worker overhead too. A worker is not automatically faster for small documents; keep the optimization conditional on real workload evidence.
Step 10. Use a bounded cache for recently viewed heavy documents when navigation tests show that immediate revisit is common. Define memory limits and eviction behavior explicitly; do not retain every large diff for an entire session merely to avoid refetching.
Step 11. Instrument the product with durable signals: render counts, long tasks or frame timing, visible gaps, blank blocks, scroll-anchor errors, memory growth and data-pipeline timing. Prefer structured metrics that can be asserted over temporary console logging.
Step 12. Automate the reproduction path. Drive cold and warm loads, deep scrolling, comment expansion, editor opening, sidebar toggles and viewport resizing on a representative engine, then fail the test when detector-grade health signals cross the accepted threshold.
Step 13. After each optimization, re-run correctness, accessibility and interaction tests as well as performance tests. Virtualization must not break keyboard navigation, screen-reader reading order, focus restoration, find-in-page expectations or stable deep links.
Step 14. Document product-specific thresholds separately from general principles. GitHub's published extreme test case and internal measurement distances are useful evidence of one implementation, not standards that should be copied unchanged into another application.
Need the actual code? Go to GenesisCodeDoctor.com to search the Code Store or request code for the exact platform, error, and repair you are working on.
Profile with non-sensitive repositories or scrubbed fixtures when traces or logs could capture source code or review comments.
Keep performance instrumentation free of secrets, access tokens and unnecessary user content; record structural and timing signals whenever possible.
Preserve a rollback path for virtualization, caching or measurement changes because a frame-time improvement can still introduce correctness or accessibility regressions.
STOP AND GET HELP WHEN
Do not turn a repair into a larger outage.
Do not copy GitHub's internal numeric thresholds, cache size or measurement distances as universal performance requirements.
Do not remove comments, accessibility semantics, keyboard behavior or review functionality merely to make a benchmark look faster.
Do not let ResizeObserver-driven writes create an uncontrolled measurement-layout-measurement feedback loop.
Do not optimize only a synthetic code-only diff when the production failure appears after variable-height comments, images or editors render.
Do not claim a large surface is fixed from one screenshot or one smooth manual scroll; require repeatable metrics across representative browsers and interaction paths.
HOW GENESIS HANDLES IT
Diagnose the exact failure before choosing a repair.
Genesis separates the visible symptom from the underlying technical cause. Run the supported diagnostic first, review the evidence, and then use a matching repair only when the failure is actually verified.
Does a million-line diff require a million DOM nodes?
No. GitHub's engineering post describes a virtualized review surface that keeps only a bounded visible set of code rows mounted. The exact implementation should be chosen for your framework and accessibility needs.
Why are review comments harder to virtualize than code lines?
Code rows can often have predictable height, while comments can change height because of wrapping, replies, expandable sections, images and other dynamic content. That makes post-render measurement and anchored correction necessary.
Should ResizeObserver update layout immediately on every callback?
Not by default. GitHub describes avoiding that feedback loop and using controlled measurement passes, with a narrow same-frame exception for visible user-caused resizes. Measure your own implementation before choosing the same policy.
Is virtualization enough to fix a slow review page?
No. Data streaming, syntax highlighting, markdown work, caching, measurement strategy and instrumentation can all become bottlenecks even when the DOM is virtualized.
What should a regression test measure?
Use detector-grade signals such as frame timing, blank or unfilled regions, correct mounted thread content, scroll stability, render counts and memory behavior across cold, warm and deep-scroll flows.
Once you know the platform and the verified problem, search the Genesis Code Doctor Code Store for a matching package. If the exact integration or repair is not there, use Request a Code and describe the platform, official documentation, desired behavior, and sanitized error—never send your secret key.
Start with a free diagnostic. If Genesis verifies a problem and a compatible treatment exists, continue to the matching Code Store product or repair path. If you cannot find the exact code you need, request it at GenesisCodeDoctor.com rather than forcing a generic snippet into the wrong platform.
