A creation-first interface

One of the primary wonders of computing is that creation on a computer is essentially completely free, once you have one – the world of information is a post-scarcity one where the only cost is your time, and that's it. Bits can represent anything, from prose to poetry to images to film to interactive games to music, and bits can be created and infinitely duplicated (taking poetic license here, don't come after me, I know they're technically being modified not created) at zero cost, on your own computer or between any other person's computer in the entire world. Even distribution, in the digital age, is nearly free – pick up a $35 computer on eBay or from your nearest surplus store and run Linux on it, every Linux distro comes with a network server – even if getting attention to that distribution isn't.

The other primary wonder of the computer is that it is an infinitely flexible information processing and communication machine – a meta-machine that, if you can describe a behavior, can instantly become a machine-to-do-that-behavior. There's no limit: as long as we understand what we want the computer to do, as long as we can describe the way we want it to process information, or how to link information to behavior, the computer can automate it. There is no fixed purpose to a computer. Thus computers can be a great help in people's everyday lives (as long as they have to communicate or process information regularly), freeing the user from time wasted with repetitive drudgery, giving the more time to think and play and create, or spend time with their friends and family, or hike around in the outdoors.

I feel that this has been lost in the modern era of personal computers, where user interfaces revolve around things like start menus, task bars, desktop folders, and home screens, oriented around launching circumscribed applications for specific tasks (usually content consumption) that present no affordances to be easily wired together or scripted or pass information quickly from one to another for processing, instead of notebook interfaces, shells, or REPLs. Don't get me wrong, there are a huge number of ways in which the fundamental metaphors, design, and capabilities of personal computers and their interfaces have massively improved, and we should preserve those where we can, but my dream operating system would be oriented around a notebook-centric interface, something like what Karl Voit calls an application-less system.

In a document-centric operating system, you should boot up your computer and be immediately presented wixsth something like a notebook interface: a document for creating things – anything you can imagine.

• You should be able to just go right ahead and start typing if you want to write prose, take structured hierarchical notes or unstructured Zettelkasten notes, register rolodex-style grouped metadata entries, list tasks and subtasks, document upcoming events, or create a presentation. This should be done with simple plain-text markup (for maximum versatility) but still offer deep structural editing, manipulation, and analysis, so that the user isn't stuck doing all the legwork themselves.
• You should be able to open existing notebooks from previous sessions, or request various views of cross sections and queries on every notebook in your entire system, correlating all the information and content you have created easily and coherently.
• You should be able to follow hyperlinks inside and between notebooks, and to applications and external websites, and even to activate code or UI elements or run key commands, to correlate together as much information as possible.
• You should be able to include documents from over the network transparently into your notebook without having to explicitly manage downloading and attaching them.
• If you want to run code, you should be able to create a code block for any language you have installed on your system and want to use immediately, in line, without having to open a separate editor or IDE program or terminal or REPL, and when you're editing that code you should have access to full syntax highlighting, refactoring support, and autocompletion.
• Then you should be able to just run that code block with a simple key command and see the output – even if that output is an image or a UI widget, which you should be able to interact with – and then plug that output into further code blocks (even if they're for different languages) or tangle a source code file from your code blocks for contribution of version control.
• Controlling your system should be actionable through writing whatever code or commands you want to execute in a code block or, if it's small enough, directly inline anywhere in your other text and hitting a key command to execute it, as well as through a fuzzy completion command palette for simpler single commands. You should be able to control other computers you own transparently over the network from this notebook interface. <<system language>>
• All applications should be accessible through running a command in the palette to open it in a new split or on a new workspace, or running it inline in the existing notebook interface to get an embedded interface, if that makes sense.
• Every time you open a new window or switch to a new desktop, either an existing notebook or interface, or a fresh new one, should be presented, as makes sense.
• The environment should offer a means of recognizing patterns in the text you've entered (or semantic metadata or markup on that text) in your notebook and turn those into powerful hyperlinks with a default action and a semantically aware and extensible list of other actions, so that your notebook system can be highly hyperlinked and manipulable with minimal intentional markup.
• If the user wants to view things like web pages, images, or videos, that should be easily possible either in a new window or inline with the notebook – as they desire – but the notebook should allow the user to toggle "read only mode" off on any of these things, at which point the piece of content will be automatically saved and an editing mode entered where they can annotate, edit, modify, or expand on it.
• Anywhere in the user interface of any application or in any notebook, it should be possible to store a hypertext link to that location and add it to any other notebook.
• Anywhere in your interface it should be as easy as possible to open a new or existing notebook for adding-to.
• Notebooks that contain hyperlinks that run code in the system language – which should be able to launch and control any application, modify or control the system itself, modify the notebook, including changing or adding other hyperlinks or code blocks and running them, as well as opening new documents internal or external – could allow users not just to script things but to trivially construct their own user interfaces for various everyday purposes in an essentially free-form, low-code way, like the beloved classic Macintosh HyperCard system extended to the entire operating system.

Combined with the properties of a homogeneous, open, malleable system with true homology between all user interactions and how interfaces are actually implemented and scripted, I think this interface would maximally empower users: it could incline them toward creation over consumption, specifically creation of their own content, and give them an up-front way to learn how to control, modify, and automate their system, so that they aren't stuck just pulling a lever that's now digital instead of physical.

There is only one system I know of today that allows an experience like this: Emacs. Either through packages like org-mode (& org-babel, org-agenda, org-capture), Embark, org-transclusion, and of course built in functionality like eval-last-sexp, eval-defun, the *scratch* buffer, and TRAMP, or through the less powerful, older, and more obscure, but also much more integrated and versatile GNU Hyperbole.