I, Hacker
Intermittent neural activity

Renraku is a family of managed research kernels I've been working on
for around 4 years. Though the goals and implementations have changed
over the years, they're all designed to be highly reliable, fast,
portable, and flexible enough to keep up with the changing needs of
today's technology.


Initially, Renraku (known as Colorblind at the time) was simply an
experiment. Inspired by Unununium in its Python era, I saw the value
in kernels being very high level. Ease of development, in the hands
of the right hacker, could mean vast improvements in a short period of
time. With this in mind, I set out to build a prototype. I built a
number of revisions on top of existing OSes, but in the end I couldn't
get the design I wanted, so I shelved the project, but never forgot
about it.

Shortly thereafter, I started playing around with the development of
Talk, an L4-inspired microkernel. It was very simple (written in
straight x86 assembly) and was intended to see how small such a
microkernel could be without sacrificing critical functionality. It
didn't get far due to not having enough time, but while designing the
set of base services and their interactions, it made me think back to

The project sat on the back burner for about a year and a half, until I saw
MSR's Singularity project, some time around 2006. At this point, I
started seriously thinking about what I want in a future OS and how I
can go about implementing it. I've since written a few prototypes in
a mix of C# and Nemerle, and the goals have largely solidified.


High level:

  • Pure managed code. No C, no assembly not generated by the compiler, no pointer access outside of the object manager and certain parts of the kernel.
  • Everything is an object. Turtles all the way down.
  • Single address space and no userland. Everything is ring 0.
  • Completely network-transparent objects.
  • Object store instead of a traditional filesystem.
  • System-wide orthogonal persistence.
  • All components reloadable at runtime.


  • Pure .NET. Currently playing around with Boo for it, due to their new macro syntax and functionality.
  • Ahead of time compilation for the base services.
  • Object model implemented on top of itself. That is, the object model is implemented in terms of value types and pointers, and the compiler has intrinsics for object model instructions to auto-call the implementation.
  • While designing/implementing any feature, now is always better than later. Always, always, always go for the practical, simple route before considering a more complex one.


This is a rough roadmap of the implementation of Renraku. How far
this ends up going is really up in the air; it could go to the end,
it could be abandoned half way and rewritten again. Eventually, I'd
love to see these ideas come to fruition, though.

  • Initial CIL->x86 compiler. Uses the actual stack to execute code, as optimizations can be added later.
  • Initial memory/object manager. Nothing fancy, just enough to get things up and running.
  • Begin implementing the .NET BCL. Get basic string manipulation and collections working.
  • Implement keyboard support.
  • Implement a basic shell. Allow object inspection/manipulation.
  • Implement initial object store.
  • Implement basic networking and network transparent objects.
  • Build framebuffer support and a basic GUI library.
  • Implement the dependencies of the Boo, C#, and Renraku compilers.
  • Implement a basic terminal and REPL.

Once these things are implemented, development should be able to
progress very rapidly. There's just a lot of work to do to get there.

What would you want to see in a future OS? What would you like to see
go away? What new UI paradigms ought to be used? I'd love to hear
feedback on this, as there's simply a lot to think about.

Happy Hacking,
- Cody Brocious (Daeken)