Build Rust Kernel Modules: Check Your Kernel Tree First?

Updated 6 November 2026 · Standard formula, shown below

Yes, you should check your kernel tree before building Rust kernel modules, because the Rust support is tied to specific kernel versions and configurations. This article explains why the kernel tree matters, how to verify it, and what to do if your tree doesn’t support Rust yet.

Why the Kernel Tree Matters for Rust

The Linux kernel added experimental Rust support in version 6.1, released in December 2022. This support is not a separate download—it is built into the kernel source tree itself. The Rust-for-Linux project maintains patches that must be applied to a specific kernel version, and the mainline kernel includes a rust/ directory with the core infrastructure. If your kernel tree does not have that directory, you cannot build a Rust module against it, because the build system will not know how to compile Rust code or link it with the kernel’s internal symbols.

Even if your kernel version is 6.1 or later, the Rust support might be disabled in your kernel configuration. The kernel build system only compiles Rust code when CONFIG_RUST=y is set. So checking your kernel tree means two things: verifying the source version includes Rust, and verifying that the configuration enables it.

How Rust Modules Are Built

Rust kernel modules are compiled as separate loadable objects, similar to C modules. The build process uses the kernel’s Kbuild system, which invokes rustc (the Rust compiler) with special flags. The kernel provides a set of Rust crates (like kernel and alloc) that wrap the kernel API. When you build a module, you compile your Rust code against those crates, and the resulting .ko file can be loaded with insmod or modprobe.

To build a Rust module, you need:

A kernel source tree that includes the rust/ directory (version 6.1+).
The kernel configured with CONFIG_RUST=y.
A compatible Rust toolchain (the kernel specifies a minimum version, which changes over time).
The bindgen tool to generate Rust bindings for C headers.

The kernel’s rust/ directory contains a Makefile and the core crates. If you try to build a module with a kernel tree that lacks these, the build will fail with errors like No rule to make target 'rust/...'.

How to Check Your Kernel Tree

Before attempting to build a Rust module, verify the following:

Check the kernel version: Run uname -r for the running kernel, or look at the top-level Makefile in your source tree for the VERSION and PATCHLEVEL variables. Rust support requires at least 6.1.
Look for the rust/ directory: In the kernel source root, run ls rust/. If it doesn’t exist, your tree does not have Rust support.
Check the configuration: If you are building from a configured tree, run grep CONFIG_RUST .config. It should show CONFIG_RUST=y (or =m). If it is not set, you need to enable it via make menuconfig under General setup → Rust support.
Verify the toolchain: Run rustc --version and compare it with the minimum version specified in the kernel’s Documentation/rust/quick-start.rst or the rust/ Makefile. For 6.1, it was 1.62; later kernels require newer versions.

If you are using a distribution kernel (e.g., Ubuntu, Fedora), the source tree may not include the rust/ directory because the distro patches it out. In that case, you need to download the vanilla kernel source from kernel.org or use the distro’s source package with the Rust patches applied.

Common Problems and Misconceptions

One common mistake is assuming that having Rust installed on your system is enough. The kernel does not use your system’s Rust libraries; it builds its own crates from the source tree. So even if rustc works, the kernel build will fail if the tree lacks the Rust infrastructure.

Another misconception is that you can build a Rust module against the running kernel’s headers (like /lib/modules/$(uname -r)/build). That directory usually contains only the C headers and the configuration, not the rust/ sources. So you cannot build a Rust module without the full source tree.

Also, the Rust support is experimental and changes between kernel versions. A module built for 6.1 may not compile against 6.2 because the internal APIs (like kernel::file_operations) evolve. You must always build against the exact kernel source you intend to load the module into.

How to Choose the Right Kernel Tree

For most users, the easiest path is to use the latest stable kernel from kernel.org that includes Rust support. As of this writing, that means any version 6.1 or later. However, if you need a specific feature or driver, you might choose an LTS kernel (like 6.1 or 6.6) that has backported Rust support. The Rust-for-Linux project maintains a branch that tracks the latest mainline, but it is not recommended for production use.

When selecting a kernel, consider:

Your hardware and whether the kernel supports it.
The Rust toolchain version required—newer kernels often require newer Rust, which may not be available on your distro.
The stability of the Rust API—if you are writing a serious module, you may want to stick to a version that has been out for a while.

If you are using a distribution kernel, check if the distro provides a linux-rust package or similar. For example, some distros ship a separate kernel with Rust enabled. Otherwise, you will need to compile your own kernel.

Costs and Benefits of Building Your Own Kernel

Building a kernel with Rust support takes time and disk space. A full build can take 10-30 minutes on a modern machine, and the source tree plus build artifacts can use several gigabytes. However, you only need to build the kernel once; after that, building a module is quick.

The benefit is that you get a kernel that is exactly configured for your needs, and you can test Rust modules without relying on distro patches. The cost is that you must maintain the toolchain and recompile if you want to upgrade the kernel.

Safety and Stability Considerations

Rust kernel modules are experimental. The API is not stable, and there may be bugs in the Rust infrastructure itself. Loading a Rust module into a production kernel could cause crashes or data corruption. Always test on a non-critical machine or in a virtual machine first.

Also, the Rust toolchain must match the kernel’s expectations. Using a too-new or too-old version of rustc will cause build errors. The kernel’s documentation provides the exact version to use for each release.

Finally, remember that the kernel’s Rust support is not just about the compiler—it also requires a compatible bindgen version and sometimes a patched libclang. These are additional dependencies that can break if your system libraries are too old.

Alternatives to Building from Source

If you do not want to build a full kernel, you have a few options:

Use a distribution that already ships a Rust-enabled kernel (e.g., Fedora has experimental Rust support in some releases).
Use a container or VM with a prebuilt kernel that includes Rust.
Use the Rust-for-Linux project’s prebuilt kernel images for development (if available).

However, for actual module development, you will eventually need the source tree to compile against. There is no way to build a kernel module without the kernel source.

Frequently Asked Questions

Can I build a Rust module without the kernel source?

No. Kernel modules must be compiled against the exact kernel source (or at least the build directory) because they need the kernel’s internal headers and the generated Module.symvers file. For Rust, you also need the rust/ crates, which are only present in the source tree.

What if my kernel is 6.1 but doesn’t have the rust directory?

That means your kernel source is not the vanilla version, or the Rust support was removed by the distro. You need to download the official kernel source from kernel.org and use that.

How do I enable CONFIG_RUST?

Run make menuconfig in the kernel source root, go to General setup, and select Rust support. Then save the configuration and build the kernel. You also need to have the Rust toolchain installed before configuring, because the build system checks for it.

Can I use a Rust module built for one kernel version on another?

No. The kernel ABI changes between versions, and Rust modules are even more sensitive because they use internal APIs that are not stable. You must rebuild the module for each kernel version you want to load it into.

Is Rust support stable enough for production?

As of kernel 6.1, Rust support is experimental. It is not recommended for production use unless you are willing to deal with API changes and potential bugs. The kernel community is working toward stability, but it is not there yet.

What is the minimum Rust version for kernel 6.1?

The minimum is 1.62. Later kernels require newer versions, so always check the Documentation/rust/quick-start.rst in your kernel source for the exact requirement.

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.