SpiderOS

A super-light OS designed for speed on modern hardware.

What is this?
Our codebase needs to run fast, especially since it's all virtual. Due to this,
we need to optimize our code and our system. Due to the nature of this beast,
a miniature Linux distro is needed. We have created build tools to spin custom
images, borrowing from the Slitaz iso image, to construct a super small system
that is capable of outperforming any available linux distro on modern hardware.


How do the build tools work?
CreateLiteStage3.sh is a tool that auto-magically downloads a copy of slitaz-rolling
and generates a .img file formatted as ext4 and then mounts and copies the files over.
This generates a functional filesystem, minus the configuration. If you so choose, one
can compress these files and install this system just like the Gentoo Linux installation.

We are currently creating a new image with a newer linux kernel and will be baking in a
few more tools into the stock installation, with the intent to get rid of the desktop
and provide a modern multi-user experience in as small of a package as possible.


What are the potential use cases for this?
Since the system is built to be EXTREMELY small, it can work really well in containers.
Along with this, if someone wishes to squeeze all the performance out of their desktop,
an OS such as this will help them perform this task. To add to this list, this distro
has it's own open source build tools, making embedded Linux an option for SpiderOS.

Creating A Base System

Getting Started
To prepare for the SpiderOS build, you will need the following:

• A linux system with ncurses, tar, BASH, and networking capabilities.
  (Recommended CPU/RAM: 64 bit quad-core CPU at > 2.8 GHz, 16 gb RAM)
• If compiling for another device, find and install a cross-compiler for it's CPU.
  
• Storage space to manipulate the newly built OS image and generate new images.
  
• This repository downloaded via zip or git clone.

Generating the base system files
Once you have ensured you have met the base requirements for creating a SpiderOS
image, run the following:

cd /path/to/SpiderOS
sudo ./SystemBuild/mkroot.sh

This will generate a stage 3 system with BusyBox in the SystemBuild folder,
though it does create a few extra directories that you don't need :). To remedy
this, look for the directory "root" in /CWD/output/host where CWD is the
current working directory in which the script was executed.

Cross-Compiling
Additional information can be found in the ABOUTMKROOT file in the SystemBuild
directory. Consult this for documentation on how to use mkroot to cross-compile
your base system's binaries.
NOTE: The cross-compiling process can also be done to build a custom kernel,
though the scripts to build a kernel need to be updated to allow this use case.

Installing Software to the System

SpiderOS Ports
SpiderOS doesn't use a package manager, but instead provides a BSD-like ports
system to assist in installing software. SpiderOS ports are different in the
fact that a SH script is provided to assist in the installation of these apps.
It also provides the developer leeway to allow or disallow the ability to use
dependency resolution as SpiderOS provides power to the developer.

To Install the SpiderOS Ports system, copy the folder into your installation's
stage 3 build before converting it into an image. The recommended path for BSD
users is to store it in the /usr directory.

GCC and GNU Make
The SpiderOS contain build scripts to install GCC and GNU make into your stage3
system directory. These scripts are located inside the SystemBuild directory.
They are named InstallGCC.sh and InstallMake.sh and install the respective
software.

Custom Linux Kernels
The way to guarantee high performance and functionality on SpiderOS is to build
your own custom kernel. We provide a build script to allow you to do this on
native hardware. However, you may need to manually build your own kernel to
allow for Cross-Compiling on different hardware. Without a cross-compiler, the
process involves the following:

1. Browse to kernel.org and download the kernel version you wish to use.
2. Extract the source code using tar and use cd to navigate to the directory in
   your terminal.
3. Execute the command make menuconfig to be greeted by an ncurses menu to
   configure your Kernel.
4. Execute the command make O=/path/to/output where the output directory is
   the /boot directory in your Stage3 system build.
5. Execute the command make O=/path/to/output modules_install where the
   output directory is also the /boot directory in your Stage3.
6. Execute the command make O=/path/to/output install where the output
   is (again) the /boot directory in your Stage3.
   

Your Kernel image files should now be built in /boot in your new system files.
NOTE: This kernel compilation process is similar when using a cross-compiler.

After this, use chroot to enter your new system and install new applications
and software for you to use. Once you are ready, proceed to the next phase.

Installation

Generating an Install Image
SpiderOS provides 3 facilities to assist in installation, located in the aptly
named Installation directory. One script will allow you to generate a .img file
which can be used to flash devices such as the Raspberry Pi. To use this, run
ConvertToIMG.sh in the Installation directory. To create a tarball for UMSDOS
style installation (like Gentoo Linux or SourceMage Linux), Execute the file
CreateStage3Tar.sh in the Installation directory. Additional bootstrapping
tools are incoming.

Installing
This part is outside of the scope of SpiderOS. However, it is recommended to
consult the Gentoo Handbook for UMSDOS-style installation, and also recommended
to read the linux manual pages dd as it is useful for flashing .img files to
disks.