I would start with a clone of Android, and redesign anything that got in the way of ultra low latency work, and make it less locked down. The storage access framework would go away.

I would add scripting and such to make it a better platform for servers.

I would have SSH, but I'd probably get rid of Bash completely in favor of one of the new modern shells. Or perhaps I'd have a pure logicless command prompt.

Most likely since we can do unlimited NIH here, I would aim for Dart as the system scripting language and add some JIT and caching to make it fast to compile, if I didn't just go with Python.

I'd have Ansible included natively, modified so that playbooks were a locally executable type like a shell script, so that random oneoff backup scripts and the like could be totally declarative.

Then I'd make a point to have a strong focus on not needing separate images for different hardware.

I would probably focus on RiscV on the assumption it will get big by the time that it was all finished, but I'd be sure to have strong ARM support.

I would probably get rid of "Everything is a file" completely. I'd have a stripped down dbus like thing for talking to devices. Everything is an object.

I would very aggressively hunt down and destroy anything that requires imperative modifications.

There would be a standard format for config files, where they go, and how different files override each other. Program defaults, os specific tweaks, and ram runtime values supported.

In fact, my package management would probably be based on a list of files describing what was wanted. Add a file that says I want apache, with this config setup, and the manager detects it and knows to install the package.

If you need to edit a system file, rather than add a layered override, there's a problem. If you need to ever swap out a core package, there's a problem.

This would be an extreme cattle not pets OS, designed for zero tinkering, just copy some files over and you're running.

Packages would always have everything they need to clean reinstall stored on disk.

Offline installing packages is done by copying a package file to the cache dir, then adding its config to the wanted list. You can do it in a disk image. All needed actual setup will happen at next boot.

No true containers. Instead you have apps like Android. You have API levels with everything you need, that is your standard base to build on.

Since servers need real databases sometimes, "make me a postgresql database" would be part of the OS API.

Networking would be fully mesh-first. You'd get a Yggdrasil-like IP address, with a built in firewall that blocks incoming connections. All software would be aware that these addresses are secure even without HTTPS.

And nothing would ever unnecessarily write to disk. There would be support for battery backed ram, and if available logfiles, nonsense like saving the last position of a window or what the browser was doing, would go there. It gets snapshot when you shut down.

Nothing would ever touch disk except stuff that the user actually would be upset to lose.

Everything would be Rust rather than C, aside from existing legacy stuff. Nothing else in its class seems to have that level of dedication to safety above everything else. Crap software is easy, unbuggy software is what's hard, so we should use a language that focuses on the hard part, not on banging out random MVPs, you can do that in just about any language already.

Everything should just work. Everything should be standard and consistent. And it should protect the hardware and be able to run for 30 years on a cheap eMMC.