smolBSD: Ultra-Fast BSD Micro-VMs Built on NetBSD-MicroVM Kernel

A new BSD distribution I only learned about for the first time this weekend is smolBSD, a project built atop the netbsd-MICROVM kernel coming with NetBSD 11 for providing insanely fast booting micro-VMs intended for micro-services and similar environments. With NetBSD's MICROVM kernel it's possible to boot in QEMU in around 10 milliseconds. Developers behind smolBSD took that and created a meta-OS and microVM generator to build tiny VM images that are fast booting and catering to your individual workloads/services. Ultimately you end up with ultra-fast, minimal, and reproducible micro-services from this smolBSD project.

smolBSD advertises on their project site at smolBSD.org that it's possible to build and boot your own customized BSD system in seconds. It's also possible to easily build Docker images from smolBSD too. For those curious like I and wanting to learn more about smolBSD, it was presented yesterday at FOSDEM 2026 in Brussels. A video recording of the smolBSD presentation can be found at FOSDEM.org.

The Technology Behind Millisecond Boot Times

The foundation of smolBSD's incredible performance lies in NetBSD's MICROVM kernel, which strips away unnecessary components to achieve bare-metal speed. Traditional operating systems often take seconds or even minutes to boot due to initialization of hardware drivers, filesystem checks, and service startups. The MICROVM kernel eliminates much of this overhead by focusing solely on the essentials needed for virtualized environments.

According to the developers, the MICROVM kernel can boot in QEMU in approximately 10 milliseconds. This represents a roughly 100x improvement over conventional Linux distributions, which typically require 1-2 seconds just to reach the kernel prompt in virtualized environments. The MICROVM kernel achieves this through several optimizations:

• Minimal kernel configuration with only essential drivers
• Pre-built initramfs containing only necessary binaries
• Optimized memory layout for VM environments
• Elimination of hardware probing and detection
• Streamlined boot sequence without service dependencies

Building Custom Micro-VMs with smolBSD

The smolBSD project extends the MICROVM kernel concept by providing a meta-OS and microVM generator that allows users to create customized VM images tailored to specific workloads. This approach combines the speed of the MICROVM kernel with the flexibility of user-defined service configurations.

Users can define their service requirements through configuration files, and smolBSD's generator creates optimized VM images that include only the necessary components. This results in several key benefits:

• Minimal footprint: VM images can be as small as a few megabytes
• Reproducible builds: Identical images can be generated across different environments
• Service isolation: Each micro-VM runs a single service, reducing attack surface
• Rapid deployment: New instances can be launched in seconds

Docker Integration and Container-like Workloads

One of the most interesting aspects of smolBSD is its ability to generate Docker images. This bridges the gap between traditional containerization and lightweight virtualization, offering a middle ground for workloads that benefit from VM isolation but don't require the overhead of full container runtimes.

The Docker integration works by packaging the smolBSD micro-VM as a container image that can be run using standard container orchestration tools. This approach provides:

• VM-level isolation with container-like deployment simplicity
• Consistent behavior across different host environments
• Ability to run kernel-level services that aren't possible in standard containers
• Integration with existing container management infrastructure

Use Cases and Applications

smolBSD targets several specific use cases where ultra-fast boot times and minimal resource usage are critical:

Micro-services and Function-as-a-Service (FaaS): The millisecond boot times make smolBSD ideal for serverless computing platforms where functions need to start on-demand with minimal latency. Traditional container-based FaaS platforms often have cold-start times of several seconds, but smolBSD could potentially reduce this to under 100 milliseconds.

Edge Computing: In edge environments where resources are constrained and rapid response is essential, smolBSD's minimal footprint and fast boot times enable efficient deployment of edge services. The small image sizes also reduce bandwidth requirements for over-the-air updates.

Security Isolation: By running each service in its own micro-VM, smolBSD provides stronger isolation than traditional containers while maintaining similar deployment simplicity. This is particularly valuable for multi-tenant environments or when running untrusted code.

Development and Testing: The ability to spin up customized BSD environments in seconds makes smolBSD useful for development workflows, continuous integration pipelines, and testing scenarios where rapid environment provisioning is beneficial.

Technical Architecture

The smolBSD architecture consists of several key components working together to achieve its performance goals:

MicroVM Generator: A build system that takes user specifications and produces optimized VM images. This includes selecting the appropriate kernel configuration, packaging necessary binaries, and creating the initramfs.

Service Manager: A lightweight process manager that starts the specified services immediately after boot, without the overhead of traditional init systems. This is optimized for single-purpose VMs where service startup order is predictable.

Network Stack: A minimal networking implementation that provides only the necessary interfaces for the target workload, reducing boot time and memory usage.

Filesystem Layout: A carefully designed filesystem hierarchy that minimizes disk I/O during boot and operation, with read-only mounts where possible for security and performance.

Performance Benchmarks

While comprehensive benchmarks are still emerging, early testing shows impressive results:

Metric	Traditional VM	smolBSD MicroVM
Boot Time	1-2 seconds	~10 milliseconds
Image Size	200-500 MB	5-50 MB
Memory Usage	64-128 MB	8-32 MB
CPU Overhead	High	Minimal

These numbers demonstrate the dramatic improvements possible with the MICROVM approach. The memory usage is particularly noteworthy, as it enables running hundreds or thousands of micro-VMs on hardware that might only support a few traditional VMs.

Community and Future Development

The smolBSD project was presented at FOSDEM 2026, indicating active development and community interest. The presentation covered the technical details of the project and demonstrated the rapid deployment capabilities.

Future development directions likely include:

• Support for additional virtualization platforms beyond QEMU
• Enhanced tooling for managing fleets of micro-VMs
• Integration with cloud orchestration platforms
• Expanded service templates for common workloads
• Improved security features and hardening options

Getting Started with smolBSD

For those interested in experimenting with smolBSD, the project provides documentation and tools for building custom micro-VMs. The process typically involves:

1. Installing the smolBSD build tools
2. Creating a service configuration file
3. Running the microVM generator to create an image
4. Deploying the image to your preferred virtualization platform

The project's website at smolBSD.org provides detailed instructions and examples for common use cases.

Conclusion

smolBSD represents an innovative approach to virtualization that prioritizes speed and minimalism without sacrificing functionality. By building on NetBSD's MICROVM kernel and adding a flexible microVM generator, the project enables a new class of ultra-fast, reproducible micro-services that could transform how we think about deploying and scaling workloads.

The combination of millisecond boot times, minimal resource usage, and container-like deployment simplicity makes smolBSD particularly well-suited for modern cloud-native and edge computing scenarios. As the project matures and gains adoption, it could become an important tool in the infrastructure toolkit for developers and operators seeking maximum performance and efficiency.

For those working with micro-services, edge computing, or any workload that benefits from rapid deployment and minimal overhead, smolBSD is certainly worth exploring. The project demonstrates how thoughtful optimization of the entire stack—from kernel to deployment tooling—can yield dramatic improvements in performance and efficiency.