DragonFly BSD facts for kids

Quick facts for kids
DragonFly BSD

DragonFly BSD 6.2.1 UEFI boot loader
Company / developer	Matthew Dillon
OS family	Unix-like (BSD)
Working state	Current
Source model	Open source
Initial release	1.0 / 12 July 2004; 21 years ago (2004-07-12)
Latest stable release	6.4.2 / 9 May 2025; 3 months ago (2025-05-09)
Available language(s)	English
Package manager	DPorts, pkg
Supported platforms	x86-64
Kernel type	Hybrid
Userland	BSD
Default user interface	Unix shell
License	BSD

DragonFly BSD is a free and open-source computer operating system. It's like the main program that helps your computer run. It was created from another system called FreeBSD 4.8.

Matthew Dillon, a computer developer, started working on DragonFly BSD in June 2003. He announced it to other developers in July 2003. Dillon believed that some changes planned for FreeBSD 5 would cause problems. He wanted to fix these issues. Even though he had some disagreements with other developers, DragonFly BSD and FreeBSD still work together. They share fixes for bugs and updates. Dillon named the project after seeing a dragonfly in his yard.

DragonFly BSD was meant to continue the ideas of FreeBSD 4.x. However, it has changed a lot since then. It uses special "lightweight kernel threads" (LWKT). It also has a unique way for parts of the system to send messages to each other. Plus, it uses a special file system called HAMMER. Many of its ideas were inspired by an older computer system called AmigaOS.

How DragonFly BSD Works

The Kernel

The kernel is the main part of an operating system. It controls everything. DragonFly's kernel has a special way for its different parts to communicate. This is called a messaging system. It's designed to be simple and work very efficiently.

According to Matthew Dillon, the team is working to improve how the kernel handles devices and files. This will allow many parts of the kernel to move outside of it. These parts will then run as smaller, separate programs. This makes them easier to fix if something goes wrong. It also makes the system stronger. If a part of the system crashes outside the kernel, the whole computer won't crash.

System calls are like requests from programs to the kernel. These are being split into two types: those that run inside the kernel and those that run outside. This helps make the kernel smaller and less complicated. It also helps DragonFly work with different versions and other systems like Linux.

How DragonFly Handles Tasks (Threading)

DragonFly BSD now works only on x86-64 computers. This makes it easier to support multiple processors. It used to run on older x86 computers, but that stopped with version 4.0. Since version 1.10, DragonFly supports a simple way for programs to run multiple tasks at once. This is called 1:1 userland threading. It also supports multi-threading, which it got from FreeBSD.

In DragonFly, each CPU (the brain of your computer) has its own task scheduler. Tasks are given to specific processors and usually stay there. They only move if a special message is sent between CPUs. This helps each processor use its own memory cache more effectively. It means each CPU can store different things it's working on. This leads to better performance.

The "Light Weight Kernel Threads" (LWKT) system helps divide work among many kernel tasks. For example, in the networking code, there's a separate task for each network rule on each processor. This reduces competition for shared resources.

Protecting Shared Resources

When multiple parts of the system need to use the same information, they need rules. These rules stop them from trying to change the same information at the same time. DragonFly uses "critical sections" and "serializing tokens" to prevent this. These methods help keep things organized and prevent problems.

Many core parts of DragonFly, like the LWKT system, work without needing special locks. This means each process works on its own CPU. Critical sections protect against interruptions on each CPU. This ensures a task won't be stopped while it's working.

Serializing tokens allow multiple tasks to access a shared resource. However, only one of those tasks can be actively running at any moment. This prevents issues like "deadlocks," where tasks get stuck waiting for each other. It also makes it easier to design complex procedures. DragonFly's token system is similar to a feature in Linux called "Read-copy-update."

DragonFly uses a special memory manager that works well with multiple processors. It doesn't need locks or waiting. This manager was also added to the standard C library for programs.

Virtual Kernel

Since release 1.8, DragonFly has a "virtual kernel" feature. This lets you run another kernel program inside the main system. It's like running a computer inside your computer. This virtual kernel runs in its own isolated space. It has fake network and storage connections. This makes it easier for developers to test new parts of the kernel.

The virtual kernel is different from the real one in two ways. It doesn't handle low-level hardware details. Also, it uses standard programming functions where possible. This helps keep the code for the real and virtual kernels organized.

The virtual kernel uses the main kernel for basic hardware functions. This includes things like timers, showing text on the screen, and using disk images.

Managing Software (Package Management)

You can get other software for DragonFly in two ways. You can use ready-to-install programs called "binary packages" through `pkgng`. Or, you can build them from source code using "DPorts."

DragonFly first used a system called FreeBSD Ports. Later, it switched to NetBSD's `pkgsrc` system. The idea was to make it easier to get third-party software. But keeping `pkgsrc` working with DragonFly became too much work. So, the project created DPorts. DPorts is a system built on top of FreeBSD Ports.

CARP Support

DragonFly BSD includes support for something called Common Address Redundancy Protocol (CARP). This feature helps make networks more reliable. It allows multiple computers to share the same network address. If one computer fails, another can take over. This was added to DragonFly in 2007.

HAMMER File Systems

DragonFly BSD supports the Unix File System, which is common on BSD systems. But it also has its own special file systems: HAMMER and HAMMER2. HAMMER2 became the main file system starting with version 5.2.0.

HAMMER was made just for DragonFly BSD. It was designed to be a powerful file system, similar to ZFS. HAMMER lets you keep a history of your files. It can also create "snapshots," which are like backups of your files at a certain time. It checks data for errors and can remove duplicate data.

HAMMER2 is the newer version of HAMMER. It is now considered stable and is the main focus for new development. Plans for HAMMER2 started in 2012. In 2017, Dillon announced that DragonFly BSD version 5.0.0 would include an early version of HAMMER2. With version 5.2.0, HAMMER2 became the default file system.

devfs

In 2007, DragonFly BSD got a new "device file system" called devfs. This system automatically adds and removes device names as needed. It lets you find devices by how they are connected. It also recognizes drives by their unique serial numbers. This means you don't need to manually set up device names beforehand. This feature was developed as part of a Google Summer of Code project in 2009.

Application Snapshots

DragonFly BSD has a feature similar to older Amiga computers. It can take a "snapshot" of a large program's memory after it loads. This allows the program to start much faster the next time you open it. This is very helpful for big programs that use many shared parts.

Development and How It's Shared

DragonFly BSD 6.2.1 with Lumina desktop environment

Like other BSD systems, DragonFly developers are updating their programming code. They are moving from older C language styles to more modern ones. DragonFly also uses a special tool called the "Stack-Smashing Protector." This helps protect against certain types of computer attacks. However, since July 2005, the main kernel is not built with this protection by default.

DragonFly has an easy-to-use system for building the entire operating system from its source code. The developers use a system called Git to manage changes to the code. Because DragonFly has a smaller team of developers, it keeps both stable and experimental versions of its code in one place.

DragonFly includes a built-in "kernel debugger." This tool helps developers find and fix problems in the kernel. Since October 2004, a special "debug kernel" is installed by default. This helps create more useful bug reports. When a new kernel is installed, older versions are cleaned up to save disk space.

How DragonFly BSD is Distributed

DragonFly BSD is available as a "Live CD" or "Live USB." This means you can start your computer from it without installing it. It includes the basic system and helpful guides. This allows users to install the system, fix a damaged installation, or try it out. Daily updates are also available online.

Like other free and open-source BSD systems, DragonFly is shared under the terms of the BSD license. This license allows people to use, change, and share the software freely.

Release History

Here are some of the past versions of DragonFly BSD and what changed:

More to Explore

• Comparison of BSD operating systems
• Comparison of open-source operating systems
• Comparison of operating system kernels
• Lumina (desktop environment)

See also

In Spanish: DragonFly BSD para niños