⚠️ Common Error on Fresh Ubuntu / Debian

If you run make menuconfig on a fresh system, the build will fail with:

/bin/sh: 1: bison: not found
scripts/Makefile.lib: recipe for target '...' failed
make[1]: *** Error 127

Root cause: Building mconf requires bison
(a parser generator) and flex (a lexer), which are not installed by default.
The ncurses UI also needs libncurses-dev.

Fix — Ubuntu / Debian:

sudo apt install build-essential bison flex libncurses-dev libssl-dev libelf-dev

Fix — Fedora / RHEL / Rocky:

sudo dnf install gcc make bison flex ncurses-devel openssl-devel elfutils-libelf-devel

📌 Reading Your Running Kernel’s Config — Linux 6.x

You do not always have to build from scratch to see a kernel’s config. On modern systems:

# Method 1 — most distros store it here (Ubuntu, Fedora, Arch):
cat /boot/config-$(uname -r)

# Method 2 — if CONFIG_IKCONFIG_PROC=y was set at build time:
zcat /proc/config.gz | less

# Method 3 — Linux 6.x stores config here too:
cat /lib/modules/$(uname -r)/config

# Method 4 — extract from kernel image directly:
./scripts/extract-ikconfig /boot/vmlinuz-$(uname -r) > recovered.config

What is make menuconfig in Linux kernel?

make menuconfig is the most widely used interface for configuring the
Linux kernel before compiling it. It launches a full-screen, text-based menu in your
terminal (powered by the ncurses library) that lets you browse thousands of kernel
options, enable or disable features, and choose whether drivers are built into the
kernel image or compiled as loadable modules. Your selections are saved to a file
called .config, which the Kbuild system reads when you run make
to actually compile the kernel.

What is the difference between Kconfig and Kbuild?

Kconfig is the configuration system — it defines every available
kernel option using special text files named Kconfig scattered across
the source tree. Programs like menuconfig read these files to build
the interactive menus. Kbuild is the build system — it reads the
resulting .config file and uses Makefile rules in every
source directory to compile and link only the selected components into the final
kernel binary. Put simply: Kconfig is about choosing what to build; Kbuild is about
actually building it.

What is the .config file in Linux kernel compilation?

The .config file is a plain text file placed at the root of your kernel
source directory. It contains one line per configuration option in one of three forms:
CONFIG_XXX=y (built-in), CONFIG_XXX=m (loadable module), or
# CONFIG_XXX is not set (disabled). Kbuild reads this file to determine
which C source files to compile, which to skip, and how to link the final kernel. It
is the single source of truth for your entire kernel build.

What does tristate mean in Linux kernel configuration?

A tristate option can take three values: y (built into the kernel image),
m (compiled as a loadable kernel module), or n (not compiled
at all). Tristate options appear with angle brackets in menuconfig — <*>
for built-in, <M> for module, < > for off. Boolean
options only have two states (on or off) and appear with square brackets. Most device
drivers are tristate because you often want the flexibility to load the driver only when
the hardware is present.

Why does make menuconfig fail with “bison not found”?

Before menuconfig can display its UI, the kernel build system compiles a small host
program called mconf from C source. Building mconf requires
bison (a parser generator) and flex (a lexer) to be installed
on your host machine. If either is missing, the build fails with the “not found” error.
Fix it on Ubuntu/Debian with:
sudo apt install bison flex libncurses-dev.
On Fedora/RHEL: sudo dnf install bison flex ncurses-devel.

What is the difference between make oldconfig and make olddefconfig?

Both targets are used when you want to carry an existing .config to a new
kernel version. make oldconfig reads your existing choices and
interactively prompts you for any options that are new in the updated kernel —
you must answer each one manually. make olddefconfig does the same but
silently sets all new options to their default values without prompting.
Use oldconfig when you want control over new options; use
olddefconfig in scripts and CI pipelines where interactive input is not
possible.

How do I view my running kernel’s configuration in Linux?

There are several ways. Most Linux distributions store the kernel config at
/boot/config-$(uname -r) — run cat /boot/config-$(uname -r)
to read it. If the kernel was built with CONFIG_IKCONFIG_PROC=y, the
config is also exposed at /proc/config.gz — read it with
zcat /proc/config.gz. On Linux 6.x, many distributions also place it at
/lib/modules/$(uname -r)/config. If you have the kernel image file, you
can use the scripts/extract-ikconfig script to extract the embedded config
(only if CONFIG_IKCONFIG=y was set at build time).

📷 Suggested Images for This Post

• Hero image: Terminal screenshot of make menuconfig
  running on Ubuntu 24.04 with the Linux 6.8 kernel source — General Setup menu
  open. Alt text: “make menuconfig Linux kernel configuration menu on Ubuntu”
• Section 5: Two-panel image — left panel shows the kernel image
  size with everything built-in, right panel shows the same kernel with most
  drivers as modules. Highlights the size difference visually.
  Alt text: “Linux kernel built-in vs module size comparison”
• Section 6: Text editor screenshot of an actual .config
  file with CONFIG_XXX=y, =m, and is-not-set lines highlighted in different colours.
  Alt text: “Linux kernel .config file showing CONFIG_XXX=y and CONFIG_XXX=m”
• Section 8: Comparison grid of menuconfig vs nconfig vs xconfig
  screenshots side by side. Alt text: “Linux kernel menuconfig nconfig xconfig comparison”