Hi, I’m Chase 
I’m part of a small team that’s working on a new kind of operating system which embodies many of the properties discussed in this forum. Here’s how we describe it:
Pallas is an event sourced, purely functional operating system, called an operating function.
Pallas provides an entirely unique set of features, but is inspired by a long history of systems and language research, including MIT’s exokernel. Pallas collapses the distinction between database, virtual machine, and language platform, creating a stable, simple, and extensible programming environment.
The cost to this design is a clean break with legacy systems, including Unix and most popular programming languages. In return, Pallas offers a set of features that are found nowhere else:
- All application data is automatically persisted, without the need for imports or boilerplate. To create a database, you write a pure function. Open system calls are included in persisted state, and so are resumed on reboot.
- Partially applied functions can be serialized and stored on-disk, or sent over the wire. Programs in mid-execution can be paused, moved to a new machine, and resumed with no impact.
- Program execution can be parallelized via a process model. A single machine can spawn and manage multiple processes.
- The system’s default language blends features from both Lisp and Haskell, with a syntax that is more readable and flexible than S-expressions without sacrificing regularity or homoiconicity. Metaprogramming capabilities include hot reload, zero-overhead virtualization, macro-based type systems, all the way up to custom compilers.
- Data and code is deduplicated, merkleized, and stored in content-addressable memory pages. This creates a global referentially-transparent content store, which is naturally complemented by protocols like BitTorrent.
The foundation of Pallas is untyped, but conceptually we can say that a database is a function of the type
type DB = Input -> (Output, DB)If a user supplies such a function, the Pallas runtime will create a database using a snapshot-and-event-log system. The user can write their programs as if they were keeping their data “in memory”, without any need for manual persistence or other forms of cache management.
The recursive part of the type above might seem strange. You can think of it almost as a normal stateful function:
type OtherDB = (State, Input) -> (State, Output)The difference is that instead of changing the state value, the recursive version would change itself. The current version of the function is the state. In other words: programs can upgrade themselves dynamically. Code can construct code. Because of this, we can put an entire compiler toolchain inside the system and the programs it generates have zero dependencies on the outside world.
Pallas is open-source, but before we start sharing it publicly, we’ve been trying to find communities of engineers and researchers that can provide private feedback. The model is sufficiently different from the mainstream that we’re concerned about confusing first impressions, so we’re holding ourselves to a high bar by running “UX” tests on the repo and documentation site.
We would really love the opportunity to conduct a live onboarding session with anyone that’s interested. They generally last for about 90 minutes and do require screensharing. I have an open calendar available here.
If you’re interested in this idea, but not in a call, we’re aiming for a finalized first version of the repo and docs within a couple weeks. I’ll update this thread with more info when it’s available.
Edit 8/26/2024