
Hobby kernel and userspace, built mostly from scratch - carlesfe
https://github.com/klange/toaruos
======
hvs
Back when I went to UIUC the SIGOps chapter had a "Roll Your Own Operating
System" series (mid-90's)[1]. I'm glad to see they are still doing interesting
things.

[1] Still available:
[http://www.acm.uiuc.edu/sigops/roll_your_own/](http://www.acm.uiuc.edu/sigops/roll_your_own/)

------
marknadal
This is amazing! I've been dying lately feeling an overwhelming sense of
disappointment with modern day OSs and their UX. To the point where I've
wanted to start to play around with making my own.

Could anybody point me in the right direction? I'm a NodeJS web developer
HTML/CSS guy. What would be the shortest/fastest path to me being able to
write my own entirely custom UX?

Preferably something I could do in HTML/CSS/JS and be able to run on a
desktop/laptop/phone. Thanks.

~~~
samwilliams
If you want to create your own complete graphical rendering system you could
look into writing a replacement for X11. You could look at the source of tinyx
to help you get started. Note that the 'tiny' x source is 5mb of plaintext.

You could also look at building a graphical tool-kit (think GTK/QT) that can
be used to render windows and their styling.

Finally, you could look at building a window manager with a bunch of
applications which look the way you would like it to. This is probably the
most achievable goal, but it also offers you the least flexibility with your
rendering.

A couple of other points: \- I would definitely recommend targeting a non-mac
*nix environment. My understanding of the situation is that on Mac and Windows
their is little support for external renderers and basically none for custom
window managers. \- Most people would consider JS is to be a pretty bad
language to write one of these systems in. You will be able to use JS as the
end user application programming interface if you like (a la Gnome 3), but you
will likely have a tough time writing any of the three systems mentioned above
in pure JS. HTML and CSS will likely only be useful for the front-end that you
expose to the end users.

Finally,

> What would be the shortest/fastest path to me being able to write my own
> entirely custom UX?

In the field of hobby OS/systems programming the 'shortest and fastest' route
is a very bad attitude to take. Building anything in this area takes time and
patience, if you skim on either of these you likely won't get far.

I hope this is helpful -- good luck! Sam

------
sand500
Is ToAru-OS a reference to raildex?

~~~
delluminatus
I would love that. But "to aru" also actually means something in Japanese,
which I would translate like, "there is an". Disclaimer: I definitely am not
an expert on Japanese.

It's actually kind of hard to translate concisely, IMO the phrase that best
captures the meaning of "ToAru-OS" is "There exists an OS". But it's kind of
awkward.

If we used the Raildex translation, ToAru-OS would be "A Certain OS".

~~~
byuu
Sorry for going off-topic here to the thread, but ...

As someone studying the language, can you explain what the と portion of the
name means? I am aware of the ある (有る) portion, "to exist", and that と is being
used here to represent a clause, eg "Xと言った" (X said), "Xと思った" (X thought).

But in this case, there's nothing _before_ とある, so why say と at all in this
case? Why not just say あるOS?

~~~
delluminatus
I think it's stylistic. The anime series (To aru majutsu no index) uses the
same style of "to aru <noun>" instead of "<noun> to aru". It reminds me of
Latin, where you can adjust the position of phrases in the sentence for
emphasis or rhythm.

Personally, I think of the "to" as emphasizing the specificity of the phrase,
if that makes sense. It's not just that "an OS", it's this _specific_ OS
that's being referenced by "aru".

~~~
byuu
Ah, most interesting. Didn't think you were allowed to ever move "X to <verb>"
to "to <verb> X", but great to know that this happens. Thank you for the
explanation!

------
yazaddaruvala
Anyone with this type of hobby kernel experience, how hard would it be to
build the "Ruby on Rails" or "NodeJS" of kernels?

If hard, why so difficult? I'm more referring to a theoretical reason, rather
than practical.

Practical Reasons: \- drivers are required \- C/ASM is hard (ie lack of
contributors) \- different hardware architectures need to be supported. That
part I get.

Why in theory can you not have an operating system framework that allows
people to "relatively easily" build a custom kernel (instead of using Linux)
the same way something like Go allows me to "relatively easily" build a custom
HTTP server (instead of using Apache)?

~~~
dschatz
You can look at OSkit as one attempt to do this. I think the overwhelming
reason its not common is that no one wants to build an OS. If they do it's for
the educational experience not practical use. This means hobbyists aren't
interested in just using a framework.

~~~
qznc
I am not sure what exactly is meant by "Ruby on Rails of kernel". Probably "an
opinionated framework to build your own kernel". In this case OSkit is
probably the best answer to the question. Maybe look at micro- and exokernels.

~~~
dschatz
I think another problem is that an OS is not analagous to a website, it's more
analagous to a web framework. And it's not like there are any framework
building frameworks floating around

------
StandardFuture
Hehe, I have talked to Kevin on irc before about his custom compositor. He
hangs out on the freenode irc channel #osdev sometimes, iirc. Really nice
dude. I am very surprised this hasn't already been submitted here before. :)

------
throwaway234
He would spend so much time in the UIUC ACM office working on that thing.
Pretty impressive for an undergrad ;)

------
jonasmalaco
I found the Bim editor interesting; particularity for the simplicity of its
implementation.

------
billconan
how does it provide the opengl driver?

~~~
lamacase
"The following external libraries and tools are retrieved during the build
process: ... Mesa - Implementation of OpenGL (only the software rasterizer is
available)."

From the readme

