Unfortunately it's private research I don't own and it probably won't be directly released, but over the past couple of years I developed a kind of distributed JVM that lets you create threads that migrate between processes. It's deeply integrated with an underlying RDBMS and dependency injection container, so injected dependencies that are singletons or that can otherwise be recreated by the DI system given small amounts of data are captured at checkpoints using "coordinates". This means threads only create a few kilobytes of state and that could be optimized further too. It's quite a nice system with a lot of features that make distributed programming a lot easier. It plays in the same space as DBOS or Temporal but presents a model much closer to an idealized distributed computer, in particular because there's no log replay so you don't have to think in terms of idempotent operations.
I've also kicked around a lot of ideas for how to rethink desktop/productivity operating systems from the ground up given what AI now makes possible. There's lots that can be done here, some profound and some just convenient. I think a desktop OS that incorporates local models smartly would be a very interesting thing and might be the sort of change that's big enough to actually justify the effort. For example:
• Window titlebars got phased out because they were mostly redundant and just taking up space. But now local models could select titles smartly even for non-document apps.
• Icons are often abstract, pointless or missing (e.g. on the web). They also suffer from needing to be a uniform shape and due to the constantly shifting art styles Microsoft and Apple's designers want this year. But now local models could generate icons on the fly given the actual thing the app is doing, and they don't necessarily have to be square anymore. Icon themes could become powerful enough to be actually useful.
• CLI tools like "ls" could give you a short description of what's inside a directory, not just show you the name. Running "foo --help How do I configure you to use TCP sockets" could generate an answer on the fly by reviewing foo's man pages.
• There's lots of things you could try around keyboard focus, like gaze tracking. The way the mouse works could use a rethink in general, modern operating systems for various reasons have never really exploited Fitt's Law and with multi-screen it just got even worse.
And dozens of other ideas... those might not be in the "easier to understand/build/program" category though.
Not exactly new, but Ternary Computers moght be something to look at:
https://en.wikipedia.org/wiki/Ternary_computer
David Ackley's work on robust, non-von Neumann architectures is still one of the more interesting directions in this space.
I've done some.
Unfortunately it's private research I don't own and it probably won't be directly released, but over the past couple of years I developed a kind of distributed JVM that lets you create threads that migrate between processes. It's deeply integrated with an underlying RDBMS and dependency injection container, so injected dependencies that are singletons or that can otherwise be recreated by the DI system given small amounts of data are captured at checkpoints using "coordinates". This means threads only create a few kilobytes of state and that could be optimized further too. It's quite a nice system with a lot of features that make distributed programming a lot easier. It plays in the same space as DBOS or Temporal but presents a model much closer to an idealized distributed computer, in particular because there's no log replay so you don't have to think in terms of idempotent operations.
I've also kicked around a lot of ideas for how to rethink desktop/productivity operating systems from the ground up given what AI now makes possible. There's lots that can be done here, some profound and some just convenient. I think a desktop OS that incorporates local models smartly would be a very interesting thing and might be the sort of change that's big enough to actually justify the effort. For example:
• Window titlebars got phased out because they were mostly redundant and just taking up space. But now local models could select titles smartly even for non-document apps.
• Icons are often abstract, pointless or missing (e.g. on the web). They also suffer from needing to be a uniform shape and due to the constantly shifting art styles Microsoft and Apple's designers want this year. But now local models could generate icons on the fly given the actual thing the app is doing, and they don't necessarily have to be square anymore. Icon themes could become powerful enough to be actually useful.
• CLI tools like "ls" could give you a short description of what's inside a directory, not just show you the name. Running "foo --help How do I configure you to use TCP sockets" could generate an answer on the fly by reviewing foo's man pages.
• There's lots of things you could try around keyboard focus, like gaze tracking. The way the mouse works could use a rethink in general, modern operating systems for various reasons have never really exploited Fitt's Law and with multi-screen it just got even worse.
And dozens of other ideas... those might not be in the "easier to understand/build/program" category though.
Maybe the first step is getting rid of the keyboard.
Genuinely asking, but why?
check out David Ackley's work
Clickable link for the curious: https://www.cs.unm.edu/~ackley/