JSD/OS: a tiny operating system for x86


The source is available on GitHub under a 3-Clause BSD license.

Creating my own OS was something that I’ve always wanted to do basically for as long as I’ve known how to code. Somehow it always seemed too difficult until one day I just decided to sit down and write one.

JSD/OS which either stands for “Jake S. Del Mastro Operating System” or “Jake’S Disk Operating System” or maybe even “Jake’s Software Distribution Operating System” is a tiny Pseudo Single-Tasking operating system for 32bit x86, which I have been developing on and off since 2014. The goal is to build an OS with a very small memory footprint, a fast file system and minimal overhead to allow user requests to be processed as quickly as possible, ideal for interactive applications. The system can run applications packaged in the ELF object format and has full support for memory protection via virtual address spaces.

The operating system is built in C & C++ with some help from 32bit x86 assembly. The plan is to move more towards C++ in the kernel & user space, except in the very early boot stages where C++ support is not yet available.

Currently only a command line interface is supported using commands that are familiar to both UNIX and DOS/Windows users. A GUI may come in the future and so might a more imaginative name.

What is Pseudo Single Tasking?

Basically it means that many processes can be running but only the one which has user focus is guaranteed to get any CPU time. Why? Because as a user I don’t really care about the system throughput, all I really care about is if the system feels fast.

This means that the active process (the one the user is working with) has a guarantee that it will never be preemptively interrupted by the scheduler, although it can be interrupted by the user (the user switches to a different task), if the active process is waiting for I/O, other processes can run but the scheduler is guaranteed to resume the active process as soon as that I/O is complete without running any other processes. In this way the scheduler is somewhat RTOS like, but obviously it doesn’t guarantee any particular time value for latency, rather just as fast as it can. Right now I call this algorithm CuFS (Conciously unFair Scheduling) as a play on the CFS (Completely Fair Scheduler) for Linux.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s