It’s less insane than you might think:

https://en.m.wikipedia.org/wiki/Singularity_(operating_syste...

I agree rust is probably better suited. Or Apple could make their own memory safe language. They’re clearly capable.

That's an interesting experiment, but that's all it is. The project relies on ASM/C/C++ to boot into a microkernel and to interpret and run the C#. But I suppose it would greatly reduce the attack surface of C/C++/ASM code.

I just wonder, for example, how a capable hardware abstraction layer would work in C#, interrupt handling, CPU and IO scheduling, etc.

Here is another experiment, this one being delivered into production,

https://www.wildernesslabs.co/

You mean Swift?

C#, Go, and Java all go in the same category (roughly)—they wouldn't work for kernel code. Rust will be a valid replacement for C++ kernel code in the near future, I'm sure.

Here's a POSIX kernel in Go, written explicitly to prove your point wrong:

https://github.com/mit-pdos/biscuit

https://pdos.csail.mit.edu/projects/biscuit.html

Where do you get that? Those have all been used in kernels, they work.

Also on another front Apple seems to have already enabled device drivers in user space: https://developer.apple.com/system-extensions/

Yes, you can use them to play around and experiment with OS-level stuff and even have some fun with it.

But you definitely cannot build a performant and robust kernel from scrtach with these languages.

> you definitely cannot build a performant and robust kernel from scrtach with these languages.

I think this is irrelevant (and less importantly, false). Its's fine to use eg se4l as a foundation, or as a incremental step even just have a safety focused driver runtime inside the kernel proper.

Sure they would, so much that there people doing it right now.

https://www.wildernesslabs.co/

https://labs.f-secure.com/blog/tamago/

https://www.ptc.com/en/products/developer-tools/perc

Writing the majority of a kernel in those languages is certainly possible.

Possible, perhaps, but feasible? Microsoft certainly had a go at it with the likes of Midori and Singularity, but these were met with the same fate that will likely befall any managed code kernel. While it's an honorable pursuit with certain merit, to produce a fully featured OS in this way -- without serious concessions -- is just not feasible.

Those projects died due to management politics from WinDev, nothing to do with capabilities.

So much that many of the System C# features are now in .NET 5 and other ones will eventually land on .NET 6.

Nope, some people are actually quite serious about it.

https://www.wildernesslabs.co/