You just unboxed a new ARM board with 32 MB of RAM and a 300 MHz CPU. Your go-to Linux distribution won’t even boot. The stock kernel image alone eats 20 MB before you add a filesystem. You need a custom kernel that strips away everything your hardware does not use, fits in a few megabytes, and boots in seconds. That is exactly what we will do today. Building a minimal Linux kernel for embedded systems is not about disabling features randomly. It is a methodical process of understanding your target hardware, selecting only the required drivers, and fine-tuning kernel options for size and speed. In 2026, with the rise of tiny edge devices and IoT sensors, this skill is more valuable than ever. Let us walk through the entire workflow.

Why Minimal Still Matters in 2026

Embedded projects today run on cheaper, slower silicon. A minimal kernel means lower bill of materials, longer battery life, and faster boot times. The 2026 Linux kernel (version 6.x) has grown in complexity, but that does not force you to carry dead weight. By tailoring the kernel, you also reduce the attack surface for security vulnerabilities. Fewer drivers mean fewer lines of code that can go wrong. Whether you are building a temperature logger, a motor controller, or a FireWire bridge for legacy audio gear, a minimal kernel is the foundation of a reliable embedded system.

Setting Up Your Build Environment

You need a host machine (typically x86_64) and a cross-compilation toolchain for your target architecture. Common targets include ARM (armv7, aarch64), RISC-V (rv64), and MIPS. We will use the standard GCC toolchain from your package manager or from Bootlin’s toolchain builder.

• Verify your host packages: build-essential, flex, bison, libncurses-dev, bc, cpio.
• Download the latest stable kernel source from kernel.org.
• Install your cross-compiler. For ARM, the package is often gcc-arm-linux-gnueabihf.
• Set the ARCH and CROSS_COMPILE environment variables.

For a reliable pipeline, many developers also configure Buildroot or Yocto. But here we want a raw, manual build to understand every option.

Step-by-Step: Building Your Lean Kernel

1. Download and extract the kernel source. Use the tarball from kernel.org. In 2026, target the latest 6.xx stable version. wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.x.y.tar.xz and tar -xf linux-6.x.y.tar.xz.
2. Set the default configuration for your board. Most SoCs have a default config in arch/arm/configs/ (e.g., multi_v7_defconfig for ARMv7). Run make ARCH=arm multi_v7_defconfig. This gives you a working starting point that you will trim.
3. Enter the interactive configuration. Run make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig. Navigate each menu and disable everything you do not need.
4. Trim aggressively, but methodically. Start with General Setup: disable kernel .config support, disable debugging, disable printk if not needed. In File Systems, keep only the filesystem you boot from (e.g., ext4 or squashfs), turn off all others. In Device Drivers, disable every driver that does not match your hardware. For a board with no WiFi, no Bluetooth, no sound card, no GPU, those subsystems can go.
5. Compile the kernel. make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -j$(nproc). This produces zImage (compressed kernel) and the device tree blob.
6. Install modules (optional). If you enabled loadable modules, run make modules_install to a staging directory. For truly minimal builds, many developers build everything statically into the kernel and disable module support entirely.
7. Test in QEMU. Use QEMU with the correct machine type and device tree. For example: qemu-system-arm -M virt -kernel arch/arm/boot/zImage -dtb arch/arm/boot/dts/arm/vexpress-v2p-ca9.dtb -append "console=ttyAMA0" -nographic. This loop saves you bricking hardware.

Key Configuration Tweaks for Size

Use this bulleted list as a checklist when running menuconfig:

• Disable loadable module support unless you absolutely need kernel modules at runtime. Built-in drivers save space and avoid module overhead.
• Set the kernel tick rate to 100 Hz for embedded devices (General Setup > Timer frequency). 100 Hz is enough for most control loops and reduces timer interrupt overhead.
• Disable all network protocols except those you use. If no networking, turn off TCP/IP, IPv6, bridging, iptables. This alone can save 500 KB.
• Disable virtual memory support if your board has no swap and does not need mmap from large files. That means disabling swap, page migration, and memory compaction.
• Disable printk and kernel log buffering if you have a small serial console or no console at all. Use CONFIG_PRINTK=n.
• Trim the block layer. If you boot from raw flash (MTD) or use a ramdisk, disable SCSI, ATA, and most block drivers.
• Disable power management features if your device runs on mains power or does not need suspend/resume.
• Compile with size optimization. Set CONFIG_CC_OPTIMIZE_FOR_SIZE=y (in General Setup).

Common Pitfalls and How to Fix Them

Expert Advice from the Trenches

“The first time I built a minimal kernel for a 16 MB SDRAM board, I kept enabling networking ‘just in case’. The kernel image came out at 6 MB. I forced myself to disable everything not used in the final product. After five iterations, I got it down to 1.8 MB and the device booted in under 3 seconds. The trick is to start with the smallest possible set of features and add back only what the application truly needs. Pretend every Kconfig toggle is a dollar you have to spend.”
— Jordan T., embedded systems architect

Connecting Your Minimal Kernel to Real Hardware

Once your kernel boots in QEMU, you are ready to flash it to physical hardware. You will need a bootloader like U-Boot or barebox. The same stripped-down philosophy applies to the bootloader: disable unused commands and features. Keep your root filesystem small with BusyBox or Toybox. For advanced debugging, you might need to enable kernel probes or ftrace. At this stage, check out our guide on deep dive into Linux kernel debugging for FireWire interfaces if your project uses FireWire for high-speed data streaming. Similarly, if you need to extend the kernel with custom hardware, our article on optimizing Linux kernel modules for enhanced hardware compatibility will help you integrate additional peripherals without bloating the main kernel.

Start Building Your Lean Kernel Today

You now have a repeatable method to build a minimal Linux kernel for embedded systems. Download the 2026 stable kernel, run menuconfig, and challenge yourself to get the image under 2 MB. Each iteration teaches you something about your hardware and the kernel’s internal wiring. Start with a simple board, test in QEMU, and then move to real iron. The confidence you gain from crafting your own kernel will pay off in every future embedded project. And if you hit a snag, the Linux community and our site are full of practical resources to help you through. Go ahead, trim that kernel down to size.