Specifies the set of environment variables available to actions with target configuration. Variables can be either specified by `name`, in which case the value will be taken from the invocation environment, by the `name=value` pair which sets the value independent of the invocation environment, or by `=name`, which unsets the variable of that name. This option can be used multiple times; for options given for the same variable, the latest wins, options for different variables accumulate. Note that unless `--incompatible_repo_env_ignores_action_env` is true, all `name=value` pairs will be available to repository rules.

If true, an analysis failure of a rule target results in the target's propagation of an instance of `AnalysisFailureInfo` containing the error description, instead of resulting in a build failure.

If enabled, issue only a warning instead of an error for loads of experimental .bzls.

Specified the module versions in the form of `{module1}@{version1},module2@{version2}` that will be allowed in the resolved dependency graph even if they are declared yanked in the registry where they come from (if they are not coming from a [`NonRegistryOverride`]). Otherwise, yanked versions will cause the resolution to fail. You can also define allowed yanked versions with the `BZLMOD_ALLOW_YANKED_VERSIONS` environment variable. You can disable this check by using the keyword `all` (not recommended). [`NonRegistryOverride`]: https://github. com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/bazel/bzlmod/NonRegistryOverride. java

Allowed values for the `--cpu` flag.

Sets the maximum number of transitive dependencies through a rule attribute with a `for_analysis_testing` configuration transition. Exceeding this limit will result in a rule error.

Whether to announce rc options.

How to resolve aspect dependencies when the output format is one of {xml, proto,record}. 'off' means no aspect dependencies are resolved, 'conservative' (the default) means all declared aspect dependencies are added regardless of whether they are given the rule class of direct dependencies, 'precise' means that only those aspects are added that are possibly active given the rule class of the direct dependencies. Note that precise mode requires loading other packages to evaluate a single target thus making it slower than the other modes. Also note that even precise mode is not completely precise: the decision whether to compute an aspect is decided in the analysis phase, which is not run during 'bazel query'.

When printing the location part of messages, attempt to use a path relative to the workspace directory or one of the directories specified by -- package_path.

Maximum number of open files allowed during BEP artifact upload.

Specifies the build event service (BES) backend endpoint in the form `[SCHEME://]HOST[:PORT]`. The default is to disable BES uploads. Supported schemes are `grpc` and `grpcs` (grpc with TLS enabled). If no scheme is provided, Bazel assumes `grpcs`.

Sets the field `check_preceding_lifecycle_events_present` on `PublishBuildToolEventStreamRequest` which tells BES to check whether it previously received `InvocationAttemptStarted` and `BuildEnqueued` events matching the current tool event.

Specify a header in `NAME=VALUE` form that will be included in BES requests. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.

Specifies the instance name under which the BES will persist uploaded BEP. Defaults to null.

Specifies a list of notification keywords to be added the default set of keywords published to BES (`command_name={command_name}`, `protocol_name=BEP`). Defaults to none.

Specifies whether to publish BES lifecycle events. (defaults to 'true').

Specifies how long bazel should wait for the BES/BEP upload to complete while OOMing. This flag ensures termination when the JVM is severely GC thrashing and cannot make progress on any user thread.

Specifies the maximal size of stdout or stderr to be buffered in BEP, before it is reported as a progress event. Individual writes are still reported in a single event, even if larger than the specified value up to `-- bes_outerr_chunk_size`.

Specifies the maximal size of stdout or stderr to be sent to BEP in a single message.

Connect to the Build Event Service through a proxy. Currently this flag can only beused to configure a Unix domain socket (`unix:/path/to/socket`).

Specifies the base URL where a user can view the information streamed to the BES backend. Bazel will output the URL appended by the invocation id to the terminal.

Specifies a list of notification keywords to be included directly, without the `user_keyword=` prefix included for keywords supplied via `--bes_keywords`. Intended for Build service operators that set `-- bes_lifecycle_events=false` and include keywords when calling `PublishLifecycleEvent`. Build service operators using this flag should prevent users from overriding the flag value.

Specifies how long bazel should wait for the BES/BEP upload to complete after the build and tests have finished. A valid timeout is a natural number followed by a unit: Days (d), hours (h), minutes (m), seconds (s), and milliseconds (ms). The default value is `0` which means that there is no timeout.

Specifies whether the Build Event Service upload should block the build completion or should end the invocation immediately and finish the upload in the background. - `wait_for_upload_complete`: blocks at the end of the current invocation until all events (including lifecycle events if applicable) are uploaded and acknowledged by the backend. - `nowait_for_upload_complete`: blocks at the beginning of the next invocation until all events (including lifecycle events if applicable) are uploaded and acknowledged by the backend. - `fully_async`: blocks at the beginning of the next invocation until all events are uploaded but does not wait for acknowledgements. Events may be lost in case of (transient) failures and backends may report streams as incomplete in this mode. There is no guarantee that `FinishInvocationAttempt` or `FinishBuild` lifecycle events are sent.

If non-empty, write a varint delimited binary representation of representation of the build event protocol to that file. This option implies `--bes_upload_mode=wait_for_upload_complete`.

Convert paths in the binary file representation of the build event protocol to more globally valid URIs whenever possible; if disabled, the `file://` uri scheme will always be used

Specifies whether the Build Event Service upload for `-- build_event_binary_file` should block the build completion or should end the invocation immediately and finish the upload in the background. Either `wait_for_upload_complete` (default), `nowait_for_upload_complete`, or `fully_async`.

If non-empty, write a JSON serialisation of the build event protocol to that file. This option implies `--bes_upload_mode=wait_for_upload_complete`.

Convert paths in the json file representation of the build event protocol to more globally valid URIs whenever possible; if disabled, the `file://` uri scheme will always be used

Specifies whether the Build Event Service upload for `-- build_event_json_file` should block the build completion or should end the invocation immediately and finish the upload in the background. Either `wait_for_upload_complete` (default), `nowait_for_upload_complete`, or `fully_async`.

The maximum number of entries for a single `named_set_of_files` event; values smaller than 2 are ignored and no event splitting is performed. This is intended for limiting the maximum event size in the build event protocol, although it does not directly control event size. The total event size is a function of the structure of the set as well as the file and uri lengths, which may in turn depend on the hash function.

Whether all actions should be published.

If non-empty, write a textual representation of the build event protocol to that file

Convert paths in the text file representation of the build event protocol to more globally valid URIs whenever possible; if disabled, the `file://` uri scheme will always be used

Specifies whether the Build Event Service upload for `-- build_event_text_file` should block the build completion or should end the invocation immediately and finish the upload in the background. Either `wait_for_upload_complete` (default), `nowait_for_upload_complete`, or `fully_async`.

The maximum number of times Bazel should retry uploading a build event.

Custom key-value string pairs to supply in a build event.

If true, build runfiles symlink forests for all targets. If false, write them only when required by a local action, test or run command.

If true, write runfiles manifests for all targets. If false, omit them. Local tests will fail to run when false.

Check bazel version compatibility of Bazel modules. Valid values are `error` to escalate it to a resolution failure, `off` to disable the check, or `warning` to print a warning when mismatch detected.

If disabled, .bzl load visibility errors are demoted to warnings.

Check if the direct `bazel_dep` dependencies declared in the root module are the same versions you get in the resolved dependency graph. Valid values are `off` to disable the check, `warning` to print a warning when mismatch detected or `error` to escalate it to a resolution failure.

If disabled, visibility errors in target dependencies are demoted to warnings.

If specified, Bazel will instrument code (using offline instrumentation where possible) and will collect coverage information during tests. Only targets that match `--instrumentation_filter` will be affected. Usually this option should not be specified directly - `bazel coverage` command should be used instead.

Use terminal controls to colorize output.

Specify the mode the binary will be built in. Values: `fastbuild`, `dbg`, `opt`.

Selects additional config sections from the rc files; for every <command>, it also pulls in the options from <command>:<config> if such a section exists; if this section doesn't exist in any .rc file, Blaze fails with an error. The config sections and flag combinations they are equivalent to are located in the tools/*.blazerc config files.

If enabled, every query command emits labels as if by the Starlark <code>str</code> function applied to a <code>Label</code> instance. This is useful for tools that need to match the output of different query commands and/or labels emitted by rules. If not enabled, output formatters are free to emit apparent repository names (relative to the main repository) instead to make the output more readable.

Deprecated: this flag is not used internally by Blaze although there are legacy platform mappings to allow for backwards compatibility. Do not use this flag, instead use `--platforms` with an appropriate platform definition.

Configures a credential helper conforming to the [Credential Helper Specification][ch-spec]to use for retrieving authorization credentials for repositoryfetching, remote caching and execution, and the build event service.Credentials supplied by a helper take precedence over credentials supplied by`--google_default_credentials`, `--google_credentials`, a `.netrc` file, or the auth parameter to `repository_ctx.download()` and`repository_ctx.download_and_extract()`.May be specified multiple times to set up multiple helpers.See [Configuring Bazel's Credential Helper - Engflow Blog][ch-example] for instructions.[ch-spec]: https://github.com/EngFlow/credential-helper-spec[ch-example]: https://blog.engflow.com/2023/10/09/configuring-bazels-credential-helper/

How long to cache credentials for if the credential helper doesn't return an expiration time. Changing the value of this flag clears the cache.

Configures the timeout for a credential helper.Credential helpers failing to respond within this timeout will fail the invocation.

Use terminal cursor controls to minimize scrolling output.

Each `--define` option specifies an assignment for a build variable. In case of multiple values for a variable, the last one wins.

A comma-separated list of names of packages which the build system will consider non-existent, even if they are visible somewhere on the package path.Use this option when deleting a subpackage 'x/y' of an existing package 'x'. For example, after deleting x/y/BUILD in your client, the build system may complain if it encounters a label '//x:y/z' if that is still provided by another package_path entry. Specifying --deleted_packages x/y avoids this problem.

A path to a directory where Bazel can read and write actions and action outputs. If the directory does not exist, it will be created.

Additional places to search for archives before accessing the network to download them.

Specify a file to configure the remote downloader with. This file consists of lines, each of which starts with a directive (`allow`, `block` or `rewrite`) followed by either a host name (for `allow` and `block`) or two patterns, one to match against, and one to use as a substitute URL, with back-references starting from `$1`. It is possible for multiple `rewrite` directives for the same URL to be given, and in this case multiple URLs will be returned.

If true, Bazel picks up host-OS-specific config lines from bazelrc files. For example, if the host OS is Linux and you run bazel build, Bazel picks up lines starting with build:linux. Supported OS identifiers are linux, macos, windows, freebsd, and openbsd. Enabling this flag is equivalent to using --config=linux on Linux, --config=windows on Windows, etc.

Enable runfiles symlink tree; By default, it's off on Windows, on on other platforms.

Checks the environments each target is compatible with and reports errors if any target has dependencies that don't support the same environments

Comma-separated list of aspects to be applied to exec-configured targets, regardless of whether or not they are top-level targets. This is an experimental feature and is subject to change.

How long the server must remain idle before a garbage collection of the action cache is attempted. Ineffectual unless -- experimental_action_cache_gc_max_age is nonzero.

If set to a nonzero value, the action cache will be periodically garbage collected to remove entries older than this age. Garbage collection occurs in the background once the server has become idle, as determined by the -- experimental_action_cache_gc_idle_delay and -- experimental_action_cache_gc_threshold flags.

The percentage of stale action cache entries required for garbage collection to be triggered. Ineffectual unless -- experimental_action_cache_gc_max_age is nonzero.

Deprecated in favor of aspects. Use `action_listener` to attach an `extra_action` to existing build actions.

Whether to publish `TargetSummary` events.

If true, expand Filesets in the BEP when presenting output files.

Specify how an output group's files will be represented in `TargetComplete`/`AspectComplete` BEP events. Values are an assignment of an output group name to one of `NAMED_SET_OF_FILES_ONLY`, `INLINE_ONLY`, or `BOTH`. The default value is `NAMED_SET_OF_FILES_ONLY`. If an output group is repeated, the final value to appear is used. The default value sets the mode for coverage artifacts to BOTH: `--experimental_build_event_output_group_mode=baseline.lcov=both`

Initial, minimum delay for exponential backoff retries when BEP upload fails. (exponent: 1.6)

Selects how to upload artifacts referenced in the build event protocol. In Bazel the valid options include `local` and `remote`. The default value is `local`.

If enabled, adds a `visibility()` function that .bzl files may call during top-level evaluation to set their visibility for the purpose of load() statements.

If set to true, rule attributes and Starlark API methods needed for the rule cc_shared_library will be available

Specifies the strategy for the circuit breaker to use. Available strategies are "failure". On invalid value for the option the behavior same as the option is not set.

If specified, Bazel will also generate collect coverage information for generated files.

If enabled, the profiler collects the system's overall load average.

If enabled, the profiler collects the Linux PSI data.

If enabled, the profiler collects CPU and memory usage estimation for local actions.

If enabled, the profiler collects SkyFunction counts in the Skyframe graph over time for key function types, like configured targets and action executions. May have a performance hit as this visits the ENTIRE Skyframe graph at every profiling time unit. Do not use this flag with performance- critical measurements.

If enabled, the profiler collects the system's network usage.

If enabled, the profiler collects worker's aggregated resource data.

Records a Java Flight Recorder profile for the duration of the command. One of the supported profiling event types (cpu, wall, alloc or lock) must be given as an argument. The profile is written to a file named after the event type under the output base directory. The syntax and semantics of this flag might change in the future to support additional profile types or output formats; use at your own risk.

If set to true, the auto-generated //external package will not be available anymore. Bazel will still be unable to parse the file 'external/BUILD', but globs reaching into external/ from the unnamed package will work.

How long the server must remain idle before a garbage collection of the disk cache occurs. To specify the garbage collection policy, set --experimental_disk_cache_gc_max_size and/or --experimental_disk_cache_gc_max_age.

If set to a positive value, the disk cache will be periodically garbage collected to remove entries older than this age. If set in conjunction with --experimental_disk_cache_gc_max_size, both criteria are applied. Garbage collection occurrs in the background once the server has become idle, as determined by the --experimental_disk_cache_gc_idle_delay flag.

If set to a positive value, the disk cache will be periodically garbage collected to stay under this size. If set in conjunction with --experimental_disk_cache_gc_max_age, both criteria are applied. Garbage collection occurrs in the background once the server has become idle, as determined by the --experimental_disk_cache_gc_idle_delay flag.

If set to true, attr.label(materializer=), attr (for_dependency_resolution=), attr.dormant_label(), attr. dormant_label_list() and rule(for_dependency_resolution=) are allowed.

If set to true, enables the APIs required to support the Android Starlark migration.

If set to true, enables the `macro()` construct for defining symbolic macros.

If set to true, .scl files may be used in load() statements.

If true, enable the set data type and set() constructor in Starlark.

Whether to enable thread dumps. If true, Bazel will dump the state of all threads (including virtual threads) to a file every -- experimental_thread_dump_interval, or after action execution being inactive for --experimental_thread_dump_action_execution_inactivity_duration. The dumps will be written to the <output_base>/server/thread_dumps/ directory.

If true, enable package()s to set the transitive_visibility attribute to restrict which packages may depend on them.

aquery, cquery: whether to include aspect-generated actions in the output. query: no-op (aspects are always followed).

If set to true, exposes a number of experimental pieces of Starlark build API pertaining to Google legacy code.

If true, uses a Query implementation that does not make a copy of the graph. The new implementation only supports --order_output=no, as well as only a subset of output formatters.

How long an install base must go unused before it's eligible for garbage collection. If nonzero, the server will attempt to garbage collect other install bases when idle.

If true, enables the <code>isolate</code> parameter in the <a href="https: //bazel.build/rules/lib/globals/module#use_extension" ><code>use_extension</code></a> function.

Which model to use for where in the output tree rules write their outputs, particularly for multi-platform / multi-configuration builds. This is highly experimental. See [GH-6526] for details. Starlark actions can opt into path mapping by adding the key `supports-path-mapping` to the `execution_requirements` dict. [GH-6526]: https://github.com/bazelbuild/bazel/issues/6526

Each entry should be of the form `label=value` where label refers to a platform and values is the desired shortname to override the platform's CPU name in `$(TARGET_CPU)` make variable and output path. Only used when `--experimental_platform_in_output_dir`, `-- incompatible_target_cpu_from_platform` or `--incompatible_bep_cpu_from_platform` is true. Has highest naming priority.

If true, a shortname for the target platform is used in the output directory name instead of the CPU. The exact scheme is experimental and subject to change: 1. First, in the rare case the `--platforms` option does not have exactly one value, a hash of the platforms option is used. 2. Next, if any shortname for the current platform was registered by `--experimental_override_name_platform_in_output_dir`, then that shortname is used. 3. Then, if `--experimental_use_platforms_in_output_dir_legacy_heuristic` is set, use a shortname based off the current platform Label. 4. Finally, a hash of the platform option is used as a last resort.

If set to true, enables a number of platform-related Starlark APIs useful for debugging.

Specifies additional profile tasks to be included in the profile.

Includes the extra "out" attribute in action events that contains the exec path to the action's primary output.

Includes target configuration hash in action events' JSON profile data.

Includes target label in action events' JSON profile data.

Controls the output of BEP ActionSummary and BuildGraphMetrics, limiting the number of mnemonics in ActionData and number of entries reported in BuildGraphMetrics.AspectCount/RuleClassCount. By default the number of types is limited to the top 20, by number of executed actions for ActionData, and instances for RuleClass and Asepcts. Setting this option will write statistics for all mnemonics, rule classes and aspects.

Controls the output of BEP BuildGraphMetrics, including expensiveto compute skyframe metrics about Skykeys, RuleClasses and Aspects.With this flag set to false BuildGraphMetrics.rule_count and aspectfields will not be populated in the BEP.

Whether to make source manifest actions remotable

The minimum blob size required to compress/decompress with zstd. Ineffectual unless --remote_cache_compression is set.

If set to true, Bazel will extend the lease for outputs of remote actions during the build by sending `FindMissingBlobs` calls periodically to remote cache. The frequency is based on the value of `--experimental_remote_cache_ttl`.

The guaranteed minimal TTL of blobs in the remote cache after their digests are recently referenced e.g. by an ActionResult or FindMissingBlobs. Bazel does several optimizations based on the blobs' TTL e.g. doesn't repeatedly call GetActionResult in an incremental build. The value should be set slightly less than the real TTL since there is a gap between when the server returns the digests and when Bazel receives them.

A path to a directory where the corrupted outputs will be captured to.

If set to true, discard in-memory copies of the input root's Merkle tree and associated input mappings during calls to GetActionResult() and Execute(). This reduces memory usage significantly, but does require Bazel to recompute them upon remote cache misses and retries.

A Remote Asset API endpoint URI, to be used as a remote download proxy. The supported schemas are grpc, grpcs (grpc with TLS enabled) and unix (local UNIX sockets). If no schema is provided Bazel will default to grpcs. See: https://github.com/bazelbuild/remote-apis/blob/master/build/bazel/remote/asset/v1/remote_asset.proto

Whether to fall back to the local downloader if remote downloader fails.

Whether to propagate credentials from netrc and credential helper to the remote downloader server. The server implementation needs to support the new `http_header_url:<url-index>:<header-key>` qualifier where the `<url-index>` is a 0-based position of the URL inside the FetchBlobRequest's `uris` field. The URL-specific headers should take precedence over the global headers.

Sets the allowed number of failure rate in percentage for a specific time window after which it stops calling to the remote cache/executor. By default the value is 10. Setting this to 0 means no limitation.

The interval in which the failure rate of the remote requests are computed. On zero or negative value the failure duration is computed the whole duration of the execution.Following units can be used: Days (d), hours (h), minutes (m), seconds (s), and milliseconds (ms). If the unit is omitted, the value is interpreted as seconds.

If set to true, Bazel will mark inputs as tool inputs for the remote executor. This can be used to implement remote persistent workers.

HOST or HOST:PORT of a remote output service endpoint. The supported schemas are grpc, grpcs (grpc with TLS enabled) and unix (local UNIX sockets). If no schema is provided Bazel will default to grpcs. Specify grpc:// or unix: schema to disable TLS.

The path under which the contents of output directories managed by the --experimental_remote_output_service are placed. The actual output directory used by a build will be a descendant of this path and determined by the output service.

If set to true, enforce that all actions that can run remotely are cached, or else fail the build. This is useful to troubleshoot non-determinism issues as it allows checking whether actions that should be cached are actually cached without spuriously injecting new results into the cache.

Enables remote cache key scrubbing with the supplied configuration file, which must be a protocol buffer in text format (see src/main/protobuf/remote_scrubbing.proto).This feature is intended to facilitate sharing a remote/disk cache between actions executing on different platforms but targeting the same platform. It should be used with extreme care, as improper settings may cause accidental sharing of cache entries and result in incorrect builds.Scrubbing does not affect how an action is executed, only how its remote/disk cache key is computed for the purpose of retrieving or storing an action result. Scrubbed actions are incompatible with remote execution, and will always be executed locally instead.Modifying the scrubbing configuration does not invalidate outputs present in the local filesystem or internal caches; a clean build is required to reexecute affected actions.In order to successfully use this feature, you likely want to set a custom --host_platform together with --experimental_platform_in_output_dir (to normalize output prefixes).

If set to true, repository_rule gains some remote execution capabilities.

If set, the repository cache will hardlink the file in case of a cache hit, rather than copying. This is intended to save disk space.

If true enables the repository_ctx `load_wasm` and `execute_wasm` methods.

The maximum number of attempts to retry a download error. If set to 0, retries are disabled.

Enable experimental rule extension API and subrule APIs

Whether to include the command-line residue in run build events which could contain the residue. By default, the residue is not included in run command build events that could contain the residue.

Scale all timeouts in Starlark repository rules by this factor. In this way, external repositories can be made working on machines that are slower than the rule author expected, without changing the source code

If set to true, non-main repositories are planted as symlinks to the main repository in the execution root. That is, all repositories are direct children of the $output_base/execution_root directory. This has the side effect of freeing up $output_base/execution_root/__main__/external for the real top-level 'external' directory.

If enabled, the register_toolchain function may not include target patterns which may refer to more than one package.

Enables type checking in files and functions that contain type annotations or related syntax. (When this flag is disabled, Bazel is more forgiving of invalid types in type annotations.)

Enables type annotations and related syntax in .bzl files. Locations of files where these are allowed is further restricted by `-- experimental_starlark_types_allowed_paths`. Type syntax is never permitted in .scl files regardless of this flag.

List of canonical Label prefixes under which Starlark type annotations are allowed.

Stream log file uploads directly to the remote storage rather than writing them to disk.

If this option is enabled, filesets will treat all output artifacts as regular files. They will not traverse directories or be sensitive to symlinks.

If true, repository rules and module extensions will only inherit `PATH`, `PATHEXT` (on Windows), and environment variables explicitly specified by `-- repo_env`. Note that unless `--incompatible_repo_env_ignores_action_env` is true, `--action_env=NAME=VALUE` will also be included.

Dump the threads when action execution being inactive for this duration. If zero, no thread dumps are written for action execution being inactive.

How often to dump the threads periodically. If zero, no thread dumps are written periodically.

The maximum size of the stdout / stderr files that will be printed to the console. -1 implies no limit.

Please only use this flag as part of a suggested migration or testing strategy. Note that the heuristic has known deficiencies and it is suggested to migrate to relying on just `--experimental_override_name_platform_in_output_dir`.

If true, experimental Windows support for --watchfs is enabled. Otherwise --watchfsis a non-op on Windows. Make sure to also enable --watchfs.

Log certain Workspace Rules events into this file as delimited WorkspaceEvent protos.

The given features will be enabled or disabled by default for targets built in the target configuration. Specifying `-{feature}` will disable the feature. Negative features always override positive ones. See also `--host_features`.

Allows the command to fetch external dependencies. If set to false, the command will utilize any cached version of the dependency, and if none exists, the command will result in failure.

Sets a shorthand name for a Starlark flag. It takes a single key-value pair in the form `{key}={value}` as an argument.

At any point after an invocation has been running for at least one minute, if Blaze has spent at least this percentage of the invocation's wall time doing full GCs, Blaze will give up and fail with an OOM. A value of 100 effectively means to never give up for this reason.

If set to a value in [0, 100] and this is a command that takes top-level targets (e.g. build but not query) and there are multiple such top-level targets, overrides --gc_churning_threshold. Useful to configure more aggressive OOMing behavior (i.e. a lower value than -- gc_churning_threshold) when they are multiple top-level targets so that the invoker of Bazel can split and retry while still having less aggressive behavior when there is a single top-level target.

Limits which, if reached, cause GcThrashingDetector to crash Bazel with an OOM. Each limit is specified as <period>:<count> where period is a duration and count is a positive integer. If more than --gc_thrashing_threshold percent of tenured space (old gen heap) remains occupied after <count> consecutive full GCs within <period>, an OOM is triggered. Multiple limits can be specified separated by commas.

The percent of tenured space occupied (0-100) above which GcThrashingDetector considers memory pressure events against its limits (-- gc_thrashing_limits). If set to 100, GcThrashingDetector is disabled.

If enabled, Bazel profiles the build and writes a JSON-format profile into a file in the output base. View profile by loading into chrome://tracing. By default Bazel writes the profile for all build-like commands and query.

A comma-separated list of Google Cloud authentication scopes.

Specifies the file to get authentication credentials from. See https://cloud.google.com/docs/authentication for details.

Whether to use 'Google Application Default Credentials' for authentication.See [Authentication methods at Google - Google Cloud][gc-auth-methods] for details.Disabled by default.[gc-auth-methods]: https://cloud.google.com/docs/authentication

The maximum number of condition labels to show. -1 means no truncation and 0 means no annotation. This option is only applicable to --output=graph.

If true, then the graph will be emitted 'factored', i.e. topologically- equivalent nodes will be merged together and their labels concatenated. This option is only applicable to --output=graph.

The maximum length of the label string for a graph node in the output. Longer labels will be truncated; -1 means no truncation. This option is only applicable to --output=graph.

Configures keep-alive pings for outgoing gRPC connections. If this is set, then Bazelsends pings after this much time of no read operations on the connection, butonly if there is at least one pending gRPC call. The value 0 disables the keep-alives.

Configures a keep-alive timeout for outgoing gRPC connections. If keep-alive pings areenabled with `--grpc_keepalive_time`, then Bazel times out a connection if it doesnot receive a ping reply after this much time. Times are treated as secondgranularity; it is an error to set a value less than one second. If keep-alivepings are disabled, then this setting is ignored.

Set this to 'full' to enable checking the ctime of all input files of an action before uploading it to a remote cache. There may be cases where the Linux kernel delays writing of files, which could cause false positives. The default is 'lite', which only checks source files in the main repository. Setting this to 'off' disables all checks. This is not recommended, as the cache may be polluted when a source file is changed while an action that takes it as an input is executing.

Whether to manually output a heap dump if an OOM is thrown (including manual OOMs due to reaching --gc_thrashing_limits). The dump will be written to <output_base>/<invocation_id>.heapdump.hprof. This option effectively replaces -XX:+HeapDumpOnOutOfMemoryError, which has no effect for manual OOMs.

If true, Blaze will remove FileState and DirectoryListingState nodes after related File and DirectoryListing node is done to save memory. We expect that it is less likely that these nodes will be needed again. If so, the program will re-evaluate them.

Specifies the set of environment variables available to actions with execution configurations. Variables can be either specified by `name`, in which case the value will be taken from the invocation environment, by the `name=value` pair which sets the value independent of the invocation environment, or by `=name`, which unsets the variable of that name. This option can be used multiple times; for options given for the same variable, the latest wins, options for different variables accumulate.

Specify the mode the tools used during the build will be built in. Values: `fastbuild`, `dbg`, `opt`.

The host CPU.

The given features will be enabled or disabled by default for targets built in the exec configuration. Specifying `-{feature}` will disable the feature. Negative features always override positive ones.

The maximum number of attempts for http downloads.

The maximum timeout for http download retries. With a value of 0, no timeout maximum is defined.

The maximum number parallel http downloads.

Scale all timeouts related to http downloads by the given factor

If true, Bazel ignores `bazel_dep` and `use_extension` declared as `dev_dependency` in the `MODULE.bazel` of the root module. Note that, those dev dependencies are always ignored in the `MODULE.bazel` if it's not the root module regardless of the value of this flag.

If enabled, implicit dependencies will be included in the dependency graph over which the query operates. An implicit dependency is one that is not explicitly specified in the BUILD file but added by bazel. For cquery, this option controls filtering resolved toolchains.

aquery, cquery: whether to include aspect-generated actions in the output. query: no-op (aspects are always followed).

If set to true, tags will be propagated from a target to the actions' execution requirements; otherwise tags are not propagated. See https: //github.com/bazelbuild/bazel/issues/8830 for details.

Check the validity of elements added to depsets, in all constructors. Elements must be immutable, but historically the depset(direct=...) constructor forgot to check. Use tuples instead of lists in depset elements. See https://github.com/bazelbuild/bazel/issues/10313 for details.

If true, native rules add `DefaultInfo.files` of data dependencies to their runfiles, which matches the recommended behavior for Starlark rules ([runfiles features to avoid]). [runfiles features to avoid]: https://bazel. build/extending/rules#runfiles_features_to_avoid

When enabled, an exec groups is automatically created for each toolchain used by a rule. For this to work rule needs to specify `toolchain` parameter on its actions. For more information, see [GH-17134]. [GH-17134]: https://github.com/bazelbuild/bazel/issues/17134

A comma-separated list of rules (or other symbols) that were previously part of Bazel and which are now to be retrieved from their respective external repositories. This flag is intended to be used to facilitate migration of rules out of Bazel. See also https://github. com/bazelbuild/bazel/issues/23043. A symbol that is autoloaded within a file behaves as if its built-into- Bazel definition were replaced by its canonical new definition in an external repository. For a BUILD file, this essentially means implicitly adding a load() statement. For a .bzl file, it's either a load() statement or a change to a field of the `native` object, depending on whether the autoloaded symbol is a rule. Bazel maintains a hardcoded list of all symbols that may be autoloaded; only those symbols may appear in this flag. For each symbol, Bazel knows the new definition location in an external repository, as well as a set of special-cased repositories that must not autoload it to avoid creating cycles. A list item of "+foo" in this flag causes symbol foo to be autoloaded, except in foo's exempt repositories, within which the Bazel-defined version of foo is still available. A list item of "foo" triggers autoloading as above, but the Bazel-defined version of foo is not made available to the excluded repositories. This ensures that foo's external repository does not depend on the old Bazel implementation of foo A list item of "-foo" does not trigger any autoloading, but makes the Bazel- defined version of foo inaccessible throughout the workspace. This is used to validate that the workspace is ready for foo's definition to be deleted from Bazel. If a symbol is not named in this flag then it continues to work as normal -- no autoloading is done, nor is the Bazel-defined version suppressed. For configuration see https://github. com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/packages/AutoloadSymbols. java As a shortcut also whole repository may be used, for example +@rules_python will autoload all Python rules.

If enabled, `bazel test --run_under=//:runner` builds `//:runner` in the exec configuration. If disabled, it builds `//:runner` in the target configuration. Bazel executes tests on exec machines, so the former is more correct. This doesn't affect `bazel run`, which always builds `--run_under=//foo` in the target configuration.

If enabled, check testonly for prerequisite targets that are output files by looking up the testonly of the generating rule. This matches visibility checking.

If enabled, the `{binary}.repo_mapping` file emits a module extension's repo mapping only once instead of once for each repo generated by the extension that contributes runfiles.

If incompatible_enforce_config_setting_visibility=false, this is a noop. Else, if this flag is false, any config_setting without an explicit visibility attribute is //visibility:public. If this flag is true, config_setting follows the same visibility logic as all other rules. See https://github.com/bazelbuild/bazel/issues/12933.

Controls if the autoloads (set by --incompatible_autoload_externally) are enabled in themain repository. When enabled the rules (or other symbols) that were previously part of Bazel need to have load statements. Use buildifier to add them.

If true, java_binary is always executable. create_executable attribute is removed.

Disable objc_library's custom transition and inherit from the top level target instead (No-op in Bazel)

List of flags for which the use in `select()` is disabled.

If set to true, rule attributes cannot set 'cfg = "host"'. Rules should set 'cfg = "exec"' instead.

If set to true, disable the ability to utilize the default provider via field syntax. Use provider-key syntax instead. For example, instead of using `ctx.attr.dep.files` to access `files`, utilize `ctx.attr.dep [DefaultInfo].files See https://github.com/bazelbuild/bazel/issues/9014 for details.

A comma-separated list of flags that cannot be used in transitions inputs or outputs.

If set to true, calling the deprecated ctx.resolve_tools API always fails. Uses of this API should be replaced by an executable or tools argument to ctx.actions.run or ctx.actions.run_shell.

If set to true, the default value of the `allow_empty` argument of glob() is False.

When true, Bazel no longer modifies command line flags used for linking, and also doesn't selectively decide which flags go to the param file and which don't. See https://github.com/bazelbuild/bazel/issues/7670 for details.

If enabled, certain deprecated APIs (native.repository_name, Label. workspace_name, Label.relative) can be used.

If true, proto lang rules define toolchains from protobuf repository.

If true, enforce config_setting visibility restrictions. If false, every config_setting is visible to every target. See https://github. com/bazelbuild/bazel/issues/12932.

If enabled (or set to 'error'), fail if Starlark files are not UTF-8 encoded. If set to 'warning', emit a warning instead. If set to 'off', Bazel assumes that Starlark files are UTF-8 encoded but does not verify this assumption. Note that Starlark files which are not UTF-8 encoded can cause Bazel to behave inconsistently.

If enabled, targets that have unknown attributes set to None fail.

If true, runfiles of targets listed in the srcs attribute are available to targets that consume the filegroup as a data dependency.

In package_group's `packages` attribute, changes the meaning of the value "//..." to refer to all packages in the current repository instead of all packages in any repository. You can use the special value "public" in place of "//..." to obtain the old behavior. This flag requires that -- incompatible_package_group_has_public_syntax also be enabled.

If this option is set, sorts --order_output=auto output in lexicographical order.

Whether a target that provides an executable expands to the executable rather than the files in <code>DefaultInfo.files</code> under $(locations ...) expansion if the number of files is not 1.

If true, the genfiles directory is folded into the bin directory.

When enabled, passing multiple `--modify_execution_info` flags is additive. When disabled, only the last flag is taken into account.

If set to true, disables the function `attr.license`.

If set, (used) source files are package private unless exported explicitly. See https://github.com/bazelbuild/proposals/blob/master/designs/2019-10-24- file-visibility.md

If true, then methods on <code>repository_ctx</code> that are passed a Label will no longer automatically watch the file under that label for changes even if <code>watch = "no"</code>, and <code>repository_ctx. path</code> no longer causes the returned path to be watched. Use <code>repository_ctx.watch</code> instead.

If set to true, disables the `outputs` parameter of the `rule()` Starlark function.

In package_group's `packages` attribute, allows writing "public" or "private" to refer to all packages or no packages respectively.

If enabled, when outputting package_group's `packages` attribute, the leading `//` will not be omitted.

Whether --remote_local_fallback applies to --remote_cache.

If true, <code>--action_env=NAME=VALUE</code> will no longer affect repository rule and module extension environments.

If enabled, string keys in dicts passed to select() in .bzl files are immediately resolved to Labels relative to the file instead of being interpreted relative to the BUILD file they are ultimately loaded from.

If set to true, the command parameter of actions.run_shell will only accept string

If true, simplify configurable rule attributes which contain only unconditional selects; for example, if ["a"] + select("//conditions: default", ["b"]) is assigned to a rule attribute, it is stored as ["a", "b"]. This option does not affect attributes of symbolic macros or attribute default values.

If set to true, deprecated ctx.build_file_path will not be available. ctx. label.package + '/BUILD' can be used instead.

If enabled, certain language-specific modules (such as `cc_common`) are unavailable in user .bzl files and may only be called from their respective rules repositories.

If specified, the value of the cpu constraint (`@platforms//cpu:cpu`) of the target platform is used to set the `$(TARGET_CPU)` make variable.

When true, Bazel will stringify the label @//foo:bar to @//foo:bar, instead of //foo:bar. This only affects the behavior of str(), the % operator, and so on; the behavior of repr() is unchanged. See https://github. com/bazelbuild/bazel/issues/15916 for more information.

When true, Bazel will no longer allow using cc_configure from @bazel_tools. Please see https://github.com/bazelbuild/bazel/issues/10134 for details and migration instructions.

If set and --universe_scope is unset, then a value of --universe_scope will be inferred as the list of unique target patterns in the query expression. Note that the --universe_scope value inferred for a query expression that uses universe-scoped functions (e.g.`allrdeps`) may not be what you want, so you should use this option only if you know what you are doing. See https://bazel.build/reference/query#sky-query for details and examples. If --universe_scope is set, then this option's value is ignored. Note: this option applies only to `query` (i.e. not `cquery`).

Adds a new repository with a local path in the form of `{repository name}={path}`. Thisonly takes effect with `--enable_bzlmod` and is equivalent to adding acorresponding `local_repository` to the root module's `MODULE.bazel` file via`use_repo_rule`. If the given path is an absolute path, it will be used as it is.If the given path is a relative path, it is relative to the current workingdirectory. If the given path starts with `%workspace%`, it is relative to theworkspace root, which is the output of `bazel info workspace`. If the given pathis empty, then remove any previous injections.

When coverage is enabled, specifies whether to consider instrumenting test rules. When set, test rules included by `--instrumentation_filter` are instrumented. Otherwise, test rules are always excluded from coverage instrumentation.

When coverage is enabled, only rules with names included by the specified regex-based filter will be instrumented. Rules prefixed with '-' are excluded instead. Note that only non-test rules are instrumented unless `--instrument_test_targets` is enabled.

Unique identifier, in UUID format, for the command being run. If explicitly specified uniqueness must be ensured by the caller. The UUID is printed to stderr, the BEP and remote execution protocol.

Regex for overriding the matching logic for JDK21+ JVM heap memory collection. We are relying on volatile internal G1 GC implemenation details to get a clean memory metric, this option allows us to adapt to changes in that internal implementation without having to wait for a binary release. Passed to JDK Matcher.find()

Continue as much as possible after an error. While the target that failed and those that depend on it cannot be analyzed, other prerequisites of these targets can be.

If false, Blaze will discard the inmemory state from this build when the build finishes. Subsequent builds will not have any incrementality with respect to this one.

Use this to suppress generation of the legacy `important_outputs` field in the `TargetComplete` event. `important_outputs` are required for Bazel to ResultStore/BTX integration.

Whether each format is terminated with \0 instead of newline.

Number of parallel threads to use for the loading/analysis phase.Takes an integer, or a keyword ("auto", "HOST_CPUS", "HOST_RAM"), optionally followed by an operation ([-|*]<float>) eg. "auto", "HOST_CPUS*.5". "auto" sets a reasonable default based on host resources. Must be at least 1.

Specifies how and whether or not to use the lockfile. Valid values are `update` to use the lockfile and update it if there are changes, `refresh` to additionally refresh mutable information (yanked versions and previously missing modules) from remote registries from time to time, `error` to use the lockfile but throw an error if it's not up-to-date, or `off` to neither read from or write to the lockfile.

The logging level.

The maximum number of Starlark computation steps that may be executed by a BUILD file (zero means no limit).

If set, write memory usage data to the specified file at phase ends and stable heap to master log at end of build.

Tune memory profile's computation of stable heap at end of build. Should be and even number of integers separated by commas. In each pair the first integer is the number of GCs to perform. The second integer in each pair is the number of seconds to wait between GCs. Ex: 2,4,4,0 would 2 GCs with a 4sec pause, followed by 4 GCs with zero second pause

Add or remove keys from an action's execution info based on action mnemonic. Applies only to actions which support execution info. Many common actions support execution info, e.g. Genrule, CppCompile, Javac, StarlarkAction, TestRunner. When specifying multiple values, order matters because many regexes may apply to the same mnemonic. Syntax: `regex=[+-]key,regex=[+-]key,...`. Examples: - `.*=+x,.*=-y,.*=+z` adds `x` and `z` to, and removes `y` from, the execution info for all actions. - `Genrule=+requires-x` adds `requires-x` to the execution info for all Genrule actions. - `(?!Genrule).*=-requires-x` removes `requires-x` from the execution info for all non-Genrule actions.

Specifies URLs under which the source URLs of Bazel modules can be found, in addition to and taking precedence over any registry-provided mirror URLs. This flag can be specified per-registry using the syntax `--module_mirrors=<registry>=<mirror1>[,<mirror2>,...]` (e.g., `--module_mirrors=https://bcr.bazel.build=https://mirror.example.com`). It can also be specified as a comma-separated list of mirror URLs that applies to all registries that don't have an explicit list (e.g., `--module_mirrors=https://mirror1,https: //mirror2`). Set this to an empty value to disable the use of any mirrors not specified by the registries. Later uses of this flag override earlier ones with the same (or no) registry. The default set of mirrors may change over time, but all downloads from mirrors are verified by hashes stored in the registry (and thus pinned by the lockfile).

The maximum depth of the graph internal to a depset (also known as NestedSet), above which the depset() constructor will fail.

If enabled, deps from "nodep" attributes will be included in the dependency graph over which the query operates. A common example of a "nodep" attribute is "visibility". Run and parse the output of `info build- language` to learn about all the "nodep" attributes in the build language.

Output the results in dependency-ordered (default) or unordered fashion. The unordered output is faster but only supported when --output is not minrank, maxrank, or graph. Expands to: --order_output=no

Whether each format is terminated with \0 instead of newline. Expands to: --line_terminator_null=true

Output the results unordered (no), dependency-ordered (deps), or fully ordered (full). The default is 'auto', meaning that results are output either dependency-ordered or fully ordered, depending on the output formatter (dependency-ordered for proto, minrank, maxrank, and graph, fully ordered for all others). When output is fully ordered, nodes are printed in a fully deterministic (total) order. First, all nodes are sorted alphabetically. Then, each node in the list is used as the start of a post- order depth-first search in which outgoing edges to unvisited nodes are traversed in alphabetical order of the successor nodes. Finally, nodes are printed in the reverse of the order in which they were visited.

Output the results in dependency-ordered (default) or unordered fashion. The unordered output is faster but only supported when --output is not minrank, maxrank, or graph. Expands to: --order_output=auto

The format in which the query results should be printed. Allowed values for query are: build, graph, streamed_jsonproto, label, label_kind, location, maxrank, minrank, package, proto, streamed_proto, xml.

When specified, query results will be written directly to this file, and nothing will be printed to Bazel's standard output stream (stdout). In benchmarks, this is generally faster than <code>bazel query &gt; file</code>.

Override a module with a local path in the form of `{module name}={path}`. If the givenpath is an absolute path, it will be used as it is. If the given path is arelative path, it is relative to the current working directory. If the given pathstarts with `%workspace%`, it is relative to the workspace root, which is theoutput of `bazel info workspace`. If the given path is empty, then remove anyprevious overrides.

Override a repository with a local path in the form of `{repository name}={path}`,where the repository name can be either a canonical name or an apparent name from thepoint of view of the main repository.Note that if this is flag is used to override a module's repository, changes to theMODULE.bazel file will not be effective if the module is obtained from a registry. Use`--override_module` instead to for that purpose.If the given path is an absolute path, it will be used as it is. If the given path is arelative path, it is relative to the current working directory. If the given path startswith `%workspace%`, it is relative to the workspace root, which is the output of `bazelinfo workspace`. If the given path is empty, then remove any previous overrides.

A colon-separated list of where to look for packages. Elements beginning with '%workspace%' are relative to the enclosing workspace. If omitted or empty, the default is the output of 'bazel info default-package-path'.

Specifies a suffix to be added to the configuration directory.

If set, profile Bazel and write data to the specified file. See https: //bazel.build/advanced/performance/json-trace-profile for more information.

Number of profiles to retain in the output base. If there are more than this number of profiles in the output base, the oldest are deleted until the total is under the limit.

Show the command progress in the terminal title. Useful to see what bazel is doing when having multiple terminal tabs.

If true, attributes whose value is not explicitly specified in the BUILD file are included; otherwise they are omitted. This option is applicable to --output=proto

Populate the definition_stack proto field, which records for each rule instance the Starlark call stack at the moment the rule's class was defined.

If enabled, configurable attributes created by select() are flattened. For list types the flattened representation is a list containing each value of the select map exactly once. Scalar types are flattened to null.

Populate the source_aspect_name proto field of each Attribute with the source aspect that the attribute came from (empty string if it did not).

Use the starlark environment in the value of the generated $internal_attr_hash attribute. This ensures that the starlark rule definition (and its transitive imports) are part of this identifier.

Whether or not to calculate and populate the $internal_attr_hash attribute.

Populate the instantiation call stack of each rule. Note that this requires the stack to be present

Whether to output location information in proto output at all.

Comma separated list of attributes to include in output. Defaults to all attributes. Set to empty string to not output any attribute. This option is applicable to --output=proto.

Populate the rule_class_key field of each rule; and for the first rule with a given rule_class_key, also populate its rule_class_info proto field. The rule_class_key field uniquely identifies a rule class, and the rule_class_info field is a Stardoc-format rule class API definition.

Whether or not to populate the rule_input and rule_output fields.

If set, query will read the query from the file named here, rather than on the command line. It is an error to specify a file here as well as a command-line query.

By default, Bazel profiler will record only aggregated data for fast but numerous events (such as statting the file). If this option is enabled, profiler will record each event - resulting in more precise profiling data but LARGE performance hit. Option only has effect if --profile used as well.

If true and supported, instrumentation output is redirected to be written locally on a different machine than where bazel is running on.

Specifies the registries to use to locate Bazel module dependencies. The order is important: modules will be looked up in earlier registries first, and only fall back to later registries when they're missing from the earlier ones.

If true, the location of BUILD files in xml and proto outputs will be relative. By default, the location output is an absolute path and will not be consistent across machines. You can set this option to true to have a consistent result across machines.

Whether to accept remotely cached action results.

If set to 'all', all local outputs referenced by BEP are uploaded to remote cache.If set to 'minimal', local outputs referenced by BEP are not uploaded to the remote cache, except for files that are important to the consumers of BEP (e.g. test logs and timing profile). bytestream:// scheme is always used for the uri of files even if they are missing from remote cache.Default to 'minimal'.

The hostname and instance name to be used in bytestream:// URIs that are written into build event streams. This option can be set when builds are performed using a proxy, which causes the values of --remote_executor and --remote_instance_name to no longer correspond to the canonical name of the remote execution service. When not set, it will default to "${hostname}/${instance_name}".

A URI of a caching endpoint. The supported schemas are http, https, grpc, grpcs (grpc with TLS enabled) and unix (local UNIX sockets). If no schema is provided Bazel will default to grpcs. Specify grpc://, http:// or unix: schema to disable TLS. See https://bazel.build/remote/caching

If true, uploading of action results to a disk or remote cache will happen in the background instead of blocking the completion of an action. Some actions are incompatible with background uploads, and may still block even when this flag is set.

If enabled, compress/decompress cache blobs with zstd when their size is at least --experimental_remote_cache_compression_threshold.

Specify a header that will be included in cache requests: --remote_cache_header=Name=Value. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.

Set the default exec properties to be used as the remote execution platform if an execution platform does not already set exec_properties.

Downloads all remote outputs to the local machine. This flag is an alias for --remote_download_outputs=all. Expands to: --remote_download_outputs=all

Does not download any remote build outputs to the local machine. This flag is an alias for --remote_download_outputs=minimal. Expands to: --remote_download_outputs=minimal

If set to 'minimal' doesn't download any remote build outputs to the local machine, except the ones required by local actions. If set to 'toplevel' behaves like 'minimal' except that it also downloads outputs of top level targets to the local machine. Both options can significantly reduce build times if network bandwidth is a bottleneck.

Force remote build outputs whose path matches this pattern to be downloaded, irrespective of --remote_download_outputs. Multiple patterns may be specified by repeating this flag.

Instead of downloading remote build outputs to the local machine, create symbolic links. The target of the symbolic links can be specified in the form of a template string. This template string may contain {hash} and {size_bytes} that expand to the hash of the object and the size in bytes, respectively. These symbolic links may, for example, point to a FUSE file system that loads objects from the CAS on demand.

Only downloads remote outputs of top level targets to the local machine. This flag is an alias for --remote_download_outputs=toplevel. Expands to: --remote_download_outputs=toplevel

Specify a header that will be included in remote downloader requests: --remote_downloader_header=Name=Value. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.

Specify a header that will be included in execution requests: --remote_exec_header=Name=Value. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.

The relative priority of actions to be executed remotely. The semantics of the particular priority values are server-dependent.

HOST or HOST:PORT of a remote execution endpoint. The supported schemas are grpc, grpcs (grpc with TLS enabled) and unix (local UNIX sockets). If no schema is provided Bazel will default to grpcs. Specify grpc:// or unix: schema to disable TLS.

If specified, a path to a file to log gRPC call related details. This log consists of a sequence of serialized com.google.devtools.build.lib.remote.logging.RemoteExecutionLog.LogEntry protobufs with each message prefixed by a varint denoting the size of the following serialized protobuf message, as performed by the method LogEntry.writeDelimitedTo(OutputStream).

Specify a header that will be included in requests: --remote_header=Name=Value. Multiple headers can be passed by specifying the flag multiple times. Multiple values for the same name will be converted to a comma-separated list.

Value to pass as instance_name in the remote execution API.

Whether to fall back to standalone local execution strategy if remote execution fails.

Deprecated. See https://github.com/bazelbuild/bazel/issues/7480 for details.

Limit the max number of concurrent requests per gRPC connection. By default the value is 100.

Limit the max number of concurrent connections to remote cache/executor. By default the value is 100. Setting this to 0 means no limitation. For HTTP remote cache, one TCP connection could handle one request at one time, so Bazel could make up to --remote_max_connections concurrent requests. For gRPC remote cache/executor, one gRPC channel could usually handle 100+ concurrent requests (controlled by -- remote_max_concurrency_per_connection), so Bazel could make around `-- remote_max_connections * 100` concurrent requests.

Choose when to print remote execution messages. Valid values are `failure`, to print only on failures, `success` to print only on successes and `all` to print always.

Connect to the remote cache through a proxy. Currently this flag can only be used to configure a Unix domain socket (unix:/path/to/socket).

The relative priority of remote actions to be stored in remote cache. The semantics of the particular priority values are server-dependent.

The maximum number of attempts to retry a transient error. If set to 0, retries are disabled.

The maximum backoff delay between remote retry attempts. Following units can be used: Days (d), hours (h), minutes (m), seconds (s), and milliseconds (ms). If the unit is omitted, the value is interpreted as seconds.

The maximum amount of time to wait for remote execution and cache calls. For the REST cache, this is both the connect and the read timeout. Following units can be used: Days (d), hours (h), minutes (m), seconds (s), and milliseconds (ms). If the unit is omitted, the value is interpreted as seconds.

Whether to upload locally executed action results to the remote cache if the remote cache supports it and the user is authorized to do so.

If set to true, Bazel will compute the hash sum of all remote downloads and discard the remotely cached values if they don't match the expected value.

Specifies the location of the repo contents cache, which contains fetched repo directories shareable across workspaces. An empty string as argument requests the repo contents cache to be disabled, otherwise the default of `{-- repository_cache}/contents` is used. Note that this means setting `--repository_cache=` would by default disable the repo contents cache as well, unless `--repo_contents_cache={some_path}` is also set.

Specifies the amount of time the server must remain idle before garbage collection happens to the repo contents cache.

Specifies the amount of time an entry in the repo contents cache can stay unused before it's garbage collected. If set to zero, only duplicate entries will be garbage collected.

Specifies additional environment variables to be available only for repository rules. Note that repository rules see the full environment anyway, but in this way variables can be set via command-line flags and <code>.bazelrc</code> entries. The special syntax <code>=NAME</code> can be used to explicitly unset a variable. The string <code>%bazel_workspace% </code> in a value will be replaced with the absolute path of the workspace as printed by <code>bazel info workspace</code>.

A list of additional repositories (beyond the hardcoded ones Bazel knows about) where autoloads are not to be added. This should typically contain repositories that are transitively depended on by a repository that may be loaded automatically (and which can therefore potentially create a cycle).

Specifies the cache location of the downloaded values obtained during the fetching of external repositories. An empty string as argument requests the cache to be disabled, otherwise the default of `{--output_user_root}/cache/repos/v1` is used.

If set, downloading using `ctx.download{,_and_extract}` is not allowed during repository fetching. Note that network access is not completely disabled; ctx.execute could still run an arbitrary executable that accesses the Internet.

Prefix to insert before the executables for the `test` and `run` commands. If the value is `foo -bar`, and the execution command line is `test_binary - baz`, then the final command line is `foo -bar test_binary -baz`. This can also be a label to an executable target. Some examples are: - `valgrind` - `strace` - `strace -c` - `valgrind --quiet --num-callers=20` - `//package:target` - `//package:target --options`

If enabled, causes Bazel to print "Loading package:" messages.

Display progress messages during a build.

Minimum number of seconds between progress messages in the output.

Include timestamps in messages

Flag for advanced configuration of Bazel's internal Skyframe engine. If Bazel detects its retained heap percentage usage exceeds the threshold set by --skyframe_high_water_mark_threshold, when a full GC event occurs, it will drop unnecessary temporary Skyframe state, up to this many times per invocation. Defaults to 10. Zero means that full GC events will never trigger drops. If the limit is reached, Skyframe state will no longer be dropped when a full GC event occurs and that retained heap percentage threshold is exceeded.

Flag for advanced configuration of Bazel's internal Skyframe engine. If Bazel detects its retained heap percentage usage exceeds the threshold set by --skyframe_high_water_mark_threshold, when a minor GC event occurs, it will drop unnecessary temporary Skyframe state, up to this many times per invocation. Defaults to 10. Zero means that minor GC events will never trigger drops. If the limit is reached, Skyframe state will no longer be dropped when a minor GC event occurs and that retained heap percentage threshold is exceeded.

Flag for advanced configuration of Bazel's internal Skyframe engine. If Bazel detects its retained heap percentage usage is at least this threshold, it will drop unnecessary temporary Skyframe state. Tweaking this may let you mitigate wall time impact of GC thrashing, when the GC thrashing is (i) caused by the memory usage of this temporary state and (ii) more costly than reconstituting the state when it is needed.

Slims down the size of the JSON profile by merging events if the profile gets too large.

Stamp binaries with the date, username, hostname, workspace information, etc.

Writes into the specified file a pprof profile of CPU usage by all Starlark threads.

If this option is enabled, filesets crossing package boundaries are reported as errors.

If true, the tests() expression gives an error if it encounters a test_suite containing non-test targets.

Declares this build's target environment. Must be a label reference to an [`environment` rule]. If specified, all top-level targets must be compatible with this environment. See also `--platforms`. [`environment` rule]: https://github. com/bazelbuild/bazel/blob/master/src/main/java/com/google/devtools/build/lib/analysis/constraints/EnvironmentRule. java

Specify a path to a TLS certificate that is trusted to sign server certificates.

Specify the TLS client certificate to use; you also need to provide a client key to enable client authentication.

Specify the TLS client key to use; you also need to provide a client certificate to enable client authentication.

Query: If disabled, dependencies on 'exec configuration' will not be included in the dependency graph over which the query operates. An 'exec configuration' dependency edge, such as the one from any 'proto_library' rule to the Protocol Compiler, usually points to a tool executed during the build rather than a part of the same 'target' program. Cquery: If disabled, filters out all configured targets which cross an execution transition from the top-level target that discovered this configured target. That means if the top-level target is in the target configuration, only configured targets also in the target configuration will be returned. If the top-level target is in the exec configuration, only exec configured targets will be returned. This option will NOT exclude resolved toolchains.

A tool name to attribute this Bazel invocation to.

If false, Blaze will not persist data that allows for invalidation and re- evaluation on incremental builds in order to save memory on this build. Subsequent builds will not have any incrementality with respect to this one. Usually you will want to specify --batch when setting this to false.

Number of concurrent actions shown in the detailed progress bar; each action is shown on a separate line. The progress bar always shows at least one one, all numbers less than 1 are mapped to 1.

Specifies which events to show in the UI. It is possible to add or remove events to the default ones using leading +/-, or override the default set completely with direct assignment. The set of supported event kinds include INFO, DEBUG, ERROR and more.

A comma-separated set of target patterns (additive and subtractive). The query may be performed in the universe defined by the transitive closure of the specified targets. This option is used for the query and cquery commands. For cquery, the input to this option is the targets all answers are built under and so this option may affect configurations and transitions. If this option is not specified, the top-level targets are assumed to be the targets parsed from the query expression. Note: For cquery, not specifying this option may cause the build to break if targets parsed from the query expression are not buildable with top-level options.

If true, use the target platform for running tests rather than the test exec group.

Specifies the directory that should hold the external repositories in vendor mode, whether for the purpose of fetching them into it or using them while building. The path can be specified as either an absolute path or a path relative to the workspace directory.

If enabled, visibility errors include additional diagnostic information.

On Linux/macOS: If true, bazel tries to use the operating system's file watch service for local changes instead of scanning every file for a change. On Windows: this flag currently is a non-op but can be enabled in conjunction with --experimental_windows_watchfs. On any OS: The behavior is undefined if your workspace is on a network file system, and files are edited on a remote machine.

Whether or not to write the command.log file

If true, rule attributes whose value is not explicitly specified in the BUILD file are printed; otherwise they are omitted.

If true, XML output contains line numbers. Disabling this option may make diffs easier to read. This option is only applicable to --output=xml.