This page has detailed information on building Chromium on Windows, including tips for troubleshooting and for speeding up the build.

Build environment

Setting up the environment for Visual Studio 2010

1. Prerequisite software:
• Windows 7 or later.
• A 64 bit OS is highly recommended as building on 32 bit OS is constantly becoming harder, is a lot slower and is not actively maintained.
• At least 60 GB of free space in an NTFS volume. Tip: having the chromium source in a SSD drive greatly speeds build times.
• Visual Studio 2010 Professional or Standard.
• Windows 8 SDK.
• June 2010 DirectX SDK.
• (Optional) Cygwin
  
  
2. Install Visual Studio 2010
1. Make sure "X64 Compilers and Tools" are installed.
2. Install VS2010 SP1.
   
   
3. Install the Windows 8 SDK.
   
   Note: If you install the SDK in a path different than C:\Program Files (x86)\Windows Kits\8.0 you need to set the following following environment variable:
   
   GYP_DEFINES=windows_sdk_path="path to sdk"
   
   
4. Install the June 2010 DirectX SDK
   Note: If your install fails with the "Error Code: S1023" you may need to uninstall "Microsoft Visual C++ 2010 x64 Redistributable". See this tip from stackoverflow: http://stackoverflow.com/questions/4102259/directx-sdk-june-2010-installation-problems-error-code-s1023
   
   
5. Patch the Windows 8 SDK to build with Visual C++ 2010
   
   
1. Parts of Chromium build using the winrt headers included with the Windows 8 SDK. All the headers we use, including the WRL, can be compiled with Visual C++ 2010 with the exception of one file, asyncinfo.h. This file uses a strongly typed enum which the VS2010 compiler doesn't understand. To workaround this for the time being, a small patch needs to be applied to the Windows 8 SDK to build with the winrt headers in VS2010:
   
   

   Patch for Include\winrt\asyncinfo.h

   Index: asyncinfo.h

   ===================================================================

   --- asyncinfo.h

   +++ asyncinfo.h

   @@ -63,7 +63,7 @@

    #pragma once

    #ifdef __cplusplus

    namespace ABI { namespace Windows { namespace Foundation {

   -enum class AsyncStatus {

   +enum /*class*/ AsyncStatus {

      Started = 0,

      Completed, 

      Canceled, 
   
   
   This patch should be applied to the file "Include\winrt\asyncinfo.h" located in your Windows 8 SDK directory. If this patch is not applied, the parts of Chromium that use the Winrt headers will not compile.
   
   
   Note: By default the Windows 8 SDK will install to C:\Program Files (x86)\Windows Kits\8.0\. This directory will require admin privileges to write to. Easiest way to do apply this patch is to start an administrative command prompt, cd to C:\Program Files (x86)\Windows Kits\8.0\Include\winrt\, run notepad.exe asyncinfo.h and comment out or delete the word "class" on line 66.
   
   
   Note: For Googlers, this patch has already been applied to your SDK, everything should Just Work.
   
   
6. (Optional) Install cygwin.

Building Chromium

1. Get the Chromium depot_tools.
2. Check out the source code using a direct svn or git checkout. Do not use a tarball since it is not compatible with Windows' svn client.
3. Set up the component build (or else creating chrome_dll.pdb may fail laterl) and then regenerate the build files by running "gclient runhooks --force" in a cygwin/cmd window.
4. Install API keys.
5. Open the chrome/chrome.sln solution file in Visual Studio and build the solution. This can take from 10 minutes to 2 hours. More likely 1 hour.
6. If you just want the Chromium browser, and none of the tests, you can speed up your build by right-clicking the chrome project in the solution explorer and selecting Build. You may want to make sure this project is the Startup project (which will display as bold) by right-clicking it and selecting Set as Startup Project. This will make Chromium (as opposed to some random test) build and run when you press F5.

Accelerating the build

Be prepared: the build of whole solution can take hour(s) longer if not configured correctly.

In decreasing order of speedup:

• Use a true multicore processor, i.e. an Intel Core Duo or later (not a Pentium 4 HT).
• Use an x64 OS (otherwise incremental linking is disabled).
• Have at least 8 GB RAM.  If you have less than 4 GB, you may find builds to be prohibitively slow.
• Turn on precompiled headers and the component build.
• Use src/build/some.gyp to only load the targets you care about.
• Disable your anti-virus software for .ilk, .pdb, .cc, .h files and only check for viruses on modify. Disable scanning the directory where your sources reside.
• Store and build the Chromium code on a second hard drive that does not have swap (Control Panel->System and Security->System->Advanced->Performance/Settings->Advanced->Virtual memory/Change). Compilation and linking use a lot of memory and disk I/O.  It's not a good idea to have the I/O happening on the same disk that the memory manager is using for swap.
• Consider using ninja -- it's an alternative command-line build tool that's much faster than Visual Studio, especially for incremental builds.
• Reduce the number of parallel builds: avoid memory swap at any cost!. Chromium requires a lot of memory to link; if you build too many sub-projects simultaneously your PC will slow to a crawl during the linking phase because of the linkers fighting for memory. Go into MSVC's Tools\Options\Projects and Solutions\Build and Run and reduce "maximum number of parallel project builds". By default it is equal to the number of virtual processors (e.g. 8 for a quad core HT CPU). Recommended number for 12 GB of RAM is lower than 8 (see discussions here).  Use an even smaller number if you have less RAM.
• You may also want to tune your include.gypi file to limit the number of cl.exe processes spawned and reduce context switches (see discussions here).  For example, to limit to only 5 cl.exe and 5 linkers, the include.gypi under your home folder's .gyp should have
  
  {
    'variables': {
      'msvs_multi_core_compile': 0,
    },
    'target_defaults': {
      'msvs_settings': {
        'VCCLCompilerTool': {
          'AdditionalOptions': ['/MP5'],
        },
      },
    },
  }
  
  
• Defragment your hard drive regularly.
• You may want to try incremental linking if you're adventurous or using ninja. It makes linking very fast when you're working incrementally, but is somewhat flaky in Visual Studio, and you may need to do cleans after syncs to avoid spurious errors.

Optional