Linux is run on basically all servers. What kind of security do you have in mind? Someone else already stated it, qubes and secure blue are good. Your text is rather vague, I don't understand what you are looking for.

I'm unsure why you think that Linux mitigations should apply to OpenBSD.

A different approach is to use a version of an OS that is read-only (immutable).

I noticed that you didn't mention ChromeOS.

Edit: Added immutable, couldn't think of the word.

GrapheneOS is just Android and (as far as i know) all Android versions use SELinux. Why not just use a basic distribution like Arch with SELinux?

Qubes OS is Snowdens daily driver, Fedora SecureBlue is also designed with security and privacy in mind.

I've not come across such a topic in a while; what security issues do you see with monolithic kernels that are not present in Microkernels? Other than the "more code so more bugs" part

Whew, there's a lot to unpack here.

First, microkernels being the future: This is a sentence that was said time and time again, but while microkernels definitely have some advantages in separating components which could yield better security, in practice it also introduces other security concerns, not present with monolithic kernels, mostly with the communication between the kernel services.

Second, about the no secure Linux distros thing: As many others have mentioned, there are security-conscious Linux distros, mostly the "immutable" distros. You can use Fedore Silverblue (or even better, SecureBlue) as a daily driver, with Flatpak for your apps. That way, your main OS is read-only, thus harder to infect and all system updates are signed and verified. Using Flatpak helps enforce permissions on apps in a manner similar to Android permission (you can deny an app the right to see your files, for example).

Third, I don't really understand what you mean by "Linux's security holes". Of course it's not bug free, but no kernel of this magnitude is. Also, GrapheneOS uses Linux as well, albeit with a hardening patchset, but you can also get that with desktop Linux distros. If you think Linux (being a monolithic kernel) is automatically less secure than microkernel and hybrid kernel based systems, take a look at Windows and macOS, which both use non-monolithic kernels, but most security experts will tell you that you're better off using Linux.

Fourth, about all the niche, mostly hobby OSes you listed: A big part of security is about having more eyes on the source code. Even if you write a kernel in a "safe" programming language, there will be bugs. Something as advanced as a kernel that's ready for daily desktop use and provides advanced isolation between processes is going to be so complex that you won't be able to see what bugs arised from the different parts interacting with each other. Safe programming languages make it easier to write safe code, but don't stop you from messing up the logic that defines what apps have which permissions. Your best bet is to stick to software that has had time to mature and had more people and companies look through it. Linux is regularly audited by all tech giants, because all clouds use Linux to some extent. If it's secure enough to isolate the workloads in Google Cloud, and Amazon's AWS, it's going to be secure enough for your desktop, provided you use it well (make use of it's security features and don't shoot yourself in the foot by disabling mitigations and the like). This is partly why I think the idea that OpenBSD is more secure than Linux is somewhat outdated. Yes, they advertise it as such, but it has seen much-much less auditing than Linux did in the cloud era.

Of course, there's nothing wrong with playing around with alternatives operating systems, just don't think you'll be more secure just because something is written in Rust, or is a microkernel. Those can help, but there's much more to security than the guardrails a programming language or software architecture can provide, especially with something as complex as a modern kernel.

Gnu Hurd

Qubes is not mentioned at all.

More info on Atmosphere (Open Source Horizon AKA SwitchOS) as I find it fascinating that an OS created for a gaming device got such tight security:

https://www.reddit.com/r/emulation/comments/hygtnx/mesosphere_opensource_nintendo_switch_kernel_now/

Quotes from Creator of Atmosphere:

It is a completely unique microkernel with a cooperative (non-preemptive) scheduler. The kernel is secure -- so far as I can tell (as a reverse engineer and hacker), it has zero security bugs. They throw out years of backwards compatibility (they're not POSIX/UNIX), and they really, really benefit from it from a security and modularity PoV. Horizon's the only meaningful RTOS with a microkernel that I'm aware of (other than Fuschia). Everything's in userland -- filesystems, gpu (and other device drivers). The OS is capability-based and conceptually all about lots of different processes/drivers ("system modules") that host microservices. The fact that Nintendo designed such a rock-solid, modular, custom operating system for their consoles fascinates me.

IPC is the hottest hot-path in a microkernel, correspondingly Nintendo marked every function involved in IPC as attribute((always_inline)), this was kind of a huge pain to reverse engineer as a result. In addition, Nintendo implemented "SvcReplyAndReceive" as a single system call that allows a microservice server process to reply to and receive a new message in one invocation. That said, there's actually less overhead than you think. Past of why FUSE is slower than a kernel driver for FS is because FUSE has to talk to the kernel to do filesystem stuff, so when you read a file you have your process -> FUSE -> kernel -> hardware. In comparison, on Horizon the kernel is completely uninvolved in filesystem management (it doesn't even have the sdmmc hardware mapped). Thus processes will do process -> FS system module process -> hardware.

In Horizon, everything is very distinctly not a file. There's no global filesystem paths the way that unix/linux have special /dev/whatever. Pipes don't exist in Horizon -- all IPC is done via the horizon ipc ("HIPC") protocol. UNIX/POSIX have stuff like fork() and child processes...but creating a process is an incredibly privileged operation in a capability-based operating system. Fork() is impossible to implement in Horizon, all threads are created via SvcCreateThread() instead. Child processes aren't a thing that exist.

I just read an older article about the black market using graphineos to create a supposed private phone to run drugs, however the FBI joined forces with two other countries to infiltrate a man in the middle attack and busted the drug ring. I think a private os is a pipe dream since you still need to get on the internet and as long as you’re online, you’re vulnerable.

• https://chimera-linux.org FreeBSD userland with Linux kernel and Musl C library.

• https://hardenedbsd.org

I don't know about OS development to chime in, but what outdated practices does RedoxOS have?