GDC 2025: How Build Insights Reduced Call of Duty: Modern Warfare II’s Build Times by 50%

In game development, time is critical —every second you spend waiting on a build is time you’re not iterating, refining gameplay, or fixing critical bugs. And for C++ games, where large codebases and complex build systems are the norm, no matter the platform, every small improvement matters and compounds quickly. At four builds per hour, shaving just two minutes off each build translates to over an hour saved in a single workday. And, in Continuous Integration (CI) systems, where every Pull Request (PR) is gated on a successful test pass, these gains become even more critical. Faster builds mean more PRs approved per day, accelerating feature development and keeping the entire team moving forward—ultimately making it easier to test new ideas, react to feedback, and deliver the best possible experience for your players.

For massive projects like Call of Duty, where efficiency is key to keeping development on track, optimizing build times isn’t just a nice-to-have—it’s essential. That’s where Build Insights comes in.

Build Insights is a powerful profiling tool designed to help developers analyze and optimize their build’s performance. It provides deep visibility into compilation and linking, helping teams like Activision pinpoint inefficiencies that slow down development. Whether it’s a function call that takes too long to compile or a linker bottleneck stalling parallel builds, Build Insights helps you pinpoint slowdowns, eliminate inefficiencies, and unlock faster iteration cycles—so you spend less time waiting and more time creating.

How Build Insights Transformed Activision's Development Workflow

"Build times impact every aspect of development. When builds are slow, valuable engineering time is lost—time that could be spent improving features, optimizing performance, or debugging critical issues. Slow builds also create bottlenecks in our continuous integration pipelines, delaying the verification of every piece of code and content that goes into our games. To keep our development workflow efficient, we need our builds to be as fast as possible and Build Insights provides that capability to our teams." — Michael Vance, SVP & Fellow Software Engineer, Activision

With decades of experience in the gaming industry, Michael Vance has played a key role in shaping major titles like the Call of Duty series and the Spider-Man games. His expertise in real-time rendering and game technology has helped push the boundaries of performance and visual fidelity.

That same drive for innovation extends across Activision’s studios, including Infinity Ward, where Rulon Raymond, Senior Director of Technology, leads efforts to optimize performance and streamline development workflows.

Rulon has spent years refining game engines to deliver the high frame rates, graphical fidelity, and seamless gameplay experiences that Call of Duty players expect. His focus is on improving efficiency across the entire development pipeline—from asset creation to final rendering—ensuring that teams can iterate quickly and push the limits of what’s possible.

One of the biggest challenges Rulon and his team faced was optimizing build times, particularly with Link Time Code Generation (LTCG) and Profile Guided Optimization (PGO). While these optimizations improve runtime performance, they significantly increase build times, making them impractical for daily iteration.

To tackle this, Activision partnered with the Xbox Advanced Technology Group (ATG).

"At Xbox ATG, our goal is to empower developers to achieve more. Collaborating with Activision and the Build Insights team allowed us to drive meaningful improvements that benefit not just Call of Duty, but the entire game development community." — Andrew Farrier, Xbox ATG: Principal Software Eng. Lead for CPU/System team

Andrew Farrier is a Principal Software Engineering Lead at Xbox ATG where he manages the team that is responsible for the CPU, Systems, Engines, File I/O, and Compiler areas. Andrew led an in-depth investigation leveraging Build Insights to pinpoint inefficiencies, implement targeted optimizations, and dramatically reduce build times. Below, he breaks down the key findings and the optimizations that made the biggest impact. What follows is his deep dive into the investigation and results.

Digging into the Data

To begin our investigation into Call of Duty’s elongated build times, at Xbox ATG, we leveraged Build Insights, using vcperf and Windows Performance Analyzer to analyze performance data. We followed these key steps:

1. Capturing performance data using vcperf alongside MSBuild.
2. Analyzing the resulting profile in Windows Performance Analyzer to pinpoint inefficiencies.
3. Implementing optimizations based on the identified bottlenecks.
4. Measuring improvements by re-running vcperf and comparing build times.

Each step provided new insights, leading to game-changing optimizations.

Key Findings and Unexpected Discoveries

Throughout the investigation, several critical inefficiencies surfaced:

Two source files were the long pole for compilation time. The entire build pipeline reduced to only two cores for a significant amount of time while it waited for these files to finish building.

This timeline showed us what was happening during the last compilation phase. Each row represents a single CPU core. The green area represents 33 seconds of time, if you include the large blank block of time before that the total adds up to 55 seconds. This represents ~12% of the total build time where the build system is stalled waiting for two files. 

Force inlining was significantly increasing compilation time, primarily due to nested calls to force-inlined functions. One function had 13,700 force-inlined calls, due to a combinatoric explosion in call counts and resulted in 70 seconds of compile time.

This issue often arises in patterns where an inlined function is repeatedly called within constructs like switch statements. Consider the following example:

If foo is force-inlined, the compiler expands each call to foo and all the functions it calls, duplicating the function body for every case. As the number of cases grows, this expansion increases exponentially. Instead, restructuring the code to defer the call until after the switch can reduce force-inlined calls by 3x:

By treating force inlining similarly to macro expansion, it's easier to see how excessive inlining can quickly spiral out of control. Being mindful of where and how force inlining is applied can significantly improve compile times while maintaining performance.

We were able to utilize this view below to see the list of the force inlined functions and were able to reduce it from 70 seconds to just 1.5 seconds after refactoring.

We also discovered some Microsoft Visual C++ (MSVC) backend inefficiencies:

• Whole Program Analysis Phase Bottleneck: A deep dive into the Whole Program Analysis phase revealed that a single function’s large dynamic initializers were adding millions of unnecessary operations. This specific issue was slowing down this phase by 9x, increasing overall build time from 20 seconds to nearly 3 minutes.

• Global Symbol Table Inefficiencies: The existing hash table design used in LTCG builds was causing excessive cache misses, leading to a significant single-threaded bottleneck.

We noticed using the view below that multi-threading limitations in the linker led to inefficient core utilization, stalling builds. This timeline clearly shows what is happening. Each bar represents work being done on a single CPU core. As you can see, 60% of the time the linker is running single threaded. When it does go wide it’s not scaling past 24 threads, this is on a machine with 64 cores.

"We always knew build times were a challenge, but seeing the actual breakdown was eye-opening. Realizing that two files alone were holding up 12% of the entire build? That was a huge ‘aha’ moment. Build Insights didn’t just confirm our suspicions—it showed us exactly where to focus our efforts." — Rulon Raymond, Senior Director of Technology at Infinity Ward, Activision.

Optimizations That Made the Difference

Based on these discoveries, Xbox ATG partnered with the MSVC team and worked on addressing the bottlenecks discovered through Build Insights. We were able to help Activision drastically cut build times by 50%, from 27:49 minutes to 14:25 minutes. Here are some of the major impact areas:

• Disabling LTCG for 2 specific symbols, which were large initializer lists, reduced build times by ~9 minutes with no impact on overall title performance.
• Compiler Improvements made by the MSVC team reducing build times by ~5 minutes. This included smarter Handling of Large Functions in the Whole Program Analysis  phase and implementing a cache-efficient multi-map that optimizes lookups and reduces memory overhead. You can benefit from these optimizations by using the MSVC toolset in Visual Studio 17.6 and later.

These improvements weren’t just beneficial to Activision—they helped shape broader enhancements in MSVC’s LTCG and linker performance, impacting other major projects like Fortnite, Chrome, TensorFlow, and Forza.

Lessons Learned: Best Practices for Game Studios

Activision’s success highlights several key takeaways for other studios looking to optimize build times:

• Use Build Insights to identify bottlenecks. Windows Performance Analyzer’s timeline view is incredibly useful for narrowing down slowdowns.
• Be mindful of force inlining. Excessive inlining can significantly increase compile times, especially when applied deep in the call stack, where it can be hidden and lead to a combinatoric explosion of calls. Also, it can limit the compiler’s ability to make optimization choices, leading to worse runtime performance.
• Leverage Unity/Jumbo builds. Combining multiple source files into a single unit helped Activision shave one minute off their build time. Checkout our blogpost on Support for Unity(Jumbo) files in Visual Studio, to learn how you can take advantage of this for your builds!
• Continuously measure and refine. Optimization is an ongoing process, not a one-time fix.

Conclusion: From Activision’s Breakthrough to Visual Studio Integration

With Andrew’s help and by leveraging Build Insights, Activision was able to unlock major efficiency gains, reducing build times significantly and accelerating game development.

"Build Insights gave us the deep visibility needed to diagnose and resolve our most pressing performance issues, transforming how we approach build optimization. With Build Insights, we uncovered inefficiencies that were slowing us down and implemented changes that made a massive difference." — Rulon Raymond, Senior Director of Technology at Infinity Ward, Activision.

This impact reached far beyond Call of Duty. Activision’s success underscored a critical need: game developers everywhere struggle with long build times, and they need better visibility to optimize performance. Seeing the difference Build Insights made, we knew we had to go further.

This realization was the turning point that drove us to integrate Build Insights into Visual Studio, making powerful build profiling tools more accessible than ever. Now, you don’t need to set up complex diagnostics—you can simply build your project from within Visual Studio and we’ll take care of running build insights for you!

With this integration, you can instantly identify bottlenecks, from expensive code generation to inefficient header inclusions, and take actions such as navigating to problem files and addressing issues, without leaving your development environment. No need for external profiling tools—everything is built directly into Visual Studio, streamlining your workflow and making it easier than ever to optimize build performance.

Whether you're shipping the next blockbuster game or optimizing complex enterprise software, you can now harness the same tools that helped Activision push the limits of what’s possible.

Get started with the C++ Build Insights experience in Visual Studio today and take your build performance to the next level. For more tips and best practices, check out our YouTube Video, explore our blog post, or dive into our documentation to start optimizing your builds today.