Repository files navigation

Aero is a new modern, experimental, unix-like operating system written in Rust.Aero follows the monolithic kernel design and it is inspired by the Linux Kernel.Aero supportsmodern PC features such as Long Mode, 5-level paging,and SMP (multicore), to name a few.

Is this a Linux distribution?No, Aero runs its own kernel that doesnot originate from Linux and does not share any source code or binaries with the Linux kernel.

Official Discord Server:https://discord.gg/8gwhTTZwt8

Aero running TCC in Qemu (the background image is byRick Astley)

Aero running Quick JS in Qemu (the background image is byRick Astley)

Aero running DOOM in Qemu (the background image is byRick Astley)

• 64-bit higher half kernel
• 4/5 level paging
• Preemptive per-cpu scheduler
• Modern UEFI bootloader
• ACPI support (ioapic, lapic)
• Symmetric Multiprocessing (SMP)
• On-demand paging

• Creating a modern, safe, beautiful and fast operating system.
• Targetting modern 64-bit architectures and CPU features.
• Good source-level compatibility with Linux so we can port programs over easily.
• Making a usable OS which can run on real hardware, not just on emulators or virtual machines.

Please make sure you have aunix-like host system before buildingAero. If you are using windows, its highly recommended to use WSL 2.

Before building Aero, you need the following things installed:

• rustc should be thelatest nightly
• qemu
• nasm
• g++ 5.1 or later
• ninja
• parted
• meson
• python3

The following arenot requirements but arerecommendations:

• ~15GB of free disk space
• >= 8GB RAM
• >= 2 cores
• Internet access

Beefier machines will lead to much faster builds!

The very first step to work on Aero is to clone the repository:

$ git clone https://github.com/Andy-Python-Programmer/aero$cd aero

Aero uses a custom build system, that wrapscargo and takes care of building the kernel anduserland for you. It also builds the initramfs and disk image for you.

The main command we will focus on is./aero.py. The source code can be found in theroot of the repository and, as the file name states, it is written in Python.

By default if you run./aero.py without any arguments it will build the kernel and userlandin release mode with debug symbols and run it in QEMU. You can configure the behavior of thebuild system though. If you want to, you can use the--help option to read a brief descriptionof what it can do.

The build system acknowledges few different build modes, which cannot be used togetherand they are:--clean,--check,--test and--document.

• --clean option will clean all the build outputs.

• --check will build the kernel and userland using cargo'scheck command,this build mode will not produce a disk image, if you want one without actuallyrunning Aero in the emulator read ahead

• --test will run the built-in Aero test suite

• --document will generate web-based docs using cargo'sdoc command

• --sysroot will build the full userland sysroot. If not passed, then the sysroot will only containtheaero_shell and theinit binaries.

  Note: This command will require a relatively large amount of storagespace. You may want to have upwards of 10 or 15 gigabytes available if building with full sysroot.

Each of these modes can be used with additional flags, that will alter the behavior in differentways, some of them will not work for some of these modes - for example: the--la57 optionwill not have any effect when you are simply checking or documenting the build.

• --debug toggles off the release build flag when calling cargo.

  Summary: If the--debug flag is not passed then it will build Aero in release modeand debug symbols will be avaliable. On the other hand, if the debug flag is passedthen it will be built in debug mode and debug symbols will be still avaliable. By defaultAero is built in release mode (with debug symbols) since it generates faster and smallerbinaries which are easier to test.

• --no-run prevents from running the built disk image in the emulator

• --bios lets you choose the firmware the emulator will use when booting Aero,currently supported values are:legacy anduefi

• --features accepts a single comma-separated list of kernel crate features, pleasekeep in mind that there cannot be spaces in between the values

• --target lets you override the target architecture for which the kernel is built,currently the default value isx86_64-aero_os

• --la57 tells the emulator to use 5 level paging, if it supports it

The built disk image is stored in thebuild directory under the nameaero.iso. Both thedisk root and initramfs root are preserved in case you want to inspect them manually.

If you haven't used the--no-run option and you aren't using the--check or--document buildmode, the build system will run Aero in the emulator for you.

Want to give Aero a shot, without building it! You can go to thelatest job and download the latest nightly image (aero.iso), under artifacts.

Contributions are absolutely, positively welcome and encouraged! Check outCONTRIBUTING.md for the contributing guidelines for aero.

Aero is free software: you can redistribute it and/or modifyit under the terms of the GNU General Public License as published bythe Free Software Foundation, either version 3 of the License, or(at your option) any later version. See theLICENSE file for license rights and limitations.