My ideal operating system

First considered in June 2024.

First published June 30, 2024.

Most recent meaningful update on March 17, 2025.

Most recent miniscule update on, well, meaningful updates also count.

Status: Repeatedly updated but by no means finished. Currently-published version is messy and possibly self-contradictory.

Anonymous 05/05/18(Sat)15:45:20 No.45166513 ▶
    If only you knew how different things could be.

The initial question

An underwater-basketweaving forum I’m on sometimes talks about technology topics. One question someone asked once was “What’s your ideal operating system?”.

I’ve been chewing on that for a few days.

The scope of the problem

I’ve been watching fairly alternative OSs like Haiku (the BeOS clone) and I wanted to really clear the slate and assume multiple orders of magnitude of work done just for this OS. Otherwise an operating system is just a way to run stuff that people can already run on a Linux distribution or macOS.

Originally, here I said “This is a desktop operating system” but increasingly I’m coming around to the notion that all great modern computing platforms are entire ecosystems and not just a pile of bits that one throws on commodity hardware. Because of this, I’m also specifying stock peripherals like monitors and keyboards and thinking about ways to have peripherals — like wireless headphones — shared between all your devices without an Apple Account coordinating permissions behind the scenes.

It does not assume a 1:1 correspondence between people and computers.

It won’t have bugs.

Hey, stop laughing. If I’m describing my ideal operating system, then it simply won’t have bugs in it.

The system will be thoroughly well-documented at all levels.

Furthermore, anyone working on fixes to the bugs (because in order to have no bugs, one must fix bugs) will be allowed and even encouraged to contact the person experiencing the bug and ask for more information. This will happen without the bug reporter having to go through extreme measures to replicate the bug in front of someone who can do something about it — like taking it to the house of the SVP of software engineering. As you might guess, this sort of process won’t work unless you’re the SVP of something else in the organization.

Craig Federighi, the senior vice president of software engineering (at the time of this writing)

The operating system’s place in the world

(UNIX limits files to basically a block of bytes in the name)

(Do we reimplement Git? Even just the porcelain?)

The hardware

Monitors

There will be a couple of monitors for sale.



(I’m not sure what a good 6K size would be. The current iMac has a “4.5K Retina Display” which is 4480×2520. I’m tempted to suggest a doublewide 4.5K at 8960×2520. Not curved.)

(I’m also on the fence on offering a 4K 27″ monitor for people with bad eyesight.)

Their features:















The system’s underpinnings

(Maybe sort the subheads here better, or at least establish an order.)

The system programming language

It will be largely written in a modern, performant, ergonomic, safe language like how Swift 6 is shaping up to be. The idea is to have something with Rust levels of safety yet not be quite so ugly.

Unlike Swift, the compiler will not have crashing bugs.

The compiler will support LSP use.

The Language Server Protocol (LSP)

Interaction styles supported

It will be a GUI-required OS, like macOS and Windows (and unlike Linux anything).

Syncing

One thing that modern users have come to expect is that there are ways to sync preferences and data between the different computers and sub-computer computing devices that a user owns.

This kind of data includes, but is by no means limited to:






iCloud performs this sort of functionality in the Apple ecosystem. Microsoft’s current operating system does something similar. It uses the term OneDrive for its file-sync functionality, whereas “iCloud” covers all sorts of different services.

My ideal OS would be able to do this between multiple computers without a central server.

While Syncthing-style relays may be useful for facilitating state syncs across the Internet, this functionality should not depend on them, and people ought to be able to disable that functionality easily if they are OK with having syncs only happen when all the computers involved are on the same LAN.

Syncthing

Syncthing is very good, although not perfect.

CRDTs are useful technology, although they’re by no means perfect:

Wikipedia, “Conflict-free replicated data type”

Ink & Switch, “Local-first software”: “CRDTs as a foundational technology” (explains the pluses and minuses (“unsolved problems”) of CRDTs)

Iroh might also help:

Link

“AI”

Machine-learning techniques can be useful, but absolutely nothing is going to be farmed out to other machines. This may mean that work is duplicated. That’s fine.

This is essentially the way Apple used these techniques before introducing what they call “Apple Intelligence”.

Virtual machines and chroot jails

These are useful technologies.

Sandboxing

The macOS way is kind of awful. Nobody likes it. Maybe there’s a better way.

Keyboard design

A proper minimal keyboard for this operating system will have:







Here’s how they’ll be laid out on a laptop-style keyboard:

⎋ 🔅 🔆 ❓ ❓ ❓ ❓ ⏪ ⏯️ ⏩ 🔇 🔉 🔊
`  1  2  3  4  5  6  7  8  9  0  -  =  ⌫
 ⇥  Q  W  E  R  T  Y  U  I  O  P  [  ]  \
  ⌃  A  S  D  F  G  H  J  K  L  ;  '  ⏎
  ⇧   Z  X  C  V  B  N  M  ,  .  /   ⇧
🌐︎ ⎇ ⌥ ⌘          ␣            ⌘ ⌥  ←↕︎→

Or maybe an ortholinear keyboard:

⎋ 🔅 🔆 ❓ ❓ ❓ ❓ ⏪ ⏯️ ⏩ 🔇 🔉 🔊
`  1  2  3  4  5  6  7  8  9  0  -  =  ⌫
⇥  Q  W  E  R  T  U  I  O  P  [  ]  \
⌃  A  S  D  F  G  H  J  K  L  ;  '   ⏎
⇧  Z  X  C  V  B  N  M  ,  .  /   ⇧
🌐︎  ⎇  ⌥  ⌘    ␣    ⌘  ⌥  ⎇      ←↕︎→

Or maybe something more modern and experimental (read: annoying and maybe not worth the squeeze), like an ortholinear QGMLWB layout:

⎋  🔅 🔆 ❓ ❓ ❓ ❓ ⏪ ⏯️ ⏩ 🔇 🔉 🔊 
`  1  2  3  4  5  6  7  8  9  0  -  =  ⌫
⇥  Q  G  M  L  W  B  Y  U  V  ;  [  ]  \
⌃  D  S  T  N  R  I  A  E  O  H  '   ⏎
⇧  Z  X  C  F  J  K  P  ,  .  /  ⇧
🌐︎ ⎇   ⌥   ⌘   ␣   ⌘  ⌥         ←↕︎→

(I would like to point out that I have never used the QGMLWB layout. However, in _Shift Happens_, Marcin Wichary claims/passes along the claim/points out that it’s supposedly the lowest-effort English-language keyboard layout, beating Workman by a little bit, beating Dvorak by a fair bit, and beating QWERTY by a lot.)

Additionally, one idea is that all pairs of punctuation be put on some layer somewhere, as seen on phones’ on-screen keyboards:















I use less than half of these on a regular basis and I’ve only used about half of these ever, but it’s a start.

Sometimes pairs are different and use different pairings:


More may be added to support languages that need it, like, say, Japanese.

(Note to self: this may be one too many.)

(We can never really totally cut off POSIX compatibility because we’ll be SSHing into POSIX systems.)

It will not have a dedicated Caps Lock key.

I don’t know what functions will be on the keys between F2 and F7. Then again, Apple changes these around every so often, so I don’t feel the least bit bad about not knowing what deserves dedicated keyboard buttons in the top middle of the keyboard. Maybe a teeny Touch Bar like MacBooks used to have.

Here’s how the different combinations of keys will shake out:

To generate this list, run the following code:

from itertools import permutations, product
from pprint import pprint
l = ['⌃', '⇧', '🌐', '⎇', '⌥', '⌘']

everything = set(product(l, repeat=len(l)))
globs = [''.join(xs) for xs in everything]
globs = [set(glob) for glob in globs]
pprint(sorted(list(set([''.join(glob) for glob in globs]))))







⎇

⎇⇧

⎇⌃

⎇⌥

⎇⌃⇧

⎇⌥⇧

⎇⌥⌃

⌃⎇⌥

⌃⎇⌥⇧




There will be two main nucleus keys:



There will never be any OS- or application-defined keys that use both of these at the same time. Users, however, may create key combinations that use both at the same time.

At any rate, the canonical written order of keys is:

⌃⎇⌥⇧⌘🌐︎

Spoken aloud, Shift gets moved to the front:

Shift Control Alt Option Command Globe

(Unresolved issues)

(This section is very much a work-in-progress.)

Consider a browser.

It has these very R-ful functions:





Clearly, Reload gets ⌘R, but what about the rest?

(Another unresolved issue)

When Alt is part of a Command combo or a Globe combo, it does an application-level or OS-level thing.

What about when it’s pressed by itself, or in combination with other modifiers that are neither Globe nor Command?

Shift

In current OSs, people are used to Shift meaning three things:




Command

Command will be the primary key that one uses for in-application keyboard shortcuts, like:






















There will also be the same keyboard command everywhere for nerdier commands like:






Globe

Keyboard combinations with Globe will be reserved for OS-primary functions, which includes both window and tab management.


















Control

The Control key is primarily to turn letter keys into cursor-movement keys.

There are things one might want to modify cursor movement with:







The primary cursor-movement keys will be:





Adding Shift will, of course, expand the selection in that direction.

Unused options:






(Finding keyboard shortcuts for all these other movement/selections is an unsolved problem.)

It may be a good idea to have some of these keyboard combinations straight-up delete as well, like C-k in emacs or ⇧⌘K in Visual Studio Code on macOS.

Alt

(Not sure what to do with this key yet.)

Option

The lack of a Compose key

What the Compose key does for the en-US locale

Adding a compose key in addition to, or instead of, Option sounded like a reasonable idea. However, after studying the Apple Extended layout a bit and seeing what it does with:



and the ability to place dead keys on either, I think we ought to be able to get almost everything most people would want. The Apple Extended layout is missing a couple useful characters like ≈ (something available as ⌥X on the normal layout since 1984), but it could be shuffled around a bit and still make at least as much sense as the current Apple Extended layout does now.

(Coming: adjustments to the Apple Extended keyboard layout.)

Bundled fonts

The system will use OpenType fonts; I don’t have enough real criticisms of the OpenType format to say “a new format should be made”.

I’m still going back and forth on whether these fonts should be just made available for use on the Web (pretty much made free-as-in-beer) by offering gigantic sums of money to their respective foundries.

Proportional fonts

I’ll probably go with Helvetica Now as the default proportional font.

Tobias Frere-Jones has taste. Something he makes in the Seaford idiom would be a solid addition.

I think Marcin Wichary’s Gorton Perfected would make a good addition to the list of built-in fonts, provided he updates it with condensed variants as seen in the wild.

Monospace fonts

There are a couple neat features worth talking about in monospace fonts:



There’re also popular things that I’m not personally a fan of, but can see the appeal of:



Microsoft, “Beyond Calibri: Finding Microsoft’s next default font” (has a quote from Frere-Jones on what he was going for)

Monaspace

Berkeley Mono

Nerd Fonts

System automation

The OS will support something like Automator/Shortcuts, as well as something like Services.

It will not make it a fantastic chore to run selected text through a command-line application or the default language’s equivalent of a five-line Perl script.

The system will also provide a TextExpander-like facility to expand typed text into more/harder-to-type text. This will cover most of what people want out of a Compose key that they can’t get out of a macOS-style Option key.

TextExpander

Espanso

The windowing system

I have not decideded whether it would be better for windows to be application-centric (like macOS) or window-centric (like everything else).

Like macOS, there will be menu bar at the top. Or maybe the bottom. There will also be a bunch of icons over on the right, and there will be good builtin utilities for managing the sort of clutter that can happen there.

Light/dark mode and theming

The system will support both light and dark modes, as well as an automatic toggle depending on the time of day.

It will also support, for those who want them or need them:



I have not yet decided how much theming the windowing system will support. This may be disappointing if you’re looking to reimplement Windows’ Hot Dog Stand theme.

Finally, it will support multiple-image wallpaper, suitable for having wallpaper that changes with the time of day and/or whether dark mode is enabled. The image format will be simple, like having a zipfile of multiple images with some metadata in YAML describing when each image should be shown.

Pixel density

The windowing system will not support fractional pixel density (150% zoom, etc.). The macOS-style @1x, @2x (and possibly @3x, if it ever comes to that) will be the only game in town.

The mouse pointer

I may end up wanting to have the mouse cursor be like on iPadOS where the default cursor is a transparent circle and has aim assist, with the shape morphing to an I-bar where appropriate.

I’m still on the fence on the general size of click targets and whether they should be made large enough to support tap interaction.

Bundled desktop applications

A system is not complete without a decent pool of basic applications.

A Web browser

It will ship with a damn good browser not built on Blink, Gecko, or WebKit (or their companion JavaScript runtimes).

Stop laughing. We’re already in fantasyland.

It will also support Gemini and Gopher.

While we’re at it, the OS will ship with a Transmit-quality scp/sftp app.

Transmit

A built-in programmer’s editor

It will have something like Panic’s Nova as a Visual Studio Code-tier do-it-all text editor.

Nova

Like BBEdit, the editor will be able to edit files inside of zipfiles.

The terminal

There will be a terminal, and a default shell. It will support UTF-8.

Fair warning: I barely know how terminals and all their features are implemented. I’ve heard of ANSI escape codes and OSC (operating system command) codes, and know about some of the things they do, but I’m not an expert.

Wikipedia, “ANSI escape code”

Julia Evans’ posts about terminals

The default shell

The shell will not aim for sh compatibility. At all. Nevertheless, constructs like && and || may end up being a good idea anyway to not entirely poop all over world+dog’s muscle memory.

Powershell had the right idea when it came to making formal names — that is, Verb-Noun. Maybe Noun-Verb would have been a better choice, since so many commands these days start with an ur-command, like the following:

fooctl frobnitz --softly --with="big stick"

Powershell also had the right idea when it came to operating on streams of objects instead of plain text all the time.

On the other hand, Powershell commands’ output tends to be unoptimized for the screen space given. That should be fixed somehow.

As an aside, I tend to think that Http-Header case is ugly much like Pascal_Snake case, especially for command lines, but Microsoft might have the winning style here, usability-wise.

Have more than just output and error streams

If you’re used to shells in UNIX-style operating systems, you should be familiar with the difference between the standard output stream and the standard error stream.

What you may not know is that PowerShell has not two, not three, but SEVEN streams as of PowerShell 7.4:








about_Output_Streams (PowerShell 7.4)

This is an idea worth copying.

Have something better than manpages viewed with less

Manpages are nice because they’re only one page.

Info pages are, theoretically nice…but I’d have to learn some kind of one-off reader for them from the 80s and ain’t nobody got time for that.

On the other hand, if you want to find out how a particular command-line argument works in a manpage, you have to cross your fingers and hope that searching for “-r” isn’t going to flood you with false positives.

For all this, the winning play is probably going to be something like DocBook-in-XML as a source format. I’ve looked at mdoc, and while it’s at least semantic, it’s ugly as sin because of all the mandatory linebreaks:

mdoc(7) on mandoc.bsd.lv

DocBook-in-XML is probably way less ugly and easier to read while writing, especially with modern tooling (think LSPs and such).

Colors in the terminal

The terminal will be able to display things in whatever color. And when I say “whatever color”, I mean to include colors that are outside the sRGB range, like ones you might specify with OKLCH.

oklch.com

Additionally, control codes to specify colors will be able to specify both light-mode and dark-mode colors. The rationale for this is to be able to spit out terminal output, and later, when the user changes the terminal color scheme from light to dark (or vice versa), the colors used will look right for the new color scheme as opposed to something where all the foreground colors are too close to the background color to really tell what’s what.

Bundled terminal applications

TUIs are totally going to be a thing for a few things.

Text-based user interface (on Wikipedia)

Terminal-based document viewer

I’ve complained above about how manpages don’t quite measure up to a real web browser, but nobody wants to learn how to read GNU info pages at the command line.

If there were an easy-enough-to-pick-up command-line document viewer (think of lynx or GNU nano) then this would be mostly fixed.

Terminal-based text editor

There will be one terminal-based text editor included with the system. You could describe it as “Visual Studio Code, but implemented in the system programming language with a TUI user interface instead of in TypeScript with an Electron interface”.

It will feature:






This editor will also take interface cues from Micro, Helix, and…WordStar. Micro is pico/nano on steroids. Helix supports LSPs and multiple cursors and has a decent windowing system for hints and things. WordStar pre-dates almost all common conventions for cursor movement, and therefore has “fresh” ideas. I’d consider something like (modifier) IJKL or ESDF instead of the execrable vi-style HJKL.

Visual Studio Code

LSP (Language Server Protocol) on Wikipedia

Micro

Helix

WordStar (as evangelized by Robert J. Sawyer)

Unsolved problems






Link

Related thinking

The 𝕏 account for the U.S. Graphics Company shares its author’s concerns, which are fairly similar to mine.

@usgraphics

The idea graveyard

I’ve had ideas that roughly pertain to an ideal operating system, but don’t quite make the cut. Or they’re too weird. Or too normal. They go in the graveyard.

The ideal-OS idea graveyard

⏚

Home

Hi! I’m a one-pixel invisible tracking image! View me to let my webmaster know you’ve scrolled through the entire page!

Source