JurkOS

JurkOS is an independent, minimalist "On-the-Go" operating system targeting high-performance portability and bare-metal reliability. It is designed to be a lightweight, independent platform that prioritizes speed, efficiency, and a direct user-to-kernel relationship.

+---------------------------------------+
|                                       |
|            _______________            |
|           |_______________|           |
|                 ||||||                |
|                 ||||||                |
|                 ||||||   urkos        |
|                 ||||||                |
|                 ||||||                |
|          ////   ||||||                |
|         |||||  |||||||                |
|          ||||||||||||/                |
|           \_________/                 |
|                                       |
+---------------------------------------+

Did you know?

JurkOS actually has a smaller memory footprint than Tiny Core Linux. 16MB vs 28MB on 32-bit boot. Someone tell the "Tiny" guys they might need a new name... ;)

Project Target & Roadmap

The primary target of JurkOS is to provide a unified, persistent environment that remains consistent across different hardware architectures (HDD, SSD, and NVMe). Currently, the system supports 32-bit and 64-bit x86 architectures. Future updates will introduce ARM support to expand the ecosystem further.

Minimum System Requirements

CPU: 32-bit or 64-bit x86 Processor
RAM (32-bit): 16 MB – 24 MB
RAM (64-bit): 32 MB – 48 MB
Storage: 512 MB USB Flash Drive (Bootable)
Firmware: Legacy BIOS (MBR) Support

WARNING: UEFI IS NON-SUPPORTED! JurkOS requires Legacy BIOS mode to boot.

While this is an early release and not all hardware is compatible yet, future updates (1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9 Alpha) will focus on expanding hardware compatibility and feature sets.

The goal is for JurkOS to become a fully usable OS capable of reviving old computers, blending high-performance utility with the spirit of a fun, independent project. JurkOS currently outperforms Tiny Core Linux in memory efficiency, achieving a smaller boot footprint for both 32-bit and 64-bit architectures ;)

This Alpha release serves as the foundation for a fully independent ecosystem, focusing on a specialized C-based kernel shell and deterministic storage management.

Internal Architecture & Boot Sequence

JurkOS utilizes a unique multi-stage boot process and custom initialization logic to achieve hardware-independent persistence on a standard USB flash drive.

1. The Deterministic Bootloader (GRUB)

JurkOS uses GRUB in Legacy BIOS mode (MBR). To avoid the "Device Name Lottery" (where a drive might be /dev/sda on one PC but /dev/nvme0n1 on another), the build process injects a custom **Disk Signature** at offset 440 of the image.

The hex bytes \x78\x56\x34\x12 are written to define a fixed ID.
The Linux kernel is then instructed via GRUB to mount PARTUUID=12345678-01.
This ensures that no matter where the USB is plugged in, the OS always finds its root partition.

2. The Init Hand-off (PID 1)

The Linux kernel loads into RAM and hands control to /sbin/main, which serves as the **init process** (the parent of all other processes). Since this binary is compiled statically in C, it requires no external libraries or loaders to run.

3. Surgical System Setup

Before the user can interact with the system, the init process performs several critical environment tasks:

Read-Write Remount: The kernel often mounts the root as read-only. JurkOS forces a remount in Read-Write mode to enable persistence.
Virtual Filesystems: /proc, /sys, and /dev are mounted to allow the OS to talk to the hardware.
mdev Population: JurkOS triggers BusyBox's mdev to dynamically create all hardware device nodes in the /dev directory.

4. Dynamic Storage Expansion

A standard 512MB image would waste the rest of a 16GB USB drive. On the first boot, JurkOS identifies the physical size of the host drive and calls resize2fs to grow the ext4 filesystem to fill the entire stick. This happens silently during the initial setup phase.

5. Encrypted Persistence

JurkOS uses a specialized directory structure at /encrypted/userlogin/ to store user data. Credentials are "encrypted" using a Base64 system scheme, and a setup marker file ensures that the OS "remembers" the primary user across different hardware boots.

6. The JurkOS Kernel Shell

The shell is a specialized C program that wraps the BusyBox ash kernel. It provides:

Custom built-ins like sysinfo and whoami.
Full support for pipes, redirects, and every BusyBox applet (ls, grep, vi, awk).
An automated directory management system that creates and navigates to the user's home folder (/home/[username]) instantly upon login.

How to Compile

This document explains how the JurkOS build process works and provides the necessary commands to generate your own bootable image.

1. Install Required Tools

Before building, ensure your WSL/Linux environment has the following tools installed:

sudo apt update && sudo apt install -y gcc-multilib grub-pc-bin parted e2fsprogs

2. Build the Image

Navigate to the project root and run the following command:

gcc -static iso/sbin/main.c -o iso/sbin/main && truncate -s 512M jurkos.img && parted -s jurkos.img mklabel msdos mkpart primary ext4 1M 100% set 1 boot on && printf "\x78\x56\x34\x12" | dd of=jurkos.img bs=1 seek=440 conv=notrunc && DEVICE=$(sudo losetup -Pf --show jurkos.img) && sudo mkfs.ext4 -L JURKOS_ROOT ${DEVICE}p1 && sudo mkdir -p /mnt/jurk_tmp && sudo mount ${DEVICE}p1 /mnt/jurk_tmp && sudo cp -a iso/. /mnt/jurk_tmp/ && sudo grub-install --target=i386-pc --boot-directory=/mnt/jurk_tmp/boot $DEVICE && sudo umount /mnt/jurk_tmp && sudo losetup -d $DEVICE && echo "JurkOS 1.0 Alpha: Build Success."

3. Flash to USB

Once the build is complete, use ImageUSB to flash the jurkos.img to your physical USB drive.

Enjoy your fork! ;)

How to Flash

Flashing JurkOS correctly is essential to maintain the read-write persistence of the operating system. Standard ISO burners (like Rufus in ISO mode) may mount the drive as read-only, which will break JurkOS functionality.

Recommended Tool: ImageUSB

We highly recommend using ImageUSB by PassMark Software. ImageUSB is great for this type of project shout out to passmark software to making this great tool of my needs.

Steps to Flash:

Download and run ImageUSB.
Select your target USB drive from the list.
Select the 'Write image to USB drive' action.
Browse and select your compiled jurkos.img.
Click 'Write' and wait for the process to complete.

Once finished, your USB will have the exact same filesystem and partition structure as the image, ensuring it remains fully writeable and ready to boot.

Running in a VM (QEMU)

You can test JurkOS in a Virtual Machine before booting on bare metal. We recommend using **QEMU** for its powerful hardware emulation and serial redirection capabilities.

Testing with Physical USB

To boot JurkOS in QEMU using your actual flash drive (while maintaining persistence), follow these steps on Windows:

1. Identify your USB Drive

Open CMD as Administrator and run:

wmic diskdrive list brief

Look for your USB and note the DeviceID (e.g., \\.\PhysicalDrive1).

2. Launch QEMU

Run the following command (update PhysicalDrive1 to your drive number):

qemu-system-x86_64 -m 512 -device usb-ehci,id=usb -drive if=none,id=stick,format=raw,file=\\.\PhysicalDrive1 -device usb-storage,bus=usb.0,drive=stick -serial stdio

Key Features explained:

-m 512: Allocates 512MB of RAM to the VM.
-serial stdio: Bridges the JurkOS kernel console directly to your terminal. You can type and see logs in your host CMD!
format=raw: Ensures QEMU treats the USB as a raw physical disk, enabling persistence.

Common Problems

What Do I Do I Am On Linux Not Windows!

If you are using Linux and cannot use ImageUSB, we recommend using USBImager. It is a lightweight, open-source tool that performs reliable bit-for-bit flashing and is available for Linux, Windows, and macOS.