Slashdot Mirror

I find myself wondering how I'm supposed to access memory-mapped registers "safely" when the idea of void pointers and uninitialized variables are the devil. How I'm supposed to write code that deals with bootstrapping a processor's MMU. How I'm supposed to write an interrupt handler when different processors have different requirements for ISR stacks.
Writing software in that domain isn't well suited to any tool that thinks it can define what "safety" is for all platforms.

Might want to check out Redox. I saw this mentioned elsewhere in the comments. I don't have any personal experience with it, but it looks like they've come pretty far.

PS: The concept behind Rust is to keep your unsafe areas clearly marked as such. Presumably not every piece of code needs to do unsafe things. The Linux kernel has over 10 million lines of code.

Try a couple Pascal ones such as Toro or Ultibo. Or try a couple of Rust ones such as Redox or Nebulet. OSDev is a good resource for operating system starting points in various languages. You can take one of their bare bones OS examples and build from there.

Either way Rust is a viable option providing the architecture is supported. Rust relies on LLVM to generate machine code so if LLVM supports an architecture then so potentially does Rust. It already supports a lot of architectures ARM, MIPs, x86 on Windows, Linux, OS X and a bunch of microcontrollers.

I'd also point out that at least one kernel HAS been written in Rust. I wouldn't seriously propose using Redox in its existing form, but it kind of pisses on the argument that even if we were talking about the kernel (and we're not) that somehow Rust is ruled out there either.

Not that this is an OS anyone uses but... https://www.redox-os.org/

Indeed, their Why MIT? page states:

"Open source should be open, for everyone."

Isn't that exactly the philosophy that led to creation of the GPL?

I think it's good that they choose a permissive license for their source code, but their reason for it, Why MIT? is just... someone is wrong on the Internet

The GPL is upstream-centric, the MIT license is downstream-centric. We happen to prioritize downstream more than upstream, since downstream is what really matters: the userbase, the community, the availability.

It is the GPL that is downstream-centric and MIT that is upstream-centric. The GPL was designed to ensure that the entire program, source code, and ability to use it, are available to the userbase and community. The MIT license is primarily about avoiding liability, so anybody upstream of the userbase has greater privileges than the community.

I wish them well, but it’s a hindrance when they get the community aspects so wrong.

So, on their flame page of "why we rulez and you dr00lz" page, they have TODO - rewrite this.

So, you expect to do a full OS, take over the world, and you can't even finish a c.300 word rant. Sure....

Besides running on PCs, BSD and Linux are the core of iOS/watchOS/tvOS/macOS and android. We're talking billions of devices here. I'd be interested to know what they call a failure. If you have one of these "failure OS"s in your pocket, you may reconsider your zealotry.

Redox is based on a microkernel: http://www.redox-os.org/book/b... They seem to be emphasizing a very small number of system calls, and making "everything a URL" (instead of everything a file): http://www.redox-os.org/book/b... I'm skeptical this will get very far, but let 'em try!

Redox is based on a microkernel: http://www.redox-os.org/book/b... They seem to be emphasizing a very small number of system calls, and making "everything a URL" (instead of everything a file): http://www.redox-os.org/book/b... I'm skeptical this will get very far, but let 'em try!

At first glance it looks like a monolithic kernel.

Pretty glancing glance you've got there:

Redox's kernel is a microkernel. The architecture is largely inspired by L4 and Minix.

Nothing as far as a distro (or desktop environment) with 3D VR or AI comes to mind but there is innovation in OS going on. Not many have attempted to answer the OP, so here's my list. Others mentioned Qubes, Urbit, and Mirage.io, which reminded me of Nix OS and HaLVM.

Both innovative and seems daily-driver ready:
1. Qubes OS - https://www.qubes-os.org/ - Linux distro that runs a Xen hypervisor to contain every app (including Windows ones) away from the desktop environment
2. Haiku OS - https://www.haiku-os.org/ - Tiny (under 200MB installed), Non-Linux that is binary-compatible with BeOS, nice understated GUI that is bland but usable
3. ReactOS - http://reactos.org/ - Win32 compatible open source OS, very active development scene working toward full NT kernel ABI compatibility. Seems stable enough to be a daily driver but hardware support is lacking
4. PC-BSD & freeBSD 10 - http://www.pcbsd.org/ http://www.freebsd.org/ - PC-BSD is a desktop distro of freeBSD 10 built for user-friendliness with automatic ZFS snapshoting and a nice graphical package manager, freeBSD 10 has a completely new package manager (pkg-ng replaces the 'pkg' binary)
5. Nix OS - https://nixos.org/ - Linux distro with innovative package manager promising atomic upgrades & rollback.

Innovative server-exclusive (ie no GUI):
5. SmartOS - https://smartos.org/ - Solaris + KVM + Docker w/ full Dtrace support. Claims ZFS as an innovation? Joyent is running a cloud of it
6. CoreOS - https://coreos.com/ - Linux distro exclusively for large Docker deployments. developing a suite of Go tools for datacenter management.

Innovative, but not ready for desktop use:
7. Redox OS - http://www.redox-os.org/ - OS written in Rust (rust-lang), which guarantees a lot of memory-safety, screenshots of desktop in 'News' section
8. Contiki OS - http://www.contiki-os.org/ - Linux distro for IoT embedded devices that claims an innovative network stack
9. Urbit - http://urbit.org/docs/user/int... - *nix distro with exclusively web-based userland, invite-only at the moment, doesn't seem like it will have a UI but that each user is the dev of their own interface
10. Mirage.io - http://mirage.io/ - Develop each app and compile into a single-purpose kernel to be run on some hypervisor
11. HaLVM - https://github.com/GaloisInc/H... - The Haskell Ligthweight Virtual Machine - which runs just the GHC on Xen, another 'build uni-purpose VMs' system