As already mentioned, AmigaOS was a pioneer in the early days of personal computing in delivering sophistication that contemporary systems could only have dreamt of and pretended to offer. Today, AmigaOS continues to offer a straightforward elegance that seems to be overlooked in the development of other platforms. Thanks to the concepts behind AmigaOS, the system is easy to understand and to use by everyone.

In this page we will explore all these concepts of AmigaOS. Also you will learn here the naming of all parts of the system.

The most important components

Exec, the AmigaOS kernel

Exec is the kernel of AmigaOS. It is the component that pilots all other components. It is responsible of running programs, dealing with computer memory, managing low-level resources that programs may need. In other words, it organises everything to make the operating system run.

It is made of different parts that cannot be moved outside the kernel: the scheduler, the memory pager and the 68k interpretive emulator.

AmigaDOS: the underlying system

The word "DOS" was originally an acronym for "Disk Operating System". Some say it should be "Disk Based Operating System" as it does a lot more than operate a disk and that it was really an operating system based (stored) on disks. Some say it should be "Device Operating System".

The whole AmigaDOS system includes things such as:

A set of commands that can be used in the Shell window and elsewhere.
A system for saving data to disk and retrieving it from disk.
A system for filing data on disks.
An interface for peripherals such as keyboards, monitors, printers, etc.
A method of running programs
A multitasking system for running more than one program at a time.
etc. etc. etc.

Read the AmigaDOS manual to understand and learn everything about AmigaDOS.

The Graphics library

The Graphics library handles every low level graphic operations like designing pixels on the monitor, creating graphic elements (bobs, sprites) and also writing text output.

Intuition

The Intuition library is responsible for every graphical objects: windows, screens, gadgets, mouse pointers... It lays between any graphic program and the graphics library.

The Workbench

The Workbench is the graphical place where you will manage your computer and all your files. The name was chosen because the user will use tools to create and work with the computer.

ARexx - inter-program communication by scripting

The ARexx scripting language can be used to operate the Workbench and the most important Amiga applications from a script containing ARexx commands. This is extremely useful to perform repetitive tasks or to do what the controlled application was not even design to do. After a learning curve, everybody can use ARexx as it is built in the system and the scripts can be executed immediately like any other tool.

How is my data stored?

Files

Executable files

Programs you can start are stored in executable files. They contain binary code directly understandable by the computer. They are files with an executable bit, a flag that shows AmigaOS that such file will do something when started. An example is a music player. When you start this executable, the player opens and you can start playing music files.

AmigaOS can run two different kinds of executable files: the AmigaOS native programs made for the PowerPC processor and programs created for the Motorola 68k processors. The laters are executed inside an emulation that transcripts them into PowerPC code.

Scripts

Scripts are text files containing a list of commands. So they are not strictly executables like binary code files but they can be executed by AmigaOS like if they were. This is the case with AmigaDOS and ARexx scripts. These files need to have the executable bit, and the script bit.

Data files

Files that are not executable are data files. These contain some data that will be manipulated by programs. Some examples are a music file, a video file or a text document.

Directories/Drawers

In order to organise things a bit, files are not all of them in the same place. We create directories which like drawers of a cabinet will store different files of the same kind. Often the name directory is used when talking about the directory which is stored on a disk. The graphical interface of AmigaOS being called the Workbench, directories are often called drawers.

Note: directories are often called folders on other systems.

Disks, partitions and volumes

Disks

Disks are storage medium you can purchase on a computer store. We use them to store our files. They can be internal hard disks, external ones or a USB disk drive.

Partitions

A disk is often very big and many users prefer to make it more organised. This is done virtually splitting the disk into several smaller parts. This operation is known as creating partitions on a disk.

TODO: insert a disk image with partitions

Volumes

A partition is a physical area on a disk. To access it with AmigaOS we could read the physical data off the partition but it's not an easy way. To make it easier AmigaOS uses the concept of volumes. These are virtual representations of a partition. The volumes have a name so AmigaOS and therefore the user can access all files/directories stored on it in a very practical way: just by using its name.

How to identify files/directories

On the Workbench

The Workbench being graphical, a lot of things are understandable just by looking at them. That's why icons are often enough to understand what kind of object it represents: a file, a directory, a disk...

In case you have a doubt, just look at the information on an icon. The Workbench will tell you the type of the object. It is displayed next to its name.

In a shell

In a shell you need to issue the command list to see if an object is a file or a directory.

A file will be displayed with its size, whereas a directory will be displayed with the text Dir next to it.

Also, as you can see on the screenshot, the list command displays other characteristics on these 3 items: the protection bits and the date they were updated the last time. The command also sums up what it just listed.

All AmigaOS components

AmigaOS is made of different components which have their own job in the system. The most important ones are mandatory. Without them the system does not even start. Other components are less important and the user can choose to use them or not. This is the case of drivers. For instance, a device driver may be omitted. If so, the corresponding device will just not work as AmigaOS will have no driver that allows it to know what to do with this device.

Kickstart modules

These components are the heart of AmigaOS. Their duties is to do graphics, to handle discs or to handle all reads/writes to files. Also one of them is the AmigaOS kernel which is some kind of director handling the work of all other components. You can find all these modules in the Kickstart directory in the system volume. Here is a list:

Mandatory modules

The following modules are required in any AmigaOS system. Without one of these, the system will not start.

kernel - The kernel works like a conductor in an orchestra. Its job is to make everything works together. It creates processes, handle memory usage, defines the way other components will access peripherals...etc. Note that the AmigaOS kernel is not based on any other kernel. It is a self made kernel that works since 1983.
loader - this component handles the loading of all other kickstart modules
battclock.resource.kmod - this module handles reading/writing the battery backed up clock which is used on all computers to keep the date and time
bootimage - this is the boot picture. It is displayed during the start sequence of AmigaOS
bootmenu.kmod - this component handles the Early Startup Menu the use can use to define some settings before starting AmigaOS
con-handler.kmod - it directs the read and write requests to the console window, to a serial AUX: device or any other supported interface
console.device.kmod - it opens a window and reads/writes text to and from that window
diskboot.kmod - handles the booting of AmigaOS from a supported disk
diskboot.config - this is a text file experienced users can modify to change the boot behaviour of AmigaOS
dos.library.kmod - this module is a collection of functions that any program can use to perform actions on disks, files and directories
elf.library.kmod - handles the loading of executable programs
env-handler.kmod - handles the read/writes of environment variables
FileSystem.resource.kmod - handles the use of the different filesystems
gadtools.library.kmod - collection of functions used to create all graphic objects like gadgets, sliders, menus...
gameport.device.kmod - handles the read/writes of game pads and joysticks
graphics.library.kmod - collection of functions used to draw graphic elements on the monitor
hunk.library.kmod - set of functions to read a data stream into memory
input.device.kmod - handles of input events like keyboard events or mouse clicks
intuition.library.kmod - collection of functions to create and handle all graphic elements (screens, windows, the mouse pointer...)
layers.library.kmod - set of functions to be used to handle different layers in graphic operations
keyboard.device.kmod - driver for the keyboard
keymap.library.kmod - functions to handle different keymaps
newlib.library.kmod - collection of functions to perform memory operations (allocating memory, copying memory areas... )
nonvolatile.library.kmod - provides a simple means for an application developer to manage nonvolatile storage
nvram.resource.kmod - handles the read/writes to the EEPROM chip present on many AmigaOS computers
PCIGraphics.card - driver that supports the use of different graphic cards
ram-handler.kmod - functions that handles the Ram disk: special disk
ramdrive.device.kmod - device that allows the usage of the ramdrive device RAD: disk
ramlib.kmod - loads disk based libraries and devices for exec.library
rtg.library - library of functions perform lowlevel graphic operations on graphic cards
shell.kmod - the AmigaOS command line interface
strap.kmod - module that handles booting on different disk devices
timer.device.kmod - driver to give access to timing functions

Filesystem support

These kickstart modules can be loaded or left aside. If you want to use a particular filesystem on your disk partitions, you need to load the corresponding filesystem module.

CDFileSystem - handles the CD-ROM disks with data stored in different formats: ISO9660, HFS...
SmartFilesystem - allows to store data on partitions in SFS0 and SFS2
JXFileSystem - allows to create partitions in JXFS
FastFileSystem - allows the usage of partitions in FFS and FFS2 layouts
diskcache.library.kmod - component required by the SmartFileSystem and JXFileSystem modules

Hardware drivers

Graphic cards drivers

3dfxVoodoo.chip
3DLabsPermedia2.chip
ATIRadeon.chip
RadeonHD.chip
siliconmotion502.chip

Disk drivers

Each of these drivers allow the use of disks connected to a disk controller. These files are named with the name of the controller they support. As an example, the sii3114ide.device.kmod allows to use disks connected on a Silicon Image SiI3114 controller chip.

it8212ide.device.kmod
lsi53c8xx.device.kmod
sam460sata.device.kmod
sii3112ide.device.kmod
sii3512ide.device.kmod
sii3114ide.device.kmod
sii0680ide.device.kmod
sii3132ide.device.kmod

USB drivers

hub.usbfd
usbsys.device
usbresource.library
ehci.usbhcd
ohci.usbhcd
uhci.usbhcd
massstorage.usbfd

Other drivers

bootkeyboard.usbfd - allows a USB keyboard to be used even before the USB stack is loaded
bootmouse.usbfd - allows a USB mouse to be used even before the USB stack is loaded
fpga.resource.kmod - allows to use the FPGA components which are present on some Amiga computers
i2c.resource.kmod - allows to use the i2c interface present on some Amiga computers
xena.resource.kmod - provides access to the Xena chip on the AmigaOne X1000

Misc modules

petunia.library.kmod - this module contains the Just-In-Time emulator that allows AmigaOS to run programs made for the Motorola 68k processor

System components

List of directories and files present at the root of any AmigaOS system

Beside the kickstart modules, AmigaOS uses many different components that can be loaded only when used. These files are stored in different directories in the system volume. Here is described a default AmigaOS installation.

C

This directory contains AmigaDOS Commands

Classes

contains different object elements easy to be used in any program: gadgets, requesters, graphic table, windows...

Devs

contains definition for Devices

Emulation

contains files used for the 68k emulation (though E-UAE)

Fonts

contains various systems fonts

Internet

contains a dialer to connect to Internet

Kickstart

contains the kickstart modules

L

contains handlers and filesystems

Libs

contains dynamic Librairies of functions

Locale

contains all files used to localise the system (catalogs, keymaps...)

MUI

contains the needed files for programs that use the MUI third party graphic interface

Prefs

contains the preference programs used to customise AmigaOS

S

contains the Scripts

SObjs

contains .so shared object library files

Storage

contains other optional files

System

contains some programs used by the system itself (i.e. you don't need to run them yourself) or low-level programs like disk tools

Utilities

contains several utilities

AmigaOS boot procedure

Basically a computer with AmigaOS does the following when the power button is pushed:

the BIOS (Uboot or CFE) of the computer initialises the hardware. At this point, the monitor wakes up and the first information are displayed
the BIOS looks on the harddisk and finds a file called the Second Level Booter (SLB). It is stored on the first sectors of the disk.
the SLB will then analyses all Amiga partitions and read each system configuration it finds. It shows all available configurations to the user.
the SLB loads the kickstart files of the selected configuration
SLB executes the Loader module
Loader executes the kickstart modules
AmigaOS becomes alive displaying a boot picture on the monitor
the AmigaDOS library executes the startup-sequence script found on the system volume
the Startup-sequence and all commands it contains are executed
the Workbench is started

At this point the user can use his/her computer.

UserDoc:How AmigaOS Works

Contents