A User's Guide to Bazel
To run Bazel, go to
your base workspace directory
or any of its subdirectories and type
% bazel help [Bazel release bazel-<version>] Usage: bazel <command> <options> ... Available commands: analyze-profile Analyzes build profile data. aquery Executes a query on the post-analysis action graph. build Builds the specified targets. canonicalize-flags Canonicalize Bazel flags. clean Removes output files and optionally stops the server. cquery Executes a post-analysis dependency graph query. dump Dumps the internal state of the Bazel server process. help Prints help for commands, or the index. info Displays runtime info about the bazel server. fetch Fetches all external dependencies of a target. mobile-install Installs apps on mobile devices. query Executes a dependency graph query. run Runs the specified target. shutdown Stops the Bazel server. test Builds and runs the specified test targets. version Prints version information for Bazel. Getting more help: bazel help <command> Prints help and options for <command>. bazel help startup_options Options for the JVM hosting Bazel. bazel help target-syntax Explains the syntax for specifying targets. bazel help info-keys Displays a list of keys used by the info command.
bazel tool performs many functions, called
commands. The most commonly used ones are
bazel test. You can browse the online help
Building programs with Bazel
bazel build followed by the name of the
target you wish to build. Here's a typical
% bazel build //foo ____Loading package: foo ____Loading package: bar ____Loading package: baz ____Loading complete. Analyzing... ____Building 1 target... ____[0 / 3] Executing Genrule //bar:helper_rule ____[1 / 3] Executing Genrule //baz:another_helper_rule ____[2 / 3] Building foo/foo.bin Target //foo:foo up-to-date: bazel-bin/foo/foo.bin bazel-bin/foo/foo ____Elapsed time: 9.905s
Bazel prints the progress messages as it loads all the packages in the transitive closure of dependencies of the requested target, then analyzes them for correctness and to create the build actions, finally executing the compilers and other tools of the build.
Bazel prints progress messages during the execution phase of the build, showing the current build step (compiler, linker, etc.) that is being started, and the number completed over the total number of build actions. As the build starts the number of total actions will often increase as Bazel discovers the entire action graph, but the number will usually stabilize within a few seconds.
At the end of the build Bazel
prints which targets were requested, whether or not they were
successfully built, and if so, where the output files can be found.
Scripts that run builds can reliably parse this output; see
--show_result for more
Typing the same command again:
% bazel build //foo ____Loading... ____Found 1 target... ____Building complete. Target //foo:foo up-to-date: bazel-bin/foo/foo.bin bazel-bin/foo/foo ____Elapsed time: 0.280s
we see a "null" build: in this case, there are no packages to re-load, since nothing has changed, and no build steps to execute. (If something had changed in "foo" or some of its dependencies, resulting in the reexecution of some build actions, we would call it an "incremental" build, not a "null" build.)
Before you can start a build, you will need a Bazel workspace. This is simply a directory tree that contains all the source files needed to build your application. Bazel allows you to perform a build from a completely read-only volume.
Specifying targets to build
Bazel allows a number of ways to specify the targets to be built.
Collectively, these are known as target patterns. This syntax is
used in commands like
Whereas labels are used to specify individual targets, e.g. for declaring dependencies in BUILD files, Bazel's target patterns are a syntax for specifying multiple targets: they are a generalization of the label syntax for sets of targets, using wildcards. In the simplest case, any valid label is also a valid target pattern, identifying a set of exactly one target.
All target patterns starting with
// are resolved relative to the current
||Just the single target
||All rules in the package
||All rules in all packages beneath the directory
||All rules in all packages beneath the directory
||All targets (rules and files) in all packages beneath the directory
||All targets (rules and files) in all packages beneath the directory
Target patterns which do not begin with
// are resolved relative to the
current working directory. These examples assume a working directory of
By default, directory symlinks are followed for recursive target patterns, except those that point to under the output base, such as the convenience symlinks that are created in the root directory of the workspace.
In addition, Bazel does not follow symlinks when evaluating recursive target patterns in any directory that contains a file named as follows:
foo/... is a wildcard over packages,
indicating all packages recursively beneath
foo (for all roots of the package
:all is a wildcard
over targets, matching all rules within a package. These two may be
combined, as in
foo/...:all, and when both wildcards
are used, this may be abbreviated to
:all-targets) is a
wildcard that matches every target in the matched packages,
including files that aren't normally built by any rule, such
_deploy.jar files associated
This implies that
:* denotes a superset
:all; while potentially confusing, this syntax does
allow the familiar
:all wildcard to be used for
typical builds, where building targets like the
is not desired.
In addition, Bazel allows a slash to be used instead of the colon
required by the label syntax; this is often convenient when using
Bash filename expansion. For example,
//foo/bar:wiz (if there is a
foo/bar) or to
there is a package
Many Bazel commands accept a list of target patterns as arguments,
and they all honor the prefix negation operator
This can be used to subtract a set of targets from the set specified
by the preceding arguments. Note that this means order matters.
bazel build foo/... bar/...
means "build all
foo and all targets
bazel build -- foo/... -foo/bar/...
means "build all targets beneath
-- argument is required to prevent the subsequent
arguments starting with
- from being interpreted as
It's important to point out though that subtracting targets this way will not
guarantee that they are not built, since they may be dependencies of targets
that weren't subtracted. For example, if there were a target
//foo:all-apis that among others depended on
//foo/bar:api, then the latter would be built as part of
building the former.
tags = ["manual"] will not be included in wildcard target patterns (
You should specify such test targets with explicit target patterns on the command
line if you want Bazel to build/test them.
Fetching external dependencies
By default, Bazel will download and symlink external dependencies during the
build. However, this can be undesirable, either because you'd like to know
when new external dependendencies are added or because you'd like to
"prefetch" dependencies (say, before a flight where you'll be offline). If you
would like to prevent new dependencies from being added during builds, you
can specify the
--fetch=false flag. Note that this flag only
applies to repository rules that do not point to a directory in the local
file system. Changes, for example, to
new_local_repository and Android SDK and NDK repository rules
will always take effect regardless of the value
If you disallow fetching during builds and Bazel finds new external dependencies, your build will fail.
You can manually fetch dependencies by running
bazel fetch. If
you disallow during-build fetching, you'll need to run
- Before you build for the first time.
- After you add a new external dependency.
fetch takes a list of targets to fetch dependencies for. For
example, this would fetch dependencies needed to build
$ bazel fetch //foo:bar //bar:baz
To fetch all external dependencies for a workspace, run:
$ bazel fetch //...
You do not need to run bazel fetch at all if you have all of the tools you are
using (from library jars to the JDK itself) under your workspace root.
However, if you're using anything outside of the workspace directory then Bazel
will automatically run
bazel fetch before running
The repository cache
Bazel tries to avoid fetching the same file several times, even if the same
file is needed in different workspaces, or if the definition of an external
repository changed but it still needs the same file to download. To do so,
bazel caches all files downloaded in the repository cache which, by default,
is located at
location can be changed by the
--repository_cache option. The
cache is shared between all workspaces and installed versions of bazel.
An entry is taken from the cache if
Bazel knows for sure that it has a copy of the correct file, that is, if the
download request has a SHA256 sum of the file specified and a file with that
hash is in the cache. So specifying a hash for each external file is
not only a good idea from a security perspective; it also helps avoiding
Upon each cache hit, the modification time of the file in the cache is updated. In this way, the last use of a file in the cache directory can easily be determined, for example to manually clean up the cache. The cache is never cleaned up automatically, as it might contain a copy of a file that is no longer available upstream.
Distribution files directories
Besides the repository cache, Bazel has a second mechanism to avoid
unnecessary downloads. Using the
--distdir option, you can
specify additional read-only directories to look for files instead of fetching
them. A file is taken from such a directory if the file name is equal to
the base name of the URL and additionally the hash of the file is equal to the
one specified in the download request (again, no file is taken from a distdir,
if no hash is specified). While the condition on the file name is not
necessary for correctness, it reduces the number of candidate files to one per
specified directory. In this way, specifying distribution files directories
remains efficient, even if the number of files in such a directory grows
Build configurations and cross-compilation
All the inputs that specify the behavior and result of a given build can be divided into two distinct categories. The first kind is the intrinsic information stored in the BUILD files of your project: the build rule, the values of its attributes, and the complete set of its transitive dependencies. The second kind is the external or environmental data, supplied by the user or by the build tool: the choice of target architecture, compilation and linking options, and other toolchain configuration options. We refer to a complete set of environmental data as a configuration.
In any given build, there may be more than one configuration.
Consider a cross-compile, in which you build
//foo:bin executable for a 64-bit architecture,
but your workstation is a 32-bit machine. Clearly, the build
will require building
//foo:bin using a toolchain
capable of creating 64-bit executables, but the build system must
also build various tools used during the build itself—for example
tools that are built from source, then subsequently used in, say, a
genrule—and these must be built to run on your workstation.
Thus we can identify two configurations: the host
configuration, which is used for building tools that run during
the build, and the target configuration (or request
configuration, but we say "target configuration" more often even
though that word already has many meanings), which is
used for building the binary you ultimately requested.
Typically, there are many libraries that are prerequisites of both
the requested build target (
//foo:bin) and one or more of
the host tools, for example some base libraries. Such libraries must be built
twice, once for the host configuration, and once for the target
Bazel takes care of ensuring that both variants are built, and that the derived files are kept separate to avoid interference; usually such targets can be built concurrently, since they are independent of each other. If you see progress messages indicating that a given target is being built twice, this is most likely the explanation.
Bazel uses one of two ways to select the host configuration, based
--distinct_host_configuration option. This
boolean option is somewhat subtle, and the setting may improve (or
worsen) the speed of your builds.
When this option is false, the host and request configurations are identical: all tools required during the build will be built in exactly the same way as target programs. This setting means that no libraries need to be built twice during a single build, so it keeps builds short. However, it does mean that any change to your request configuration also affects your host configuration, causing all the tools to be rebuilt, and then anything that depends on the tool output to be rebuilt too. Thus, for example, simply changing a linker option between builds might cause all tools to be re-linked, and then all actions using them reexecuted, and so on, resulting in a very large rebuild. Also, please note: if your host architecture is not capable of running your target binaries, your build will not work.
If you frequently make changes to your request configuration, such
as alternating between
-c opt and
builds, or between simple- and cross-compilation, we do not
recommend this option, as you will typically rebuild the majority of
your codebase each time you switch.
If this option is true, then instead of using the same configuration for the host and request, a completely distinct host configuration is used. The host configuration is derived from the target configuration as follows:
- Use the same version of Crosstool
--crosstool_top) as specified in the request configuration, unless
Use the value of
- Use the same values of these options as specified in the request
--host_crosstool_topis used, then the value of
--host_cpuis used to look up a
default_toolchainin the Crosstool (ignoring
--compiler) for the host configuration.
Use the value of
Use the value of
- Use optimized builds for C++ code (
- Generate no debugging information (
- Strip debug information from executables and shared libraries
- Place all derived files in a special location, distinct from that used by any possible request configuration.
- Suppress stamping of binaries with build data
- All other values remain at their defaults.
There are many reasons why it might be preferable to select a distinct host configuration from the request configuration. Some are too esoteric to mention here, but two of them are worth pointing out.
Firstly, by using stripped, optimized binaries, you reduce the time spent linking and executing the tools, the disk space occupied by the tools, and the network I/O time in distributed builds.
Secondly, by decoupling the host and request configurations in all builds, you avoid very expensive rebuilds that would result from minor changes to the request configuration (such as changing a linker options does), as described earlier.
That said, for certain builds, this option may be a hindrance. In particular, builds in which changes of configuration are infrequent (especially certain Java builds), and builds where the amount of code that must be built in both host and target configurations is large, may not benefit.
Correct incremental rebuilds
One of the primary goals of the Bazel project is to ensure correct incremental rebuilds. Previous build tools, especially those based on Make, make several unsound assumptions in their implementation of incremental builds.
Firstly, that timestamps of files increase monotonically. While this is the typical case, it is very easy to fall afoul of this assumption; syncing to an earlier revision of a file causes that file's modification time to decrease; Make-based systems will not rebuild.
More generally, while Make detects changes to files, it does
not detect changes to commands. If you alter the options passed to
the compiler in a given build step, Make will not re-run the
compiler, and it is necessary to manually discard the invalid
outputs of the previous build using
Also, Make is not robust against the unsuccessful termination of one of its subprocesses after that subprocess has started writing to its output file. While the current execution of Make will fail, the subsequent invocation of Make will blindly assume that the truncated output file is valid (because it is newer than its inputs), and it will not be rebuilt. Similarly, if the Make process is killed, a similar situation can occur.
Bazel avoids these assumptions, and others. Bazel maintains a database of all work previously done, and will only omit a build step if it finds that the set of input files (and their timestamps) to that build step, and the compilation command for that build step, exactly match one in the database, and, that the set of output files (and their timestamps) for the database entry exactly match the timestamps of the files on disk. Any change to the input files or output files, or to the command itself, will cause re-execution of the build step.
The benefit to users of correct incremental builds is: less time
wasted due to confusion. (Also, less time spent waiting for
rebuilds caused by use of
make clean, whether necessary
Build consistency and incremental builds
Formally, we define the state of a build as consistent when all the expected output files exist, and their contents are correct, as specified by the steps or rules required to create them. When you edit a source file, the state of the build is said to be inconsistent, and remains inconsistent until you next run the build tool to successful completion. We describe this situation as unstable inconsistency, because it is only temporary, and consistency is restored by running the build tool.
There is another kind of inconsistency that is pernicious: stable
inconsistency. If the build reaches a stable inconsistent
state, then repeated successful invocation of the build tool does
not restore consistency: the build has gotten "stuck", and the
outputs remain incorrect. Stable inconsistent states are the main
reason why users of Make (and other build tools) type
clean. Discovering that the build tool has failed in this
manner (and then recovering from it) can be time consuming and very
Conceptually, the simplest way to achieve a consistent build is to throw away all the previous build outputs and start again: make every build a clean build. This approach is obviously too time-consuming to be practical (except perhaps for release engineers), and therefore to be useful, the build tool must be able to perform incremental builds without compromising consistency.
Correct incremental dependency analysis is hard, and as described above, many other build tools do a poor job of avoiding stable inconsistent states during incremental builds. In contrast, Bazel offers the following guarantee: after a successful invocation of the build tool during which you made no edits, the build will be in a consistent state. (If you edit your source files during a build, Bazel makes no guarantee about the consistency of the result of the current build. But it does guarantee that the results of the next build will restore consistency.)
As with all guarantees, there comes some fine print: there are some known ways of getting into a stable inconsistent state with Bazel. We won't guarantee to investigate such problems arising from deliberate attempts to find bugs in the incremental dependency analysis, but we will investigate and do our best to fix all stable inconsistent states arising from normal or "reasonable" use of the build tool.
If you ever detect a stable inconsistent state with Bazel, please report a bug.
Bazel uses sandboxes to guarantee that actions run hermetically1 and correctly.
Bazel runs Spawns (loosely speaking: actions) in sandboxes that only contain the minimal
set of files the tool requires to do its job. Currently sandboxing works on Linux 3.12 or newer
CONFIG_USER_NS option enabled, and also on macOS 10.11 or newer.
Bazel will print a warning if your system does not support sandboxing to alert you to the fact
that builds are not guaranteed to be hermetic and might affect the host system in unknown ways.
To disable this warning you can pass the
--ignore_unsupported_sandboxing flag to
On some platforms such as Google Kubernetes
Engine cluster nodes or Debian, user namespaces are deactivated by default due to security
concerns. This can be checked by looking at the file
/proc/sys/kernel/unprivileged_userns_clone: if it exists and contains a 0, then
user namespaces can be activated with
sudo sysctl kernel.unprivileged_userns_clone=1.
In some cases, the Bazel sandbox fails to execute rules because of the system setup. The symptom
is generally a failure that output a message similar to
namespace-sandbox.c:633: execvp(argv, argv): No such file or directory. In that
case, try to deactivate the sandbox for genrules with
and for other rules with
--spawn_strategy=standalone. Also please report a bug on our
issue tracker and mention which Linux distribution you're using so that we can investigate and
provide a fix in a subsequent release.
1: Hermeticity means that the action only uses its declared input files and no other files in the filesystem, and it only produces its declared output files.
Phases of a build
In Bazel, a build occurs in three distinct phases; as a user, understanding the difference between them provides insight into the options which control a build (see below).
The first is loading during which all the necessary BUILD files for the initial targets, and their transitive closure of dependencies, are loaded, parsed, evaluated and cached.
For the first build after a Bazel server is started, the loading phase typically takes many seconds as many BUILD files are loaded from the file system. In subsequent builds, especially if no BUILD files have changed, loading occurs very quickly.
Errors reported during this phase include: package not found, target not found, lexical and grammatical errors in a BUILD file, and evaluation errors.
The second phase, analysis, involves the semantic analysis and validation of each build rule, the construction of a build dependency graph, and the determination of exactly what work is to be done in each step of the build.
Like loading, analysis also takes several seconds when computed in its entirety. However, Bazel caches the dependency graph from one build to the next and only reanalyzes what it has to, which can make incremental builds extremely fast in the case where the packages haven't changed since the previous build.
Errors reported at this stage include: inappropriate dependencies, invalid inputs to a rule, and all rule-specific error messages.
The loading and analysis phases are fast because Bazel avoids unnecessary file I/O at this stage, reading only BUILD files in order to determine the work to be done. This is by design, and makes Bazel a good foundation for analysis tools, such as Bazel's query command, which is implemented atop the loading phase.
The third and final phase of the build is execution. This phase ensures that the outputs of each step in the build are consistent with its inputs, re-running compilation/linking/etc. tools as necessary. This step is where the build spends the majority of its time, ranging from a few seconds to over an hour for a large build. Errors reported during this phase include: missing source files, errors in a tool executed by some build action, or failure of a tool to produce the expected set of outputs.
The Bazel system is implemented as a long-lived server process.
This allows it to perform many optimizations not possible with a
batch-oriented implementation, such as caching of BUILD files,
dependency graphs, and other metadata from one build to the
next. This improves the speed of incremental builds, and allows
different commands, such as
query to share the same cache of loaded packages,
making queries very fast.
When you run
bazel, you're running the client. The
client finds the server based on the output base, which by default is
determined by the path of the base workspace directory and your
userid, so if you build in multiple workspaces, you'll have multiple
output bases and thus multiple Bazel server processes. Multiple
users on the same workstation can build concurrently in the same
workspace because their output bases will differ (different userids).
If the client cannot find a running server instance, it starts a new
one. The server process will stop after a period of inactivity (3 hours,
by default, which can be modified using the startup option
For the most part, the fact that there is a server running is invisible to the user, but sometimes it helps to bear this in mind. For example, if you're running scripts that perform a lot of automated builds in different directories, it's important to ensure that you don't accumulate a lot of idle servers; you can do this by explicitly shutting them down when you're finished with them, or by specifying a short timeout period.
The name of a Bazel server process appears in the output of
ps -e f as
bazel(dirname), where dirname is the
basename of the directory enclosing the root of your workspace directory.
% ps -e f 16143 ? Sl 3:00 bazel(src-johndoe2) -server -Djava.library.path=...
This makes it easier to find out which server process belongs to a
given workspace. (Beware that with certain other options
ps, Bazel server processes may be named just
java.) Bazel servers can be stopped using
the shutdown command.
bazel, the client first checks that the
server is the appropriate version; if not, the server is stopped and
a new one started. This ensures that the use of a long-running
server process doesn't interfere with proper versioning.
.bazelrc, the Bazel configuration file,
--bazelrc=file option, and
Bazel accepts many options. Typically, some of these are varied
frequently (for example,
--subcommands) while others stay the
same across several builds (e.g.
To avoid having to specify these unchanged options for every build (and other commands)
Bazel allows you to specify options in a configuration file.
Where are the
Bazel looks for an optional configuration file in the following locations,
in the order shown below. The options are interpreted in this order, so
options in later files can override a value from an earlier file if a
conflict arises. All options to control which of these files are loaded are
startup options, which means they must occur after
before the command (
--nosystem_rcis present, Bazel looks for the system .bazelrc file: on Unix, it lives at
/etc/bazel.bazelrc, and on Windows at
%ProgramData%/bazel.bazelrc. If another system-specified location is required, this value can be changed by setting
src/main/cpp:option_processorand using this custom Bazel binary. The system-specified location may contain environment variable substitutions, as
%var_name%on Windows or
--noworkspace_rcis present, Bazel looks for the
.bazelrcfile in your workspace directory.
--nohome_rcis present, Bazel looks for the home, or user, bazelrc: the file
.bazelrcin your home directory.
An additional .rc file can be specified by the
--bazelrc=filestartup option. If this option is not present, no additional file is loaded. Unlike in the three default locations specified above, an incorrect path or non-existent file will fail if passed explicitly.
.bazelrc syntax and semantics
Like all UNIX "rc" files, the
.bazelrc file is a text file with
a line-based grammar. Lines starting
# are considered comments
and are ignored, as are blank lines. Each line contains a sequence of words,
which are tokenized according to the same rules as the Bourne shell.
Lines that start with
import are special: if Bazel encounters such
a line in a
.bazelrc file, it parses the contents of the file
referenced by the import statement, too. Options specified in an imported file
take precedence over options specified before the import statement. Options
specified after the import statement take precedence over the options in the
imported file. Options in files imported later take precedence over files
imported earlier. To specify a path that is relative to the workspace root,
Most lines of a bazelrc define default option values. The first word on each line specifies when these defaults are applied:
startup: startup options, which go before the command, and are described in
bazel help startup_options.
common: options that apply to all Bazel commands.
command: Bazel command, such as
queryto which the options apply. These options also apply to all commands that inherit from the specified command. (For example,
Each of these lines may be used more than once and the arguments that follow
the first word are combined as if they had appeared on a single line.
(Users of CVS, another tool with a "Swiss army knife" command-line interface,
will find the syntax similar to that of
Options specified in the command line always take precedence over those from
a configuration file. Within the configuration file, precedence is
given by specificity. This means that lines for a more specific command take
precedence over lines for a less specific command, with
getting lowest precedence (for example, the
test command inherits
all the options from the
build command, so the line
test --foo=bar takes precedence over the line
build --foo=baz, regardless of which rc file or what order
these two lines are in). Two lines specifying options for the same command at
equal specificity are parsed in the order in which they appear within the file.
The user-specific configuration file takes precedence over the master file.
Because this precedence rule does not match the file order, we recommend
that the file follows the same order, with
common options at the
top, and most-specific commands near the bottom. This way, the order in which
the options are read is the same as the order in which they are applied,
which is more intuitive.
The arguments specified on a line of an rc file may include arguments that are not options, such as the names of build targets, and so on. These, like the options specified in the same files, have lower precedence than their siblings on the command line, and are always prepended to the explicit list of non- option arguments.
In addition to setting option defaults, the rc file can be used to group
options and provide a shorthand for common groupings. This is done by adding
:name suffix to the command. These options are ignored by
default, but will be included when the option
--config=name is present, either on the command line
or in a
.bazelrc file, recursively, even inside of another
config definition. The options specified by
only be expanded for applicable commands, in the precedence order described
Note that configs can be defined in any
.bazelrc file, and that
all lines of the form
command:name (for applicable commands)
will be expanded, across the different rc files. In order to avoid name
conflicts, we suggest that configs defined in personal rc files start
with an underscore ('_') to avoid unintentional name sharing.
--config=foo expands to the options defined in the rc files
"in-place" so that the options specified for the config have the same
precedence that the
--config=foo option had.
Here's an example
# Bob's Bazel option defaults startup --host_jvm_args=-XX:-UseParallelGC import /home/bobs_project/bazelrc build --show_timestamps --keep_going --jobs 600 build --color=yes query --keep_going # Definition of --config=memcheck build:memcheck --strip=never --test_timeout=3600
Other files governing Bazel's behavior
You can specify directories within the workspace
that you want Bazel to ignore, such as related projects
that use other build systems. Place a file called
.bazelignore at the root of the workspace
and add the directories you want Bazel to ignore, one per
line. Entries are relative to the workspace root.
Calling Bazel from scripts
Bazel can be called from scripts in order to perform a build, run tests or query the dependency graph. Bazel has been designed to enable effective scripting, but this section lists some details to bear in mind to make your scripts more robust.
Choosing the output base
--output_base option controls where the Bazel process should
write the outputs of a build to, as well as various working files used
internally by Bazel, one of which is a lock that guards against
concurrent mutation of the output base by multiple Bazel processes.
Choosing the correct output base directory for your script depends
on several factors. If you need to put the build outputs in a
specific location, this will dictate the output base you need to
use. If you are making a "read only" call to Bazel
bazel query), the locking factors will be more important.
In particular, if you need to run multiple instances of your script
concurrently, you will need to give each one a different (or random) output
If you use the default output base value, you will be contending for the same lock used by the user's interactive Bazel commands. If the user issues long-running commands such as builds, your script will have to wait for those commands to complete before it can continue.
Notes about Server Mode
By default, Bazel uses a long-running server process as an optimization. When running Bazel
in a script, don't forget to call
shutdown when you're finished
with the server, or, specify
that idle servers shut themselves down promptly.
What exit code will I get?
Bazel attempts to differentiate failures due to the source code under consideration from external errors that prevent Bazel from executing properly. Bazel execution can result in following exit codes:Exit Codes common to all commands:
2- Command Line Problem, Bad or Illegal flags or command combination, or Bad Environment Variables. Your command line must be modified.
8- Build Interrupted but we terminated with an orderly shutdown.
32- External Environment Failure not on this machine.
33- OOM failure. You need to modify your command line.
34- Reserved for Google-internal use.
35- Reserved for Google-internal use.
36- Local Environmental Issue, suspected permanent.
37- Unhandled Exception / Internal Bazel Error.
38- Reserved for Google-internal use.
40-44- Reserved for errors in Bazel's command line launcher,
bazel.ccthat are not command line related. Typically these are related to bazel server being unable to launch itself.
1- Build failed.
3- Build OK, but some tests failed or timed out.
4- Build successful but no tests were found even though testing was requested.
1- Build failed.
- If the build succeeds but the executed subprocess returns a non-zero exit code it will be the exit code of the command as well.
3- Partial success, but the query encountered 1 or more errors in the input BUILD file set and therefore the results of the operation are not 100% reliable. This is likely due to a
--keep_goingoption on the command line.
7- Command failure.
Future Bazel versions may add additional exit codes, replacing generic failure
1 with a different non-zero value with a particular
meaning. However, all non-zero exit values will always constitute an error.
Reading the .bazelrc file
By default, Bazel will read the
.bazelrc file from the base workspace
directory or the user's home directory. Whether or not this is
desirable is a choice for your script; if your script needs to be
perfectly hermetic (e.g. when doing release builds), you should
disable reading the .bazelrc file by using the option
--bazelrc=/dev/null. If you want to perform a build
using the user's preferred settings, the default behavior is better.
The Bazel output is also available in a command log file which you can find with the following command:
% bazel info command_log
The command log file contains the interleaved stdout and stderr streams
of the most recent Bazel command. Note that running
will overwrite the contents of this file, since it then becomes the most
recent Bazel command. However, the location of the command log file will
not change unless you change the setting of the
The Bazel output is quite easy to parse for many purposes. Two
options that may be helpful for your script are
--noshow_progress which suppresses progress messages,
--show_result n, which controls whether
or not "build up-to-date" messages are printed; these messages may
be parsed to discover which targets were successfully built, and the
location of the output files they created. Be sure to specify a
very large value of n if you rely on these messages.
Troubleshooting performance by profiling
The first step in analyzing the performance of your build is to profile your build with the
The file generated by the
command is a binary file. Once you have generated this binary profile, you can analyze it using
analyze-profile command. By default, it will
print out summary analysis information for each of the specified profile datafiles. This includes
cumulative statistics for different task types for each build phase and an analysis of the
critical execution path.
The first section of the default output describes an overview of the time spent on the different build phases:
=== PHASE SUMMARY INFORMATION === Total launch phase time 6.00 ms 0.01% Total init phase time 864 ms 1.11% Total loading phase time 21.841 s 28.05% Total analysis phase time 5.444 s 6.99% Total preparation phase time 155 ms 0.20% Total execution phase time 49.473 s 63.54% Total finish phase time 83.9 ms 0.11% Total run time 77.866 s 100.00%
The following sections show the execution time of different tasks happening during a particular phase:
=== INIT PHASE INFORMATION === Total init phase time 864 ms Total time (across all threads) spent on: Type Total Count Average VFS_STAT 2.72% 1 23.5 ms VFS_READLINK 32.19% 1 278 ms === LOADING PHASE INFORMATION === Total loading phase time 21.841 s Total time (across all threads) spent on: Type Total Count Average SPAWN 3.26% 154 475 ms VFS_STAT 10.81% 65416 3.71 ms [...] SKYLARK_BUILTIN_FN 13.12% 45138 6.52 ms === ANALYSIS PHASE INFORMATION === Total analysis phase time 5.444 s Total time (across all threads) spent on: Type Total Count Average SKYFRAME_EVAL 9.35% 1 4.782 s SKYFUNCTION 89.36% 43332 1.06 ms === EXECUTION PHASE INFORMATION === Total preparation time 155 ms Total execution phase time 49.473 s Total time finalizing build 83.9 ms Action dependency map creation 0.00 ms Actual execution time 49.473 s Total time (across all threads) spent on: Type Total Count Average ACTION 2.25% 12229 10.2 ms [...] SKYFUNCTION 1.87% 236131 0.44 ms
The last section shows the critical path:
Critical path (32.078 s): Id Time Percentage Description 1109746 5.171 s 16.12% Building [...] 1109745 164 ms 0.51% Extracting interface [...] 1109744 4.615 s 14.39% Building [...] [...] 1109639 2.202 s 6.86% Executing genrule [...] 1109637 2.00 ms 0.01% Symlinking [...] 1109636 163 ms 0.51% Executing genrule [...] 4.00 ms 0.01% [3 middleman actions]
You can use the following options to display more detailed information:
This option prints all recorded tasks in the order they occurred. Nested tasks are indented relative to the parent. For each task, output includes the following information:
[task type] [task description] Thread: [thread id] Id: [task id] Parent: [parent task id or 0 for top-level tasks] Start time: [time elapsed from the profiling session start] Duration: [task duration] [aggregated statistic for nested tasks, including count and total duration for each nested task]
This option is most useful for automated analysis with scripts. It outputs each task record on a single line using '|' delimiter between fields. Fields are printed in the following order:
- thread id - integer positive number, identifies owner thread for the task
- task id - integer positive number, identifies specific task
- parent task id for nested tasks or 0 for root tasks
- task start time in ns, relative to the start of the profiling session
- task duration in ns. Please note that this will include duration of all subtasks.
- aggregated statistic for immediate subtasks per type. This will include type name (lower case), number of subtasks for that type and their cumulative duration. Types are space-delimited and information for single type is comma-delimited.
- task type (upper case)
- task description
1|1|0|0|0||PHASE|Launch Bazel 1|2|0|6000000|0||PHASE|Initialize command 1|3|0|168963053|278111411||VFS_READLINK|/[...] 1|4|0|571055781|23495512||VFS_STAT|/[...] 1|5|0|869955040|0||PHASE|Load packages [...]
This option writes a file called
<profile-file>.htmlin the directory of the profile file. Open it in your browser to see the visualization of the actions in your build. Note that the file can be quite large and may push the capabilities of your browser – please wait for the file to load.
In most cases, the HTML output from
--htmlis easier to read than the
--dumpoutput. It includes a Gantt chart that displays time on the horizontal axis and threads of execution along the vertical axis. If you click on the Statistics link in the top right corner of the page, you will jump to a section that lists summary analysis information from your build.
Additionally passing this option will render a more detailed execution chart and additional tables on the performance of built-in and user-defined Skylark functions. Beware that this increases the file size and the load on the browser considerably.
If Bazel appears to be hung, you can hit ctrl + \ or send
SIGQUIT signal (
kill -3 $(bazel info server_pid)) to get a
thread dump in the file
$(bazel info output_base)/server/jvm.out.
Since you may not be able to run
bazel info if bazel is hung, the
output_base directory is usually the parent of the
symlink in your workspace directory.