Architecture

The architecture of AROS can be described as a modern reimplementation of the classic AmigaOS design. It keeps the Amiga-like structure and programming model, but is written as an open-source operating system that can run on different hardware platforms. Basic idea AROS is not simply an emulator. It is an operating system that is designed to be source-compatible with AmigaOS where possible. This means that software written for AmigaOS can often be recompiled for AROS, especially if it uses standard system APIs. Its architecture is modular. The system is built from many components such as libraries, devices, handlers, classes, and system services. Main architectural layers 

1. Kernel and Exec layer 

At the lowest level is the Exec-like kernel. This is inspired by AmigaOS Exec.

It is responsible for:
task scheduling
memory management
message passing
interrupts
semaphores and signals
system lists and resources
basic device and library management

AROS, like AmigaOS, uses a lightweight multitasking model. Programs run as tasks or processes and communicate through message ports. 

2. Libraries 

AROS uses shared system libraries heavily. Instead of putting all functionality into one large kernel, many services are provided through libraries. 

Examples include: 
graphics.library
intuition.library
dos.library
utility.library
layers.library
gadtools.library

Applications call these libraries to access system functions. This is very similar to classic AmigaOS.

Common AROS libraries

AROS m68k Libraries Reference Library

680x0
CPU-specific support functions for Motorola 68000-series processors

accounts
User account and authentication management

amigaguide
AmigaGuide hypertext help system supportaslStandard file, font, and screen requester library

asyncio
Asynchronous file and I/O operationsbluetooth

Bluetooth 
subsystem and device support

bz2
BZip2 compression and decompression functions

camd
Commodore Amiga MIDI driver system

codesets
Character set conversion and encoding support

commodities
Support for Commodities and background utilities

coolimages
Collection of standard GUI icons and images

cybergraphics
RTG graphics API compatible with CyberGraphX

datatypes
Unified framework for loading and displaying many file types

decorator
Window decoration management

decortheme
Theme engine for window decorationsdiskfontLoading and managing disk-based fonts

dos64
DOS functions with 64-bit file size support

egl
EGL interface between graphics drivers and OpenGL ES

envoy
Networking and resource-sharing services

expat
XML parsing libraryfdFunction definition (FD) file handling support

freetype2
TrueType and OpenType font rendering

gallium
Gallium3D graphics driver framework

gl
OpenGL graphics API

glu
OpenGL Utility Library

identify
Hardware and system identification functions

iffparse
Parsing and handling IFF files

jfif
JPEG/JFIF image format support

kms
Kernel Mode Setting graphics support

locale
Localization and language support

lzma
LZMA compression and decompression

mathieee
IEEE-compliant mathematical functions

mathtrans
Advanced mathematical transformations

mesa3dgl26
Mesa 3D OpenGL implementation

muimaster
Main library of the MUI/Zune GUI framework

muiscreen
MUI support for managing custom screens

nipc
Network Inter-Process Communication services

openurl
Opens URLs in the user's preferred web browser

pccard
PCMCIA card support

png
PNG image format support

popupmenu
Context and popup menu management

poseidon
USB stack and USB device management

posixc
POSIX-compatible C runtime library

prometheus
Support for Prometheus PCI hardware systems

reaction
ReAction GUI classes and widgets

realtime
Real-time timing and event services

reqtools
Enhanced requesters and dialog functions

rexxsupport
Additional ARexx support functions

rexxsyslib
Core ARexx system library

services
Network service management functions

stdcio
Standard C input/output support

tiff
TIFF image format support

translator
Data translation and conversion services

usergroup
User and group management

utf8proc
UTF-8 processing and Unicode normalization

uuid
Generation of UUID/GUID identifiers

version
Version information and version checking

vmm
Virtual memory management

z1
Auxiliary library used by Zune/MUI components

zstd
standard compression and decompression Functional Categories CategoryLibraries

3. Devices 

Devices provide low-level access to hardware or virtual hardware. They are not necessarily physical devices; they are system modules that offer a standard interface. 

Typical examples are: 
keyboard device
timer device
input device
audio device
storage devices
serial or parallel devices

Applications and system components communicate with devices using I/O requests and message passing. 

Common AROS devices 

ahi.device
Audio Hardware Interface device providing unified access to sound hardware and audio playback.

clipboard.device
Manages clipboard operations, allowing applications to exchange text and other data.

diskimage.device
Mounts disk image files (ADF, ISO, etc.) as virtual devices.

fdsk.device
Low-level floppy disk access and control device.

narrator.device
Text-to-speech synthesis device used by speech applications.

netinfo.device
Provides network interface and network information services.

parallel.device
Controls access to the system's parallel port.

printer.device
Standard printer interface for sending output to printers.

printtofile.device
Redirects print output to a file instead of a physical printer.

printtotool.device
Redirects print jobs to an external tool or processing application.

serial.device
Provides access to serial communication ports (RS-232 and compatible interfaces).

speech.device
Speech synthesis interface used together with narrator-related components.

timer.device 
Provides timing functions, delays, alarms, and time-based events for applications and system components. 

input.device 
Collects and distributes input events from keyboard, mouse, and other input sources.

keyboard.device 
Handles keyboard input and passes key events into the input system. 

console.device 
Provides text console windows used by the Shell and command-line programs. 

audio.device 
Offers basic audio output services and sound-related I/O functions. 

trackdisk.device 
Controls floppy disk access on systems that support Amiga-style disk drives. 

scsi.device 
Provides access to hard disks and other mass-storage devices through SCSI-like interfaces.

gameport.device 
4Handles joystick, mouse, and game controller input on compatible systems. 

4. DOS layer 

The DOS layer manages files, directories, volumes, command execution, and processes from the user’s point of view. 

It handles: 
files and directories
assigns
volumes
paths
command execution
Shell interaction
startup scripts

This is where concepts like SYS:, C:, LIBS:, DEVS:, S: and Prefs: become important. 5. Filesystem and handlers AROS uses handlers and filesystems to access different storage systems. 

A handler can represent: 
a disk filesystem
a console
a pipe
a network resource
another virtual device

This flexible design comes directly from the Amiga tradition. For example, CON: or RAM: behave like special devices that can be accessed through file-like paths. 

ahi.handler
Provides support for AHI audio streams and audio-related I/O operations.

aux.handler
Implements AUX: devices, typically used for serial terminal and communication connections.

debug.handler
Redirects output and diagnostic messages to debugging consoles or logs.

envoyfs.handler
Network file system handler used by the Envoy networking system for shared resources.

fat.handler
Provides access to FAT12, FAT16, and FAT32 file systems commonly used on PC media.

pfs3.handler
Supports the Professional File System 3 (PFS3), a high-performance Amiga file system.

pipe.handler
Creates named pipes for inter-process communication between applications.

port.handler
Provides DOS-style access to message ports as file-like objects.

sfs.handler
Supports the Smart File System (SFS), known for speed and reliability.

smb.handler
Allows access to SMB/CIFS network shares, such as Windows file servers and NAS devices.

speak.handler
Provides a speech output interface, typically used with speech synthesis devices and software.

6. Graphics system 

The graphics system provides screen, window, bitmap, and drawing support. 

Important parts include:
graphics.library for low-level graphics
layers.library for overlapping windows
intuition.library for windows, screens, menus, and gadgets

AROS keeps the Amiga concept of separate screens. Applications can open their own screens or use the public screen. 

7. Intuition and GUI systemIntuition is the central GUI system. 

It manages: 
windows
screens
menus
mouse and keyboard events
gadgets
requesters
user interaction

On top of this, AROS also uses higher-level GUI systems such as Zune, which is an open-source implementation inspired by MUI. 8. Wanderer desktop The standard AROS desktop is called Wanderer. It is comparable to Workbench on AmigaOS. 

Wanderer provides: 
icons
drawers
desktop windows
file management
program launching
drag and drop

It sits above the lower system layers and uses the standard AROS APIs. 

9. Hardware abstraction 

AROS is designed to run on different architectures, including: 
x86
x86-64
ARM
PowerPC
m68k

Because of this, hardware-specific code is separated from portable system code where possible. On hosted versions, AROS runs on top of another operating system like Linux or Windows. On native versions, it talks more directly to the hardware. 

Native, hosted, and m68k versions 

AROS can exist in different forms: 
Native AROS Boots directly on hardware 
Hosted AROS Runs as a program on another OS 
m68k AROS Runs on Amiga-like m68k systems or UAE AROS ROM Can replace or complement Kickstart-like functionality 

This flexibility is one of the major architectural differences compared with the original AmigaOS. 

How programs interact with AROS 

A typical AROS program does not access hardware directly. Instead, it uses system APIs. 

For example: 
to open a window, it uses Intuition
to draw graphics, it uses graphics.library
to read files, it uses dos.library
to use timers, it sends requests to timer.device
to build a GUI, it may use Zune or GadTools

This keeps programs more portable and better integrated into the system. 

10. concept of datatypes

One of the most innovative features inherited from AmigaOS and implemented in AROS m68k is the DataTypes system. DataTypes provide a standardized and extensible way for applications to handle many different file formats without requiring built-in support for each format. 

Basic Idea 
Instead of every application implementing its own code to load JPEG images, PNG files, WAV audio, text documents, or other formats, AROS delegates this task to specialized datatype classes. An application simply asks the DataTypes system to open a file. 

The system then:
Identifies the file type.
Loads the appropriate datatype class.
Creates an object representing the file.
Provides standardized methods for viewing, reading, printing, or processing the content.

  The application does not need to know the file's actual format.

Application
│
▼
DataTypes System
│
├── jpeg.datatype
├── png.datatype
├── wave.datatype
├── html.datatype
└── text.datatype
│
▼
File Content 

Advantages 

Format Independence 

Applications can support new formats automatically. 

For example: 
MultiView can display JPEG images. After installing png.datatype, MultiView can also display PNG images. No changes to MultiView itself are required.

Extensibility 
New formats can be added simply by installing new datatype modules. Examples:

Unified Programming Interface 
From a programmer's perspective, all datatype objects are accessed through a common API. 

An application can load: 
text files
images
sounds
animations

using the same programming model. 

Datatype Classes 

DataTypes are organized in a hierarchy. Generic Base Classes These provide common functionality.

picture.datatype
Generic image handling

sound.datatype
Generic audio handling

text.datatype
Generic text handling

animation.datatype
Generic animations

binary.datatype
Generic binary files 

Specialized Datatypes 

These inherit from the base classes. 

Example:

picture.datatype
│
├── jpeg.datatype
├── png.datatype
├── gif.datatype
├── tiff.datatype
├── bmp.datatype
└── webp.datatype 

All image datatypes support common image operations while adding format-specific decoding.

Automatic Format Detection 

DataTypes do not rely solely on filenames. 

Many datatypes examine: 
file headers
magic numbers
internal signatures

to identify a format. 

For example, a JPEG image can often be recognized even if it lacks a ".jpg" extension. 

Integration with MultiView 

The classic example is MultiView. MultiView itself contains very little format-specific code. 

Instead, it: 
Loads a file through DataTypes.
Displays whatever object is returned.
Uses the datatype to handle rendering.

As more datatypes are installed, MultiView automatically gains support for additional file formats.

Example Workflow 

Suppose a user double-clicks: VacationPhoto.webp 

AROS performs the following steps: 
Detects the file type.
Loads webp.datatype.
Creates a picture object.
Passes the object to MultiView.
MultiView displays the image.

The application never needs to understand the WebP format itself. Benefits for Developers Developers can write software that works with entire categories of files rather than individual formats.

AROS Enhancements 

While retaining compatibility with the classic AmigaOS architecture, modern AROS distributions often extend the DataTypes system with support for newer formats such as: 

PNG
JPEG
WebP
HEIC
TIFF
HTML

This allows legacy applications to work with modern file formats through the same DataTypes mechanism.

8svx.datatype
Supports Amiga 8SVX audio files and sound playback.

amigaguide.datatype
Displays and processes AmigaGuide hypertext documents.

animation.datatype
Handles animated image and video-style file formats.

ascii.datatype
Supports plain ASCII text files.

binary.datatype
Provides generic handling for binary data files.

bmp.datatype
Loads and displays Microsoft BMP bitmap images.

degas.datatype
Supports Atari ST DEGAS image formats.

font.datatype
Handles font files and font preview functionality.

gemimage.datatype
Supports GEM image formats used on Atari systems.

gif.datatype
Loads and displays GIF images, including animations where supported.

heic.datatype
Provides support for HEIC/HEIF image files.

html.datatype
Displays and renders HTML documents.

ilbm.datatype
Supports Amiga IFF ILBM bitmap images.

jpeg.datatype
Loads and displays JPEG image files.

picture.datatype
Generic image datatype superclass for picture formats.

png.datatype
Loads and displays PNG images.

pnm.datatype
Supports Portable AnyMap formats (PBM, PGM, PPM).

sound.datatype
Generic audio datatype superclass for sound formats.

text.datatype
Generic text datatype supporting text viewing and processing.

tiff.datatype
Loads and displays TIFF image files.

wave.datatype
Supports Microsoft WAV audio files.

webp.datatype
Loads and displays WebP image files.