Features

Performance
  • Efficient parallel compilation
  • Local and network cache support
  • Lightning fast "nothing to build"
  • Unity/Blob builds
  • (soon) Distributed compilation
Platforms
  • Build multiple platforms at once
  • Build multiple targets at once
  • Support PC, current gen consoles and more
Lightweight
  • Tiny, self-contained executable
  • Small run-time memory usage
  • No external dependencies
  • No installation required
Easy to use
  • Modern configuration syntax
  • Human readable errors
  • Visual studio compatible
More...
  • Unit Test support
  • Build statistics
  • Progress bar
  • (soon) Visual Studio project generation

Performance

Efficient parallel compilation

FASTBuild was designed from the ground up to support parallel compilation. The highly optimized main build pipeline is designed to be as thin as possible, dispatching build tasks to worker threads to maximize parallelism.

FASTBuild has no artificial dependency bottlenecks like those present when compiling with Visual Studio/MSBuild. Unlike Visual Studio, FASTBuild is able to precisely manage the number of CPU cores used during a build avoiding excessive idle spots or excessive context switching due to too spawning too many threads.

FASTBuild is a native Windows application, with all functionality built-in, avoiding the process-invocation overhead present in systems like make.

Processing and management of the build graph occurs in highly optimized C++ code, avoiding performance issues present in systems like Scons.

Built-in cache support

Build caching is supported as a built-in feature. A single line in the configuration file enables sharing of build results via a local or network cache.

Lightning fast "nothing to build"

FASTBuild knows the entire dependency graph before the build starts and can perform the absolute minimum IO required to determine which files need building. The build state is saved between invocations to minimize work required for incremental and "nothing" builds. The build configuration file is only parsed when it changes.

Unity/Blob
FASTBuild supports automatically generated Unity/Blob builds. By including many cpp files into single a single Unity (or Blob) file, compilation and link times can be greatly reduced. Unity/Blobbing in FASTBuild is compatible with network distribution and caching.
Distributed Compilation

FASTBuild will soon be able to perform distributed compilation. This feature isn't ready for prime-time yet, but performance improvements so far are promising:

Lightweight

Tiny, self-contained executable
FASTBuild is a single executable, weighing in at around 300KB.
Small run-time memory usage
FASTBuild uses very little memory, apart from some per-cpu work buffers. A typical 8 core machine has a footprint of under 100MB. More free memory means better IO caching by Windows.
No external dependencies
FASTBuild requires no external DLLs, libraries, 3rd party software or executables (other than those belonging to your compiler(s)). It runs on a clean install of Windows (XP, 7 or server class equivalents).
No installation required
The single executable for FASTBuild does not need installation. It can simply be copied to a machine and run, or checked into revision control and versioned alongside your build (ideal for automated build systems).

Platforms

Build multiple platforms at once
FASTBuild can target mutiple (and any combination of) defined tagets (or even all of them) simultaneously. This is ideal for building mutiple platforms when verifying compilation before check-in, or as part of an automated build system. This is especially useful if some of your targets have large linking bottlenecks, such as those introduced by Link-Time Code Generation.
Build multiple targets at once
As with buiding multiple platforms simultaneously, FASTBuild can build multiple versions of the same platform simulatenously. For example you can build the "debug", "release" and "retail" configurations in parallel. Again, this is ideal for maximizing performance on automated build servers or during pre-submit "sanity-check" compiles.
Support PC, current gen consoles and more
FASTBuild is designed to work with current generation console and Windows compilers (specifically MSVC, GCC, SNC). It can also be made to work with any other command line compilers, preparing it for more platforms in the future.

Easy to Use

Modern configuration syntax
FASTBuild has a uses a bespoke configuration language, designed to simplify the configuration of code compilation. Configuration files are orders of magnitude smaller than Visual Studio project files or makefiles and are human readable.
Human readable errors
When FASTBuild fails to parse a configuration file, a human-readable error is emitted pinpointing the exact location of the error (in Visual Studio compatible) file(line:row) format.
Visual studio compatible
FASTBuild output, whether it be build progress or config parsing errors, is output in Visual Studio compatible format. If you want to route FASTBuild output through Visual Studio, you will have the same error integration as if you were compiling using Visual Studio itself.

More...

Unit Test support
FASTBuild contains built in support for Unit Tests. Unit tests are automatically compiled and executed only when relevant source is modified.
Build statistics
FASTBuild gathers build statistics during the build and can report them upon completion. This information can be used to further improve compile times by targetting large compilation units or libraries.
Progress Bar
FASTBuild tracks build times across build and can use this information to estimate progress through the current build.
Visual Studio project generation
FASTBuild will soon support generation of Visual Studio projects from the FASTBuild build configuration files.