The little book about OS development

https://littleosbook.github.io/

by ibobev • 1 year ago

370 50 1 year ago

littleosbook.github.io

_mlbt• 1 year ago

Thank you! This looks like a great resource on the topic.

I wish I still had the source code for the “OS” I made as a teenager. I got as far as writing an MBR boot loader, switching to protected mode, displaying characters on the screen, and keyboard input. I highly recommend it if you’re looking for a fun challenge.

shpongled• 1 year ago

Writing my own "OS" (read: mostly copying from the OG Bran's Kernel Development Tutorial [1]) was also a formative experience for me as a teenager. Really great way to learn systems programming and what goes on under the hood!

[1] http://www.osdever.net/bkerndev/Docs/gettingstarted.htm

qingcharles• 1 year ago

Ha! Same. Lost the code too. It was fun actually booting something into bare metal. This book helped a lot:

https://www.amazon.com/Developing-32-Bit-Operating-System-Cd...

furkanonder• 1 year ago

The book is good. I wish they would look at the issues on GitHub, there are some things that need to be fixed. The last commit was 10 years ago.

roywashere• 1 year ago

There is an active fork here: https://ordoflammae.github.io/littleosbook/

fragmede• 1 year ago

Speaking of OS development, games make learning fun. I had the idea of making a game to teach operating systems while taking a journey through the history of computers. The player would play the part of the process scheduler and interrupt handler, starting on a single CPU system with very limited RAM, before growing to SMP systems then maybe getting to multi-system distributed computing platforms that we have today.

markus_zhang• 1 year ago

I have thought about making a game or a Fallout 3/4 mod in which the player needs to assembly pieces to repair a broken vintage computer before the nuclear war, and then search for some manuals and write programs to solve quests.

SoothingSorbet• 1 year ago

That sounds fun. I tried to design an assembly game once, but found I lack the creativity to design puzzles/goals that are not just "implement this common algorithm in assembly language". The idea of bootstrapping a PC from virtual firmware and writing an OS sounds nice, though.

ignoramous• 1 year ago

...to teach operating systems while taking a journey through the history of computers. The player would play the part of the process scheduler and interrupt handler, starting on a single CPU system with very limited RAM...

Something similar by Ben Eater (not with game development, though): https://youtube.com/playlist?list=PLowKtXNTBypFbtuVMUVXNR0z1...

vibrantrida• 1 year ago

There are two Japanese operating system development books I wish have English translations because they take you as far as getting a graphical environment with windows working [0], one of the books is even a 30-days challenge of sort [1].

Here is someone's take on MikanOS [0] https://github.com/uchan-nos/mikanos

And another one on 30-days Homemade OS [1] https://github.com/kamaboko123/30daysOS

An attempt to translate "30-days Homemade OS" [1] to English but it didn't get far https://github.com/handmade-osdev/os-in-30-days

I do not know of any English book nor article that go this far, except Fusion but the graphical environment chapter is not done yet [2]

[0] https://www.amazon.co.jp/dp/4839975868 - MikanOS

[1] https://www.amazon.co.jp/dp/B00IR1HYI0 - 30-days Homemade OS

[2] https://0xc0ffee.netlify.app/osdev/ - Fusion, an OS made in Nim

khaledh2• 1 year ago

Fusion author here. I haven't abandoned the project, and I do plan to complete it, including a graphics subsystem and a network stack. I'm currently trying to crack a tough nut, which is efficient zero-copy IPC using message passing over channels with a shared heap. This is a fundamental piece that will be used to communicate between different components (both within the kernel and across kernel-user space). Once I have a proper implementation, I expect the pace to pick up.

And of course I will document everything as I make more progress.

warangal2• 1 year ago

Are you trying to do this message passing using Nim channels ? For my use-cases, i always had to resort to just passing `pointers`, to prevent any copying, most of time i just divide the problem to use independent memory locations to write to avoid using locks, but that is not general pattern for sure. For read only purposes i just use `cursor` while casting to appropriate type. If you find a useful pattern, please share.

xmprt• 1 year ago

My favorite OS book (less about development and more about how it works) is Operating Systems: Three Easy Pieces. Free in HTML and PDF form but they sell a printed book as well. https://pages.cs.wisc.edu/~remzi/OSTEP/

drudolph914• 1 year ago

just got recommended this and read a good chunk of it! it’s a great read

joshgachnang• 1 year ago

Ahh my favorite professor and favorite class at UW. Remzi is great.

checker6592• 1 year ago

Best part is that it comes with references to all the classic papers and sources.

zelphirkalt• 1 year ago

A little (ha) bit of confusion with "The Little ..." series, with that title.

netbsdusers2• 1 year ago

Unfortunately this book has the classic fault of osdev tutorials: lots of talking about x86 minutiae, very little osdev. X86 minutiae is not osdev. It is a vanishingly small portion of what even a basic OS has to deal with.

01HNNWZ0MV43FF• 1 year ago

I wonder if I could learn anything interesting by making a user space machine agnostic os using some VM like wasm that allows for preemption

PhilipRoman• 1 year ago

https://github.com/rswier/swieros is a cool project that uses it's own VM (with a C compiler included). I was surprised by all the capabilities it has.

pjmlp2• 1 year ago

For sure, all Xerox PARC famous OSes are kind of VM based for example.

The compilers generated bytecode, and the CPUs were microcoded.

So the first boot phase was to load the microcode into the CPU, and then boot into Smalltalk, Interlisp-D, Mesa, Cedar environments.

There was a project that tried to be a future Amiga OS replacement that was also bytecode based with JIT,

https://news.ycombinator.com/item?id=9806607

Inferno with Limbo, another example, get wasm to replace disVM role.

Or like ART on Android, and so on.

Ah, IBM i (née AS/400) is also bytecode based with a JIT on the kernel.

Lots of examples out there, UNIX is not the only way.

dokyun3• 1 year ago

It would be great if there were more hobby OS resources targetting something other than X86. It is common and everything, but all the bootstrapping and device cruft involved isn't something you should need to get in your head, and 386 assembly by itself is terribly frustrating and obtuse to write by hand. I think most people might be better off starting out with a RISC microcontroller. There isn't nearly as much bullshit involved between getting a running kernel and talking some simple serial, and you can get an instruction set reference, assembler manual, and processor datasheet that will tell you everything you need to know. And it's easy to have fun hardware hacking that way too, making your own peripherals and such.

qwerty59• 1 year ago

You mean something like this: https://operating-system-in-1000-lines.vercel.app/en/

anta403• 1 year ago

Perhaps this one: https://github.com/mit-pdos/xv6-riscv ?

The old xv6 is x86-based and it's not officialy maintained anymore.

Or Xinu: https://xinu.cs.purdue.edu. There's a BeagleBone (ARM) port.

junon• 1 year ago

Honestly here's how you do e.g. ARM:

- Get multitasking working in x86 since there are a ton of guides for that. Learn OSdev concepts.

- Read the ARMARM. It's many thousands of pages of dense technical material, nearly everything you need to get started. The only parts it doesn't cover are boot media/formats and peripherals.

There aren't good resources for ARM osdev because the environment is not standardized at all. ARM chips are used everywhere and you're often targeting specific boards, not chips. Writing the ARM-specific stuff is only half the battle.

quotemstr• 1 year ago

People talk in hushed and revenant tones of SICP despite it having little to do with modern computing architecture. Perhaps x86 is still a great way to cut one's teeth.

charcircuit• 1 year ago

The issue is not that x86 is mentioned. It's just that there is a lot more to an operating system than just getting code running on a CPU.

RPC, the input stack, the graphics stack, the network stack, audio, profiling, telemetry, scheduling, UI toolkits, security, service management, application management, etc.

If you want to learn these things you will need to read the documentation and source code for other OSs.

nukem222• 1 year ago

X86 also has little to do with modern computing architecture. That's just the ISA; it's not going to help you solve pipelining or cache issues inherent to the data flow.

Wishing x86 on students is sincerely such a sadistic act. Just pick an arbitrary isa that's easier to reason about (read: basically anything after 1990 not designed by intel) and stick to it.

dist1ll• 1 year ago

True. I'm guessing it's the same reason that lexing and parsing are the focus of many langdev guides, despite being amongst the smallest/simplest parts of the compiler. I guess it makes sense, since those topics are the entry point into the field and at some point your learning is mostly self-directed.

initramfs2• 1 year ago

Without knowing much about the type of OS this book is, I imagine that there a lot of architectural aspects of x86 are considered "standard" to many of the x86 OSes out there. I hear a lot about code density in the x86, MIPS, and SH-2, compared to a lightweight RISC processor. Or, the book glazes over some of the more universal aspects of OSes, to address specific features of x86.

egl2020• 1 year ago

I don't find the x86 minutiae objectionable. If you want to build or even just understand an OS that runs on real hardware, you will have to deal with processor and hardware minutiae, and this gives one example of what you might encounter and how to deal with it.

netbsdusers2• 1 year ago

For most OSes the amount of code that actually deals in processor minutiae is really quite small. Portable logic makes up the majority. Maybe an exception can be drawn for some very particular OSes like DOS or Windows 9x.

So you read a tutorial and it spends about 90% of its time talking about an area that really isn't that interesting compared to other areas. I just don't think that's very compelling at all.

I say this having my own hobby OS which I've ported to four architectures (m68k, amd64, aarch64, riscv). At the moment I'm working on a TCP/IP stack which has been really enjoyable and I've learnt a great deal in doing this already. Other fun areas have been virtual memory and page replacement, designing asychronous I/O facilities, and IPC mechanisms, as well as appropriate synchronisation for each (synchronisation alone is a very deep topic, and there's considerable scope for innovation with techniques like safe memory reclamation.) Others may differ, but in these I find a lot more of interest than x86 minutiae.

rocky_raccoon• 1 year ago

I love osdev. I don't know what the end game is for me, but there's something really cool about being able to just create... whatever I want. It all sort of clicked for me when I was able to get some basic x86 interrupts and syscalls working. Once you get the syscalls going, the world is your oyster!

Seriously, I would highly recommend tinkering around with a hobby OS. I used it as an opportunity to learn Rust and I got more than I bargained for. Now, I feel somewhat comfortable in Rust AND I can throw more double and triple faults than most people in the world.

endorphine• 1 year ago

Did you use a book or similar resource? I vaguely recall there was some book about implementing an OS in Rust.

ibobev• 1 year ago

Here are some other tutorials about operating systems development including some in Rust programming language: https://github.com/bobeff/programming-math-science?tab=readm...

hedonhermdev• 1 year ago

https://os.phil-opp.com/

This one?

checker6592• 1 year ago

Have you considered making your own CPU core in an FPGA and running your OS on it?

(Oysters all the way down, I know)

Rochus• 1 year ago

Even Wirth had good fun with this: http://www.projectoberon.net/

initramfs2• 1 year ago

Now, where's the instruction manual for the little red OS book? https://en.wikipedia.org/wiki/Kylin_(operating_system)

vishnuharidas• 1 year ago

This took me a nostalgic dive back to 2000's when a website called planet-source-code.com was popular among the developer community. It had hundreds of mini operating systems written by members. Most of them were written in C/C++ and Assembly for the bootloader, compiled using Mingw32, and booting from a regular Floppy disk.

pjmlp2• 1 year ago

Since everyone is plugging their favourite alternatives, I am still a big fan of Project Oberon, it may be not fit for purpose on 2025 computing, however it is a tiny graphical based OS, written in a memory safe systems language, with enough content to learn about OS development.

https://www.projectoberon.net/

The little book about OS development

Related Stories