Optimizing Pull Request Performance at GitHub: A Q&A on the Files Changed Tab

GitHub's pull request review experience is critical for developers, but large diffs posed performance challenges—excessive memory usage, high DOM node counts, and sluggish interaction. Our team recently shipped a React-based overhaul of the Files changed tab, focusing on speed and responsiveness for all PR sizes. We didn't rely on a single fix; instead, we adopted a layered strategy: optimizing diff-line components for everyday PRs, using virtualization for extreme cases, and improving foundational rendering. This Q&A covers the problems we faced, our metrics, the solutions we implemented, and the results.

What performance issues did large pull requests cause?

When viewing pull requests with thousands of files or millions of lines, the browser struggled. In extreme cases, the JavaScript heap exceeded 1 GB, DOM nodes surpassed 400,000, and page interactions became extremely sluggish or even unusable. Our Interaction to Next Paint (INP) scores—a key responsiveness metric—fell below acceptable levels, meaning users experienced noticeable input lag. These problems primarily affected large PRs; smaller diffs remained fast. The core challenge was to maintain a seamless experience across all scales without sacrificing features like native find-in-page or smooth scrolling.

Why wasn't there a single silver bullet solution?

We quickly realized that no single technique could address all PR sizes. Optimizations that preserve every feature and browser-native behavior hit a ceiling for the largest diffs. Conversely, aggressive mitigations designed to prevent worst-case scenarios often degraded the experience for everyday reviews. For example, full virtualization could break browser search or cause layout jumps. Instead of chasing a one-size-fits-all fix, we developed multiple targeted approaches, each tailored to a specific pull request size and complexity. This layered strategy let us keep the common case fast while gracefully handling the extremes.

How did you optimize diff-line components?

Our first strategy focused on making the primary diff experience efficient for most pull requests. We audited the React components rendering each line, eliminating unnecessary re-renders, and reducing the overhead of syntax highlighting. By memoizing expensive calculations and using virtualized rows for large changes that didn't need native find-in-page, we cut the render time significantly. These optimizations kept medium and large reviews fast without sacrificing expected behavior like native find-in-page. The result was a smoother scrolling and selection experience, even when PRs contained hundreds of changed files.

How does graceful degradation with virtualization help?

For the very largest pull requests—those with tens of thousands of lines—we introduced a virtualization layer. This approach limits the number of diff lines rendered at any moment, prioritizing responsiveness and stability. When a PR exceeds a threshold, we display only the visible portion plus a small buffer, and load more as the user scrolls. This reduces DOM node counts from hundreds of thousands to a few thousand, slashing memory consumption and INP scores. However, we carefully designed this mode to degrade gracefully: features like direct link to specific lines still work, and users are informed that search applies only to loaded content. This trade-off ensures the experience never becomes unusable, even for massive diffs.

What foundational component and rendering improvements were made?

Beyond the size-specific strategies, we invested in improvements that benefit every pull request, regardless of size. We refactored core components to use React 18's concurrent features, batched state updates, and optimized event listeners. We also shifted from imperative DOM manipulation to declarative React patterns, reducing layout thrash. These changes compounded across all PR sizes—small diffs loaded faster, and large diffs had a lower baseline memory footprint. One key improvement was replacing the monolithic diff view with a composable architecture, allowing only changed sections to re-render when toggling comments or side-by-side views.

What were the measurable performance results?

After deploying the new Files changed tab, we saw dramatic improvements. For large pull requests (10,000+ lines), JavaScript heap size dropped by over 60%, and DOM node counts fell by 90%. INP scores improved from over 500ms to well under 100ms—a five-fold reduction in perceived lag. Even for medium PRs, time to interactive improved by 30%. These gains came without losing any core review functionality. The combination of optimized diff lines, virtualized rendering, and foundational upgrades created a system that scales smoothly from a one-line fix to a million-line merge.

What's next for pull request performance?

We're continuing to monitor real-user metrics and identify edge cases. Future work includes smarter lazy-loading for large file trees, further reducing memory pressure via off-main-thread syntax highlighting, and exploring Web Worker delegation for parsing tasks. We also aim to refine the virtualization threshold based on device capabilities, so users on lower-end hardware get an adaptive experience. Our goal is to make the PR review experience consistently fast, no matter the repository size or reviewer's machine. Stay tuned for more updates on the GitHub Changelog and engineering blog.