AtheOS - In Depth With the Author

BetaNews recently contacted Kurt Skauen regarding his operating system - AtheOS. Kurt covered such points as: the latest features in his new OS, who worked on it, and more. The main kernel is based off of UNIX. Previously, Kurt planned to develop his operating system to resemble an AmigaOS clone, however he decided to take an alternate path.

The AtheOS, specifically designed for Intel architecture and free of charge, has popped up on the Internet. It is released under the GPL license, and the creator stresses that its not meant to be another UNIX clone, nor does it run X-Windows. Instead, it offers its own multi-threaded GUI. But what is the story behind AtheOS, and what can it do? BetaNews takes an in-depth look at the newest addition to the family of operating systems that users have at their disposal.

BN: If you could explain the best features of the AtheOS that other
systems do not have, what would they be?

Kurt: The AtheOS kernel is designed to perform well on SMP machines and to
give low latency on all machines. It is fully re-entrant and I have
tried hard to keep locking as fine-grained and brief as possible. The
kernel is very modular and loads device-drivers dynamically as needed.
It have clean interfaces to normal device-drivers, file-systems and
network interfaces that make it easy to write drivers and expand the
functionality at runtime without rebooting. This is very far from
kernel-modules in Linux. A Linux kernel-module is more like a part of
kernel that is not necessarily loaded yet. The modules are heavily
interconnected with the kernel, while a device driver in AtheOS
communicate with the kernel through a small interface isolating it
from the rest of the kernel. This makes it much simpler to keep device
drivers compatible across different versions of the kernel.

The file system is 64-bit and journaled. It use B+trees to handle
directories with hundreds of thousands of files almost as efficient as
those with just a few files. It also support multiple equally
efficient data streams per file. All but the main data-stream is
named. And they can be typed (like int/float/string/etc etc). This
make it possible to identify a file by other attributes than the
name. The FS is ready for, but I am not fully done implementing "super
directories" containing all files on the FS keyed on the value of the
typed attributes. When done it will be possible to query for files
based on the value of the named streams. This is the main reason for
using B+trees, since some of the "super directories" will contain
every file on the system so a fast search algorithm is required.

The GUI is an integrated part of the OS. This does not mean that it
lives in kernel space. It has a user-space server handling the GUI
just like X but the server is much more high-level and talks to the
applications through a messaging protocol. The protocol is almost
entirely hidden from the apps by the C++ toolkit. The server also
handles the global clipboard and assist applications with
drag-and-drop. Both applications and the server is multithreaded to
make the GUI very responsive and to better utilize SMP machines.

The object-oriented GUI (Screenshots: 1, 2, 3, 4) was written via a C++ API "providing windows containing a hierarchy of widgets that all have their own graphical environment." He adds that the GUI is much more integrated into the operating system than the typical UNIX system.

With the AtheOS, users have a choice of up to 32 desktops, all with different color-depth and resolution capabilities, as well as the ability to "clone" windows to make them available on more than one desktop. Each desktop can also hold any number of windows.

AtheOS has a very flexible messaging system that makes it easy to
build advanced GUI components from existing components and connect it
all together to export a new interface.

To make it short:

o Object oriented GUI.
o Fast low-latency low-level messaging protocol (sending flat memory
buffers).
o Advanced flexible highlevel messaging protocol (sending typed data
stored in a flexible container class)
o Global clip-board and drag-and-drop with a well defined interface making
it easy to use.
o Pre-emptive mutithreaded kernel.
o Very modular kernel with a "real" device driver interface.
o 64-bit Journaled filesystem.
o multiple data-streams per file.
o indexing of named datastream (not finnished yet)
o Hierarchial /dev/ directory with dynamic layout (device drivers can add
remove entries dynamically)
o Most object's in the kernel (process,thread,semaphore,etc etc) have
names making it easier to debug programs and the kernel.

Many of the features in AtheOS is also found in one or more other
system. I try to combine the best from the systems I know and to add
what I feel is missing. I hope that the high-levelness of the API's
will make it easier to keep apps more consistent than on for example
Linux where everything above the bare kernel is optional.

BN: Explain how the communication in your system differs from others.

Kurt: I guess it is IPC.

AtheOS supports various POSIX/BSD IPC mechanisms like anonyme pipes
(pipe()), named pipes (mkfifo()), TCP/IP and POSIX signals. It also
support shared memory and most important, message ports.

The kernel provide message ports for sending flat data between threads
and processes. On top of that there is a highlevel message system that
make it easy(er) to make protocols that is backward/forward
compatible. The system is based around a container class that stores
members based on names. The sender give each member in the message a
name, and the receiver look them up using the same name. A element can
be one of the atomic types (int,float,bool,etc etc), a few of the API
classes (Point,Rect,etc etc) another message or a flat buffer of data
(untyped). The main advantage with this is that if a old app receives
a message from a new app it will simply ignore the new elements. If a
new app receive a message from a old app, it can often provide
resonable default values for the missing elements.

BN: What is your programming background?

Kurt: I have no "official" programming education.

I started programming assembler on the Amiga, and eventually learned C.

When Comodore went bankrupt I bought a PC and shortly after that I
started the AtheOS project. I was then employed as a programmer by
Funcom production, (a game company) where I learned C++.

BN: How long have you been developing the AtheOS?

Kurt: About 4 years.

BN: What was your motivation behind writing the AtheOS?

Kurt: When I first got a PC, I was not very aware of Linux, and my PC was to
small to run Windows so I ended up with DOS. Not to much fun to do
with DOS so I decided to create a GUI system I could use for my apps.
I kept working on it, and after a while I ended up with a quite useful
system. Today I do all development under AtheOS and that is a great
inspiration by itself.

BN: Did you do this on your own, or did you have some outside assistance?

Kurt: I have developed the OS myself and ported most apps from UNIX (GNU).

Users are given shell access via an x-term style program and bash, and have access to the majority of the tools normally found in a UNIX environment. It also features drag-and-drop functionality and a universal clipboard.

Most of the design of the file system comes from the book written by the creator of the BeOS file system.

The AtheOS operating system is capable of mounting drives from other AtheOS machines, as well as Linux machines, although the author stresses that the functionality is still premature and needs work before it will be extremely useful.