Skip to content
A 64-bit SMP-safe kernel for the PC architecture.
C Assembly Python Makefile C++
Branch: master
Clone or download

Latest commit

Fetching latest commit…
Cannot retrieve the latest commit at this time.


Type Name Latest commit message Commit time
Failed to load latest commit information.


* What?

Cute! is a 64-bit SMP-safe POSIX-compatible kernel for the PC architecture.

It's 'cute' in the sense of having the source code as simple and fun to
work with as possible, hopefully without sacrificing performance.

Throughout this project, a huge number of questions were (and are) asked
to the great people at #osdev. Special thanks to:

	- Brendan Trotter (bcos), <>, the BCOS project
	- Travis Geiselbrecht (geist),

* Navigation:

To begin your way throughout the kernel source, I'd recommend checking
the freestanding isolated parts first. Begin with the `lib/' folder,
which includes optimized C string methods, type-generic linked-lists,
spinlocks, a printf() implementation, etc.

Most of the kernel heavily-used idioms are included in 'kernel.h';
it'll be handy to have it open while checking the rest of the source.

This kernel source is tracked by 'git' from day 0: if you'd like to
know how to write a bootloader and a kernel from scratch, the git
history (with its carefully written commit logs) should be very

By now, you can go anywhere. ALWAYS check a module's header file
BEFORE checking its code. Due to compilers inefficiencies [1] and C
parsing semantics, a lot of details are put in *.h.  Comments in the
*.c files also assume reading such headers FIRST, unless otherwise

[1] To be fixed by GCC-4.5 `link-time optimization': constant folding,
    code inlining, and further analysis across separate object modules.

	- this file.

	- early bootstrap code: a 512-Kbyte bootloader, assembly for
	  jumping to C, code to jump to 'real-mode' and return back,
	  the SMP trampoline, etc.

	- library: as stated above, freestanding components like
	  C string methods, linked-lists (for stacks and queues),
	  spinlocks, a printf(), etc

	- memory management: dynamic memory allocation and virtual

	- device drivers: interrupt controllers, timers, keyboard,
	  inter-processor interrupts (local APICs), etc

	- the rest: context switching, thread scheduling, BIOS table
	  parsers, IRQ handling, system-wide panic(), etc.

	- userspace tools: Python-2.6+/3.0+ programs that generate
	  gnuplot scripts out of the kernel scheduling statistics.

* Influences?

One of the MAJOR goals of this project is examining the current literature
of Operating Systems in the process:

	- The page allocator is influenced by SVR2 buffer-cache lists,
	  with tweaks for zoning and PC's sparse physical memory.

	- Dynamic memory allocation uses the McKusick-Karels algorithm
	  originally found in 4.3-BSD.

	- Overall kernel coding style and APIs are heavily influenced by
	  Linux-2.6. I used that style in the past, and I love it.

	- The scheduler MLFQ parameters are taken from Solaris, with
	  influences from the FreeBSD ULE (2.0) scheduler.

* Books?

Beside the datasheets, specifications, and research papers saved
in our `references' git repository [**], below books proved to be
tremendously helpful:

	- M. Bach: `The Design of the UNIX Operating System', 1986
	  That book is __perfect__ for understanding the basics.

	- M.K. McKusick and G.V. Neville-Neil: `The Design and
	  Implementation of the FreeBSD Operating System', 2004

	- J. Mauro and R. McDougall: `Solaris Internals, Core Kernel
	  Components', first edition, 2000

	- U. Vahalia: `Unix Internals, The New Frontiers', 1996


			--Ahmed S. Darwish <>
You can’t perform that action at this time.