Show HN: A new hobby OS from “scratch” in C#

https://github.com/amaneureka/AtomOS

by amaneureka • 9 years ago

310 63 9 years ago

github.com

adzm• 9 years ago

This sounds interesting but is really lacking details. Though... now I wonder what happened to singularity / midori.

amaneureka11• 9 years ago

I am really sorry about lack of details on page. I am working on it and soon add more detailed documentation.

Meanwhile You can try building it and play around with source.

https://github.com/amaneureka/AtomOS/wiki/Build-Environment

ifdefdebug2• 9 years ago

according to the license headers in the source files I am not even allowed to copy the thing to my computer...

edit: ok, found the project license (bsd) but you really should update those headers...

jongalloway2• 9 years ago

Would be nice if there was an ISO or cloud-installable VM image available. I've distributed "live cd" VM ISO's via legal torrent sites, which is a little hassle to set up but will make it a lot easier for people to get involved.

pjmlp7• 9 years ago

Aren't you aware of Joe Duffy's blog?

http://joeduffyblog.com/

https://www.infoq.com/presentations/csharp-systems-programmi...

Basically both projects achieved their goals, but Midori eventually was killed by management, even though they got an usable GUI desktop running with some core applications.

Some of their decisions influeced async/await design in C#, the AOT compilers to native code in WP 8.x and WP 10, some of the new features for C# 7 and others planned for future versions.

ifdefdebug2• 9 years ago

anybody knows if the scoped modifier is going to make it from m# into c#? that would be great...

zamalek• 9 years ago

There's also MOSA[1] and Cosmos[2]. MOSA is focusing more on the compiler/runtime, while Cosmos is doing just enough to get a working OS. Both are pure C#, it looks like Atom is too.

[1] https://github.com/mosa/MOSA-Project [2]: https://github.com/CosmosOS/Cosmos

amaneureka11• 9 years ago

Yeah. And I managed to take it to the next level with dynamic executable loading and SVGA drivers.

mihular4• 9 years ago

But why not join forces with cosmos-instead of many half done OS we could have one functional? Were there any particular reasons?

skybrian• 9 years ago

I'm surprised C# is suitable for this. How does that work?

amaneureka11• 9 years ago

Because It is not possible to run C# executable without .NET framework. I had to work on a compiler first. Source: https://github.com/amaneureka/AtomOS/tree/master/src/Compile... Which works on the top of Microsoft's IL Builder. Then it add compiler stubs to support .NET code and convert code into native x86 assembly. The assembly file is then passed through NAsm and proper linking chain to produce final Kernel ELF binary. Build.sh produces an ISO image which can be used to boot OS in either virtual machine or on real hardware.

I explained it here: https://www.reddit.com/r/programming/comments/5xlmc6/a_new_h...

pjmlp7• 9 years ago

Good luck with the project, we already have too many kernels written in straight C.

Only thanks to this kind of work one can prove it is possible.

djsumdog• 9 years ago

That's a lot-o-work! Pretty impressive man. I think projects like this are awesome.

willvarfar• 9 years ago

How does that work? Surprisingly well :)

Many hobby kernels (as mentioned in these comments) have used C#, as well as bleeding-edge research kernels e.g. Microsoft's Singularity project: https://en.wikipedia.org/wiki/Singularity_(operating_system)

nickpsecurity3• 9 years ago

Bleeding-edge was VerveOS:

https://www.microsoft.com/en-us/research/publication/safe-to...

It's legacy will be in their IronClad Apps. Look into those if you want to see how far they've gone. Also, Microsoft Research & HLL vs Nix and C in security are a gap that's ever widening. ;)

pjmlp7• 9 years ago

Haven't you heard of Singularity or Midori?

http://joeduffyblog.com/

https://www.infoq.com/presentations/csharp-systems-programmi...

There are quite a few OS projects written in system programming languages with GC, all the way back to Mesa/Cedar at Xerox PARC.

If you want to have an idea, check the Project Oberon book.

http://people.inf.ethz.ch/wirth/ProjectOberon/index.html

This is the 2013 re-edition, it was originally published in 1992.

bad_user• 9 years ago

Also a library for building special purpose operating systems (unikernels) in OCaml, which is actually used: https://mirage.io/

apotheon2• 9 years ago

Let's not forget other more recent stuff that still happened before AtomOS, like Redox. I seem to recall seeing a couple others recently as well, but for some reason I'm drawing a blank now. I think the big deal about this is mostly just that it's an effort outside of Microsoft to do this, and compile it to machine code rather than just use some kind of "higher order" OS that needs to run on top of something else -- and even there it's not unique, even if it looks more interesting than FlingOS (which is evidently just a new take on the "toy kernel/OS for teaching" idea).

contextfree• 9 years ago

Midori was still built on a C++ microkernel though.

ishitatsuyuki• 9 years ago

Not sure how it could deal with GC pause.

amaneureka11• 9 years ago

It does not. new operator internally calls Heap.kmalloc https://github.com/amaneureka/AtomOS/blob/master/src/Kernel/...

To free any object instance I have to call Heap.Free

flukus• 9 years ago

So random including random c# snippets would probably leak memory? I imagine it would produce an uncanny valley feeling.

kodfodrasz• 9 years ago

Nice, although I'd call the AssemblyAttribute EmitAssemblyAttribute, as the Assmebly word has its special meaning in the .Net world, and can potentially confusing (not to mention the assembly scoped attributes...)

amaneureka11• 9 years ago

Sure, Thanks :D

moon_priestess2• 9 years ago

[Removed to avoid distraction.]

naasking3• 9 years ago

Looks like a traditional kernel, which I think is a shame. High-level language-based operating systems have a lot more flexibility to enforce fine-grained abstractions rather than a traditional OS's coarse-grained abstractions.

For instance, memory safety is process-level in a traditional OS, but object-level in a programming language. So paging logic doesn't make as much sense here, since it would require a lot of expensive runtime support to make every object lazily loaded, not to mention the expense of the bookkeeping overhead to track which objects should be paged out.

This encourages a more event-oriented architecture where programs provide the kernel with continuation when requesting services. For instance, something like C#'s async/await operating at the kernel process level would be one possible approach.

amaneureka11• 9 years ago

I strongly recommend you to build the kernel once and check output assembly file. which should answer lot of your doubts like extra overhead of object loading. It's not exactly same how you are interpreting. I tried very hard in order to optimize the output code.

naasking3• 9 years ago

Are you saying this is not a traditional operating system design utilizing the MMU for memory protection? If it is, then everything I said is accurate compared to software isolation in an OS like Midori. If not, then you should really point that out because it makes your project much more interesting!

nickpsecurity3• 9 years ago

naasking is saying you could try different protection strategies since it's an experimental, clean-slate OS. User/kernel model protection is among the weakest models that only works with separation kernels such as seL4 or Muen. Tiny, tiny kernels. Let me give you examples of alternative, OS architectures and protection models to show what naasking likely meant by doing it different:

http://www-spin.cs.washington.edu/

Note: SPIN OS was written in safe Modula-3. Interesting thing about it was leveraging the language safety & a type-safe linker to allow code to be loaded into kernel for acceleration.

http://www.symbolics-dks.com/Genera-why-1.htm

Note: LISP machines were among most powerful machines ever created for developers. The language itself had code as data philosophy to change it at will. Runtimes had REPL, incremental compilation per function, AOT compilation, and live updates of code. Do a whole OS that way you get feature 7 along with debugging or linking ones on 8-12 page that no OS has today. I mean, single coolest thing your OS could do is allow debugging or updates of it in high-level code that somehow goes through compiler and right back into memory. The same HLL that users write the applications in.

http://www4.cs.fau.de/Projects/JX/

Note: The main paper on this page will tell you what this OS is about. The architecture tries to enforce POLA at a decent granularity with building blocks that are pretty easy to understand. Almost everything is safe. One thing worth copying is using different, garbage collectors for different apps or parts of OS.

https://en.wikipedia.org/wiki/MOSIX

http://encyclopedia.thefreedictionary.com/K42

Note: MOSIX was an OS I ran into when I studied supercomputers in the late 90's. The cool thing about it was how it turned a network of computers into a cluster that it automatically distributed jobs over. Treated them like one machine in a way that typically required low-level, message passing. K42 was IBM's attempt at building blocks for something similar using microkernels and hot-swappable components.

https://www.cs.vu.nl/pub/amoeba/amoeba.html

Note: Amoeba was a distributed, operating system. Each machine ran some code. The OS and apps were spread among them.

https://www.cs.ucsb.edu/~chris/teaching/cs290/doc/eros-sosp9...

Note: EROS was a capability-secure, microkernel OS with trusted networking and GUI stacks. Abandoned when Microsoft hired Shapiro. Capability model has strong properties for enforcing POLA but one must be clever to minimize overheads.

E language and capability model

https://www.combex.com/papers/index.html

Note: Embedding the capability model as constructs in the language, esp RPC's, can make for interesting abilities.

https://www.microsoft.com/en-us/research/publication/safe-to...

Note: Nucleus is literally stolen from a 70's-era mainframe that did same stuff along with Per Hansen. The idea is you wrap all the low-level stuff behind an interface that forces it used safely & consistently in above layers. Then, above stuff is easy to do in high-level language. The how of this has many possibilities. Safety enforced statically with type systems or Design-by-Contract (e.g Spec#); or dynamically with argument checks; or both.

nkkollaw• 9 years ago

No way to build on macOS..?

cd_cd• 9 years ago

This is fantastic. I have heard of a few projects like this. I'm guessing you're natively compiling the C# code. I'd love to contribute but I'd probably just get in the way. Good luck - a glimpse of the future perhaps.

dmarlow• 9 years ago

How is it different to https://github.com/FlingOS/FlingOS/ ?

Not trying to be difficult, I'm just wanting to learn more about your project.

apotheon2• 9 years ago

I see it at least has a better license.

SwellJoe2• 9 years ago

Linux has done pretty well with the "worse" GPL license.

SwellJoe2• 9 years ago

There is an OS named "Atomic" (it is a Red Hat project, so not particularly obscure), which seems pretty similar to "AtomOS" and "Atomix": http://www.projectatomic.io/

balajiarun2• 9 years ago

I see a lot of concepts simply borrowed from Cosmos, rewriting it and seeking copyright - Especially the IL2Native compiler is very similar.

balajiarun2• 9 years ago

Does your compiler handle generics?

amaneureka11• 9 years ago

Yes! https://github.com/amaneureka/AtomOS/blob/master/src/Kernel/...

_RPM• 9 years ago

commits messages like "Open Sourced!" annoying

udp• 9 years ago

I appreciate that this is a hobby project, but comments like this one in Kernel.cs:

     while (true) //Set CPU in Infinite loop DON'T REMOVE THIS ELSE I'll KILL YOU (^ . ^)

combined with things like your "How to contribute" section requiring that anyone wanting to contribute is "dedicated", are frankly going to put anyone off wanting to get involved with this. It also doesn't reflect well on your maturity as a developer.

BinaryIdiot• 9 years ago

I'm all for humorous comments, even if they're a bit flippant, but that comment just isn't funny. Though I've met some great people with a sense of humor that makes absolute no sense to me and that's just how it came off to me versus a maturity issue (but without my experience I could easily see having an identical opinion to yours).

The dedicated part though seems a little more ridiculous to me. Most people who may contributed may not necessary be "dedicated" or even like the project but just may want to help with someone. If I saw a project was looking for dedicated contributors I'd be less likely to contribute anything as I don't want to be married to someone else's project.

nialv7• 9 years ago

The "YOU" here might refer to the compiler, not the person looking at the code.

Animats• 9 years ago

Yet another "multitasking monolithic kernel based x86 targeting operating system" isn't that useful. Something new would help. A fast microkernel. A hypervisor that runs containers. A kernel with better security for IoT.

pjmlp7• 9 years ago

Being written in C# makes it useful, because in this industry we lack visionaries, and most only believe what is put in front of them.

jatins• 9 years ago

That looks good!

(P.S. turns out we are from same college _and_ school)

amaneureka11• 9 years ago

oh! what's your name?

Show HN: A new hobby OS from “scratch” in C#

Related Stories