rules_kconfig

Bazel rules for parsing Kconfig files and generating equivalent Bazel build settings.

A kconfig repository exposes each config symbol as a Bazel build setting flag (bool_flag, int_flag, or string_flag) whose default matches the Kconfig-declared default. It also generates a config.h header (via rules_cc_autoconf) that reflects the active flag values, so C/C++ code can consume the configuration with #include "config.h".

Setup

Add the dependency to your MODULE.bazel:

bazel_dep(name = "rules_kconfig", version = "{version}")

A Python toolchain is required for parsing. Configure one with rules_python:

python = use_extension("@rules_python//python/extensions:python.bzl", "python")
python.toolchain(python_version = "3.12")
use_repo(python, "python_3_12_host")

Then register a kconfig repository via the module extension:

kconfig = use_extension("@rules_kconfig//kconfig:extensions.bzl", "kconfig")
kconfig.repo(
    name = "my_kconfig",
    kconfig = "//:Kconfig",
    interpreter = "@python_3_12_host//:python",
)
use_repo(kconfig, "my_kconfig")

Generated repository

For a Kconfig file such as:

config FOO
    bool "Enable FOO"
    default n

config COUNT
    int "Count"
    default 3

The generated repository @my_kconfig contains:

Usage

Setting flag values

Flags can be set on the command line or in .bazelrc:

build --@my_kconfig//:CONFIG_FOO=true
build --@my_kconfig//:CONFIG_COUNT=7

Consuming config.h

Depend on the generated cc_library to include the header:

cc_library(
    name = "mylib",
    srcs = ["mylib.c"],
    deps = ["@my_kconfig//:config"],
)

#include "config.h"

#if CONFIG_FOO
/* FOO is enabled */
#endif

Reacting to flags with config_setting

Use config_setting + select() to vary build behavior:

config_setting(
    name = "foo_enabled",
    flag_values = {"@my_kconfig//:CONFIG_FOO": "true"},
)

cc_library(
    name = "mylib",
    srcs = ["mylib.c"],
    deps = select({
        ":foo_enabled": ["//extras:foo_support"],
        "//conditions:default": [],
    }),
)

Providing defaults via .config

You can supply a .config file to override Kconfig defaults. Pass the defaults attribute when declaring the repository:

kconfig.repo(
    name = "my_kconfig",
    kconfig = "//:Kconfig",
    defaults = "//:.config",
    interpreter = "@python_3_12_host//:python",
)

If any Kconfig symbol uses $(shell,...) for its default and is not explicitly set in the .config file, the repository rule will fail with an actionable error message.

Interactive configuration with menuconfig

The menuconfig rule launches kconfiglib's terminal UI for interactive Kconfig editing. Add a target to your BUILD.bazel:

load("@rules_kconfig//kconfig:menuconfig.bzl", "menuconfig")

menuconfig(
    name = "menuconfig",
    kconfig = "//:Kconfig",
)

Then run:

bazel run //:menuconfig

The TUI reads and writes the .config file in your workspace root.

Overriding configuration on external repositories

When a kconfig repository is declared by an external dependency, use kconfig.overrides to overlay your own .config without modifying the external module. If the source repository was itself created with a .config, the overrides are stacked on top of those base values:

kconfig = use_extension("@rules_kconfig//kconfig:extensions.bzl", "kconfig")
kconfig.overrides(
    name = "my_board_config",
    kconfig = "@ext_kconfig//:ext_kconfig",
    config = "//:.config",
    interpreter = "@python_3_12_host//:python",
)
use_repo(kconfig, "my_board_config")

Then wrap targets that depend on kconfig flags with the generated transition rule:

load("@my_board_config//:defs.bzl", "with_kconfig_overrides")

with_kconfig_overrides(
    name = "ext_config_customized",
    actual = "@ext_kconfig//:config",
)

Values explicitly set on the command line take precedence over the overlay.

rules_kconfig

Bazel rules for parsing Kconfig files and generating equivalent Bazel build settings and config.h headers.

Module extension

The primary interface is the kconfig module extension. Each kconfig.repo tag parses a Kconfig file tree and generates a repository containing:

• A bool_flag, int_flag, or string_flag for every config symbol.
• A cc_library target (:config) that provides config.h reflecting the active flag values.

kconfig = use_extension("@rules_kconfig//kconfig:extensions.bzl", "kconfig")
kconfig.repo(
    name = "my_kconfig",
    kconfig = "//:Kconfig",
    interpreter = "@python_3_12_host//:python",
)
use_repo(kconfig, "my_kconfig")

Use kconfig.overrides to overlay a .config file onto an external kconfig repository via a Starlark transition:

kconfig.overrides(
    name = "my_board_config",
    kconfig = "@ext_kconfig//:ext_kconfig",
    config = "//:.config",
    interpreter = "@python_3_12_host//:python",
)
use_repo(kconfig, "my_board_config")

See the Introduction for full setup and usage instructions.

Rules

• kconfig_library
• kconfig_toolchain
• menuconfig

Providers

• KConfigInfo

Repository Rules

• kconfig_overrides_repository
• kconfig_repository

Module Extensions

• kconfig

kconfig_library

load("@rules_kconfig//kconfig:defs.bzl", "kconfig_library")

kconfig_library(name, deps, srcs, root)

Collect Kconfig source files into a single provider for use by menuconfig and repository rules.

All source files must be real (non-generated) files. If a single source is provided, it is automatically treated as the root. When multiple sources are present, set root explicitly to indicate the top-level Kconfig entry point. Transitive sources from deps are included in the provider.

ATTRIBUTES

kconfig_toolchain

load("@rules_kconfig//kconfig:defs.bzl", "kconfig_toolchain")

kconfig_toolchain(name, kconfiglib)

Declares a kconfig toolchain backed by kconfiglib.

ATTRIBUTES

menuconfig

load("@rules_kconfig//kconfig:defs.bzl", "menuconfig")

menuconfig(name, config, kconfig)

Launch kconfiglib's menuconfig TUI for interactive Kconfig editing.

Run with bazel run to interactively create or edit a .config file against a Kconfig tree. The TUI writes the resulting configuration to the path specified by config (relative to the workspace root).

ATTRIBUTES

KConfigInfo

load("@rules_kconfig//kconfig:defs.bzl", "KConfigInfo")

KConfigInfo(root, srcs)

Encapsulates a Kconfig source tree: an optional root file and all source files (direct and transitive).

FIELDS

kconfig_overrides_repository

load("@rules_kconfig//kconfig:defs.bzl", "kconfig_overrides_repository")

kconfig_overrides_repository(name, config, interpreter, kconfig, kconfiglib_anchor)

Overlay .config values onto an existing kconfig repository.

Reads the manifest from the source kconfig repository to locate the symlinked Kconfig source tree, then reparses with kconfiglib and a user-provided .config file. If the source repository was itself created with a .config, the overrides are stacked on top of those base values. Generates a defs.bzl containing a Starlark transition and wrapper rule that apply the overrides.

Values explicitly set on the command line take precedence over the overlay.

The generated defs.bzl creates the transition and rule:

Use with_kconfig_overrides to wrap a kconfig-dependent target:

load("@base_kconfig_override//:defs.bzl", "with_kconfig_overrides")

with_kconfig_overrides(
    name = "config",
    actual = ":consumer_of_base",
)

ATTRIBUTES

kconfig_repository

load("@rules_kconfig//kconfig:defs.bzl", "kconfig_repository")

kconfig_repository(name, apparent_name, defaults, interpreter, kconfig, kconfiglib_anchor)

Parse a Kconfig file tree and generate a Bazel repository with build settings.

The generated repository contains a bool_flag, int_flag, or string_flag for every config symbol found in the Kconfig tree, plus a cc_library target (:config) providing a config.h header that reflects the active flag values.

The Kconfig source tree is symlinked into kconfig_srcs/ and a kconfig.manifest.json records the root file and all visited files. A repo-named symlink (e.g. @my_kconfig//:my_kconfig) points to the manifest for downstream consumers.

Prefer using the kconfig module extension rather than calling this rule directly.

ATTRIBUTES

kconfig

kconfig = use_extension("@rules_kconfig//kconfig:defs.bzl", "kconfig")
kconfig.overrides(name, config, interpreter, kconfig)
kconfig.repo(name, defaults, interpreter, kconfig)

Configure kconfig repositories.

TAG CLASSES

overrides

Overlay .config overrides onto an existing kconfig repository.

Attributes

repo

Declare a kconfig repository to be generated from a Kconfig file tree.

Attributes