My ideal operating system

First considered in June 2024.

First published June 30, 2024.

Most recent meaningful update on December 10, 2025.

Most recent miniscule update on December 11, 2025.

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

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

The UNIX conception of a file is “a block of bytes of finite length”.

Not all operating systems and file systems have agreed on that, though. macOS today still has type and creator codes (so, theoretically, most JPEGs open in Preview but the one you made in Acorn opens in Acorn when you double-click on it), but barely anyone uses them and even more old-school uses of extended attributes are pretty much only limited to BBEdit which will store per-text-file settings in them, but no critical information in them.

I want this OS to be similar, probably. The Internet touches basically everything and we don’t want to have an OS that leans into complicated definitions of “a file” and ends up being an isolated hothouse flower that is only good for solo work that is never shared except by packing the whole thing into a VM and having other people run it in VirtualBox or similar (I’m thinking of TempleOS as I write this).

However, there’s a lot out there that is just…annoyingly suboptimal.

If we’re willing to say “this OS has no bugs” by magical fiat, then we can say the following:

This means:

The hardware

People who are really serious about software should make their own hardware.

— Alan Kay

Well, I’m not making anything — only dreaming it all up — but the point stands. See my quip above that reads “all great modern computing platforms are entire ecosystems and not just a pile of bits that one throws on commodity 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.)

Also see the discussion on my ideal-setup page for oddball (4:3) monitor sizes:

My ideal setup

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)
Ian Duncan, “The CRDT Dictionary: A Field Guide to Conflict-Free Replicated Data Types”

Iroh might also help:

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

Document-type and -format preferences

YAML is good.

A bunch of files in a zipfile is good.

Typst is good. CommonMark is OK, but Djot is even better because it’s more featureful and easier to parse.

However, Djot has a number of features in it that seem like they’re aimed at people who don’t use a setup that will automatically curl quotes. These are anti-features in my ideal OS, so they get thrown out and we have to think of a name for a Djot clone. I don’t like its Symbols feature, either, because it’s very obviously a hook for nonstandard extensions.

yaml.org
Wikipedia, “YAML”
Typst
Djot
Djot’s smart-punctuation overrides

You know what else is good? Text files and their dependencies in a zipfile. ePub and .docx are like this (although they’re both moderately warty formats, at least). Typst-and-referenced-images-in-a-zipfile would also be good. Ditto djot.

I’m at a total loss to think of how HTML+CSS+JavaScript could be done better, but Steven Wittens isn’t:

Steven Wittens, “HTML is Dead, Long Live HTML — Rethinking DOM from first principles”

This might be thinking small, but I’d like to bring (back) parts of XHTML 2, the never-finished W3C Recommendation that basically killed off the W3C with a too-annoying-to-implement standard and left the WHATWG to pick up the crown that the W3C just chucked into the gutter:

The World Wide Web Consortium, “XHTML™ 2.0”

Interesting ideas it had that died with it:

Ditching <h1> through <h6> for just <h> sounds nice in theory, but I can’t think of a nice way to turn a Markdown-like language into HTML like that. (Markdown only got popular after XHTML 2 was floated and died off.)

Filesystem layout

I’m not entirely sold on the UNIX “everything is a file” philosophy, but it’s likely within spitting distance of what I want in the end. I’d likely have a better opinion about this if I’d used Plan 9 in any capacity. That said, Plan 9 is designed, as far as I know, networked in a hierarchical relationship and I’m not sure if that’s the sort of model I’d want in my ideal OS unless I want my ideal OS to cater to use cases of working well as an owned-by-someone-else machine.

I think GoboLinux has more or less the right idea when it comes to filesystem hierarchies:

Wikipedia, “GoboLinux”

I think “everything in /Programs” is a bit too flat. I’d want multiple domains for, say, programs, much like how macOS is organized:

macOS has — or at least had — a /Network domain, where some kind of master server could supply programs.

Like in macOS, spaces will not be shied away from.

Unlike macOS, everything will be sentence-cased, not title-cased. Imagine “~/Library/Application support/” rather than the same with a capital S. This may very well cause confusion in cases like, say, “~/Library/Application support/Google Chrome/”, because people will have to remember what’s a proper noun and what isn’t.

I may totally flip on system directories and declare that all-lowercase kabob-case directories are the winning play, à la “~/library/application-support/”.

“Files and folders that start with a period are hidden by default” seems like a perfectly adequate convention worth carrying over to my ideal system. Of course, one should also have a way to hide files without changing their names.

Encoding file name information through multiple parts of a directory path, and dealing with the consequences

Assuming you haven’t saved this page to a file, you’re using a URL that has important information scattered throughout its hierarchy. “/os/” doesn’t say much about what this page is about, but “/ideal/os/” does.

Making sense of directories that are totally mysterious on their own

One problem that crops up if you give these kinds of names to folders is “where is this directory”?

Consider Finder’s Go → Recent Folders menu. If I see an entry in it that just says “2”, which of the following is it?

~/Dropbox/Photos/Games/Xenoblade Chronicles/2/
~/Dropbox/Photos/Games/Zelda/2/
~/Documents/House/Upgrades/2025 - Sauna installation/Blueprints/Rounds/2

Finder will just say “2”, and leave me to guess. Granted, this is a recent-folders list, so I’m probably not totally hosed, but still.

BBEdit, on the other hand, is fancier than macOS’ Finder, and supplies sometimes-critical context (the downside is that the list is way more cluttered). If I opened the top folder in BBEdit, I’d see this in the history:

2 — 📁 ~/Dropbox/Photos/Games/Xenoblade Chronicles`

Unfortunately, the list in BBEdit is ragged-right, which makes it difficult to scan. I think a better idea is to have something like:

                                                      all lined up here ↓
                           ~/Dropbox/Photos/Games/Xenoblade Chronicles/2/Blade combos.JPG
                                          ~/Dropbox/Photos/Games/Zelda/2/World map.png
~/Documents/House/Upgrades/2025 - Sauna installation/Blueprints/Rounds/2/Power.pdf
                                                                        ↑

BBEdit can’t do this, but theoretically my OS could.

Sending files that have important information further up the directory hierarchy

Consider some of my images collections.

For example, I have full paths like

~/Dropbox/Photos/Games/Xenoblade Chronicles/3/Bantz/No use for all these imbecilic side characters.jpg

Now, “No use for all these imbecilic side characters.jpg” certainly conveys the sentiment of the image, but there’s a guy in Xenoblade Chronicles 2 who definitely would say this sort of thing. If I wanted to have a single filename that captures all this information (say I’m about to zip up a bunch of similar files and send them to a friend), I’d want the filename to be something like

Xenoblade Chronicles 3, Bantz, No use for all these imbecilic side characters.jpg

In order to make this not-unpleasant, I’d need some kind of “make a copy with user-chosen directory separators” function in the system file manager (the macOS Finder equivalent, or the Windows Explorer equivalent). Above, I’ve chosen “ ” (yes, a space) as the first replacement and “, ” for the second and third.

(Honestly I’d prefer that “Bantz” be removed entirely from the for-sharing filename, but describing that kind of feature in the above paragraph is beyond my abilities at the moment.)

This rename-for-publishing feature would be some semi-buried nerd feature like New Folder With Selection (⌃⌘N) that I enjoy on macOS.

In the system parts of the filesystem

I have fond memories of BeOS’s ultra-terse paths like

             SCSI target ID
             ↓
 /dev/disk/0/1/0
           ↑   ↑
  controller   partition

I think this looks cooler and is more readable (has more separators) than Solaris’ setups:

/dev/dsk/c0t0d0s0
/dev/dsk/c0t0d1s0
/dev/dsk/c2t5006016A0ABCD123d10s2

(The letters stand for “controller”, “target”, “disk”, and “slice” (“slice” being the same kind of thing as a “partition”. However, in the third example, the target is the target port WWN (World Wide Name — a sort of MAC address for a storage node), and by golly, I could use some slashes around it to help separate it from the rest.)

Home directories

Programs will not add configuration files and/or folders directly to users’ home folders on pain of mocking and social ostracism by all the cool kids.

Because the system lives in a fantasy land where nobody bothers with programs written outside of the system’s ecosystem, peer pressure will actually work.

Instead, there will be direct equivalents of ~/.config/, ~/.local/, ~/.cache/, etc. Maybe even with those exact names. Programs will put their configuration in there, or perhaps in ~/Library. Actually, ~/Library is the cohesive place for all this. The trouble with the modern macOS ~/Library is that there’s a LOT of stuff in it, and the average user can’t really be trusted to muck around in there. Even when I go in there, it’s full of stuff I generally have no interest or business mucking with, and it reminds me of ~/.config/ on a Linux machine (busy), rather than ~/.config/ on my macOS machine (literally everything in there I wrote myself).

…yeah, I think I’d dislike ~/Library/ a lot less if it didn’t have so much crud in there that I don’t care about and have zero desire to manipulate myself unless something goes extraordinarily wrong.

Like, there are four kinds of folders in here:

Sandboxing made all this worse, too, at least on macOS, if only because of the duplication. I wonder if there’s a better way.

There are two ways to organize things:

Arch Linux Wiki, “XDG Base Directory” (a summary of the XDG Base Directory specification)

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 keys 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

AFAICT this will mostly be what it does on macOS now.

I’m very tempted to stop doing the European thing and have the following keybindings instead of what Macs have done since 1984:

This means that the most common character, ’, is two keypresses instead of three.

Similarly, « and » can go on adjacent keys instead of being piled on the same key. ‹ and › are currently ⌥⇧3 and ⌥⇧4 on macOS, and that’s fine.

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

System automation

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

Workflows will have an easy export/import to/from YAML files for ease of sharing and authorship, both by programmer types and LLMs.

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.

The look and feel

I think I want the OS to have the look and feel of Newton OS 2.1, as seen on the MessagePad 2000 and 2100 (in particular, with 16 shades of gray, including both black and white-xor-green).

It shouldn’t be grayscale itself, mind, but I think there’s undercelebrated design in here, particularly with how the icons look. They’re plain and clear and there’s a very warm, human aspect to them that I like that isn’t well-replicated in any of the other styles at the time (Windows 95/2000 style, Mac OS style, BeOS style, IRIX style, CDE style).

If you’d like to get an idea of what I mean, use your favorite search engine and look at screenshots of NewtonOS 2.1 running on a MessagePad 2000 or 2100. You can also look at older MessagePads (like the 130 and the 120), but those aren’t grayscale at all, so you might miss a little bit of flourish that is closer to what modern displays can do.

I’m mostly thinking that Newton cues would be best for toolbar buttons and smaller icons. The Newton look is too plain for modern Dock icons (on macOS before Tahoe 26, they were made out of super-large bitmapped images that were then shrunk down, and frequently had lots of details that weren’t really visible at normal Dock-icon sizes).

On the other hand, Newton icons have distinct shapes and are stylus-sized, not mouse-pointer-tip-sized, so they’re not teeny little click targets like you might get if you were trying to bring, say, Mac OS 9 into the modern era.

One drawback: I’d have to almost totally think up what windowing would look like. Basically all Newton applications were full-screen, and the ones that weren’t were a fixed size (imagine a small calculator). I’m tempted to have three dots at the top center of the window and put a radial menu there. Although people on touchpads might hate it.

EveryMac, “Newton MessagePad 2000 Specs”

Some aspects of NewtonOS live on to this day (outside of Einstein, the emulator): if you drag something off the Mac OS X / macOS Dock, hold it away for a bit, and then let go to make it disappear, both the puff animation and the sound that goes with it are from NewtonOS.

pguyot/Einstein on GitHub

Roundedness of the UI

As I write this in 2025, a lot of people are talking about a current trend in UI design — namely, the increasing roundedness of UI elements. Some rounding generally looks nicer and more humane than corners one could cut his finger on, but excessive rounding (see iOS and macOS 26) reduces information density because text and icons inside UI elements with large border radiuses need to be kept away from the rounded edges.

The roundedness of macOS Sequoia 15 is probably an upper limit of how much bouba we should tolerate.

Wikipedia, “Bouba/kiki effect” (so you know what I’m talking about when I say “bouba” or “boubacious”)

While one is tempted to revert to no rounding (like what was commonplace up through the 90s and somewhat beyond), I think this would be a mistake. My ideal OS will have modern font rendering designed for Retina-class displays, and modern fonts on retro (or merely just old) websites with razor-sharp styling look weirdly fuzzy and downright alien on sites that assume you’re reading in crisp, pixel-accurate expertly-hinted 8-point Verdana.

Mac Themes Garden
Wikipedia, “Font hinting”

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 (how close it is to sunset), as well as how much ambient light there is.

The sunset trigger will be configurable. Usually my Mac switches to dark mode too late (leaving the monitor the brightest thing in my field of vision for tens of minutes before switching over) and switches to light mode too early (sometime around sunrise but well before the screen seems too dark).

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 — or maybe all of that can just go in the filenames.

I would also like it to support “cozy animated-GIF backgrounds” (examples forthcoming).

Transparency

The Human Interface Guide (HIG) for Mac OS X 10.0 said that transparent UI elements were for temporary fleeting things like overlays on sheets.

Transparency might have a place in my OS, but I’d like it to have a purpose behind when it’s used (beyond “it looks cool here”).

Currently (as of macOS 15 Sequoia) Quick Look previews are temporary and fleeting, and also transparent.

Accidental Tech Podcast, episode #650 (source for the above factoid about what transparency was for in Mac OS X 10.0)

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

The input system

The emoji picker will not suggest U+1F9C6 FALAFEL (🧆) when the user types in “meat”.

Bundled desktop applications

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

Howard Oakley of The Eclectic Light Company, “The Anatomy of a macOS App”

A file manager

I want the file manager to be spatial by default and close parent folders (even though I occasionally like having stuff on the left side of all my Finder windows, which is a hallmark of browser windows).

For a taste of this on a computer you can use right now, get to a Mac and navigate through Finder windows by pressing ⌥⌘↓ to go into a folder and ⌥⌘↑ to back out to the parent folder. Using a mouse? Hold down Option and double-click on folders. Do this on actual files and you’ll open the file and close the enclosing Finder window (which just might be what you want…occasionally).

I think that folders’ layouts should be stored as a per-user setting, not an inside-the-folder setting (like with macOS’ .DS_Store files). This might have unintended consequences, though, that I haven’t thought through.

John Siracusa at Ars Technica, “About the Finder…” (explains what “Spatial Finder” is)

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. Additionally, it will also automatically curl single and double quotes for appropriate file types unless told to not do so on a per-file basis. (This is the kind of thing that extended attributes are good for.)

An ePub viewer

There are lots of books worth reading, and ePub is a tolerable format for reading books in.

Standard Ebooks has many books worth reading.

What’s always bothered me about annotating ebooks is the nonportability of annotations and highlights.

Maybe a (pseudo-)Markdown format like what friends uses (so, Djot) wouldn’t be the worst thing. It’d just be a file stored alongside the ePub, and it’d have highlights, notes, etc. in it. However, the kinds of anchors (loosely speaking) a program would find most stable (ePubs do get updated) aren’t always going to be the ones that are going to make sense for a normie reader who doesn’t really care about the structure of the .xhtml files inside the zipfile.

Or maybe a YAML file with a bunch of documents (separated by ---) describing annotations. That might work too, and you can just have something like `comments: |` and the reader can go to town with all his commentary on a particular passage in a work.

Djot
Standard Ebooks
JacobEvelyn/friends on GitHub

The terminal

There will be a terminal, and a default shell. The shell will be called “conk” (think of the onomatopoeia of getting hit on the head).

Wikipedia, “Conch”

Of course, all of this 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, conk

conk 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. fish went through a long period of requiring people to do `; and` instead of `&&`, and it only started getting popular and not-annoying when people could just paste most simple bash/zsh lines into fish without having to change the middle parts of them to something weird.

fish, a command-line shell for the 90s

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 (that is, linearized by default and tend to not go into large digressions).

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

But I want a better viewer than a pager like less. qman is definitely onto something:

plp13/qman on GitHub

Completions

I’m not sure how I want to implement this, but I want proper completions in the shell, like how the best completions work in the fish shell.

fish’s completions files

I figure that almost all programs ought to be able to generate completions (in a file describing what to run) for themselves. If a program uses a fancy library to handle command-line options, then that library can emit completions for it.

Of course, in fish, some programs basically have small fish programs that work out what’s permissible to type, and will tab-complete not just files in the current directory, but a list of active branches:

share/completions/git.fish

I figure that, as a first cut, all programs should have a very strong convention (like how `--help` almost always shows help) of

fooctl generate-completions [--shell-name]

like how a bunch of programs do already. You’d be able to leave off the shell-name command-line flag for conk, the system’s default shell.

Completions, an inferior way

A somewhat worse option is to have to run an initializer every single time you start up a new shell instance, like how kongplete does it, at least how I use it:

WillAbides/kongplete

Syncthing uses it:

syncthing/syncthing pull request #9226

But you have to run its completion installer once per shell instance, which isn’t viable for a gazillion command-line programs:

# put this in your ~/.config/fish/config.fish
# to run every time on shell startup
# I think the bash/zsh equivalent is
# $ source <(syncthing install-completions)
source (syncthing install-completions | psub)

On my system, theoretically, Homebrew could run this and generate a syncthing.fish completion and stick it in a system directory somewhere. But that’s not what it’s set up to do, and I want a system where you can just download binaries outside of a package manager and get good completions.

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.

Wikipedia, “Text-based user interface”

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
Edit
Fresh
WordStar (as evangelized by Robert J. Sawyer)

A static site generator

It will come with something like Hugo and probably not particularly like Astro.

Hugo
Astro

Unsolved problems

Exposure to how different things could be

Abort Retry Fail, “The QNX Operating System” (kind of like UNIX, but better, and peaked aesthetically around QNX 6.2.1)

Related thinking

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

@usgraphics

There are other people who have been rethinking operating systems, broadly defined:

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!