While that's true for mitigations, one system can be more secure than another by design

Things like an OS that's designed with sandboxing, more clean codebase that's auditable, permissions, ... in mind is more secure than an OS that later adds them as an afterthought

Or at least if added later they should be done properly

iOS and Android are way more secure than Linux (And no Android isn't just linux) cause they were designed in much later era with better security practices in mind

Even MacOS and Windows's security are objectively better than linux's even though they started with same security mindset, the problem is they are not open source

Secure from malicious app programmers (Unlike what other people think open source doesn't equate safe, even reputable essential ones can be malicious like recent xz one)

Secure from remote attacks and botnets (Only reason this haven't been a larger problem is because linux desktop users are too few to worth targeting, though that may change with rise of steam deck)

Physical integrity guarantee and protection against manufacturer while nice are very hard to get in current climate

proper sandboxing and permissions, auditable code and small attack surface as opposed to spaghetti code glued together that's impossible to audit, regardless of threat model those things are needed, even linux is moving in that direction (Though very slowly and very half baked like with flatpaks)

No good solution but easiest thing to do is System monitor resource usage (CPU, GPU, Memory) check it when programs are closed and system is idle

Captcha is probably unrelated to botnet, it can be from your browser (most privacy focused browsers like LibreWolf, Brave, Hardened Firefox get this captcha problem) or your VPN/proxy if you use one

I am not native English speaker so sorry for misunderstandment

I didn't say it's overall better

I said even though on base level OpenBSD is much more clean and secure than Linux it lacks or lags behind Linux in adding mitigations for security vulnerabilities

And there are far less eyes on OpenBSD so many vulnerabilities don't get discovered in first place

Any software can be malicious even essential ones just look at recent Xz vulnerability (And it was discovered by sheer chance), OS should have systems in place like proper sandboxing, permissions (Not half baked one like flatpak) ...

Any threat model tbh, your linux computer can be remotely used for botnet and you may not even find out (unlikely as linux is not targeted as much as windows simply because too few desktop linux users) Linux desktop's only advantage currently is obscurity but that may not remain the case with rise of popularity in Steam Deck

MacOS's security is great but unfortunately not open source

QubesOS's sandboxing/virtualization is way above whatever you can do on Debian

Both Kernel and userland

Android runs a linux kernel yes but is very far from normal linux distros, it almost alleviate all of problems with linux

Hurd kernel's concept seems solid but it doesn't look like actively developed?

OpenBSD might be best choice as you say at least until Genode or something similar become useable

As I mentioned in post Kicksecure plans to harden Linux but is not there yet, For virtualization and containerization there is QubesOS but still that doesn't seem ideal and it requires some beefy hardware

Their basic premise seems solid, but is it actively developed? it seems to go through long periods of inactivity

I didn't know Nintendo subsidize their hardware like Sony and Microsoft, as their hardware seemed overpriced to me for what they offer

And small percentage of gamers are on PC and even smaller percentage would emulate games, even without exclusives most casual gamers seem to prefer consoles so I think Nintendo is overreacting in that aspect though for pirating/jailbreaking switch devices themselves yeah maybe that's why Nintedo care

More info on Atmosphere 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/

"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."

More info on Atmosphere 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/

"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."

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.