Oz - The Generative OS

logo
a cache hit simulator for CS students
side by side view of a pdf and the notes
a custom note taking app built using AI
a speed reader built using AI

Inspiration

AI can generate software from scratch and it's getting increasingly better at it, but when it comes to editing existing software to fit your needs? AI flops here. Not because it is not able to do it. But because it lacks the interface to interact with the natural extension points of software.

So now, imagine an operating system where software exists as an extendable primitive. Something you can download, extend, and use based on your needs. Now your favourite PDF viewer could support inline annotation, your note taking app could organise your notes automatically and you can conjure pretty much any simulation to learn concepts visually.

Software has become more ephemeral and accessible than it used to be, and this operating system positions itself as a platform to host these neo-software that unlike old software, can be built and extended by pretty much anyone.

What it does

The primitive of our operating system is the file. Just like in your computers, a file can be anything: a PDF, a text file, a Powerpoint presentation, and even a piece of software.

You would never want to create files on your operating system from scratch. That's akin to buying a new computer and leaving all your data behind on your old computer. So, we made Google Drive our filesystem, now any files in your drive can be accessed from Oz and any files created in Oz... will appear in Google Drive. The bidirectional sync allows for Oz to become your go-to method of accessing files from your Google Drive, potentially even replacing the need to go to drive.google.com.

Circling back to our earlier point, a software is a file, just like how an executable is a file. When we create a piece of software within Oz, a file gets created and stored under your Applications folder. The mimetype for this file is specialised so that when you click on it, Oz opens up a window with the software running.

Now here's the magic: how do we get these software in the first place? There are two ways. The first way is simply asking for it. You do Cmd+G and it will open up a prompt field, and you simply describe what you want, and within a few seconds, you get your software running on the same window. There are two modes for software generation in this way: one is a quick method where an LLM one shots your application, and a second mode where the LLM is used as an agent with access to skills like data visualisation to enable better software generation. The choice of modes depends on how complex your software is.

The second way of getting access to software is through the marketplace. People can publish their generated application up into the marketplace, and anyone else with access to Oz, can download and use it. This enables a creator economy for not just typical static media, but also executables which aligns with the trend of software becoming commoditised.

With pretty much any software that can be generated accessible to you, what else can you ask for? You can ask for it to be more relevant to your specific needs. Simply Cmd+G again and write your prompt to edit the software. Your todo list doesn't have priority levels? Just ask for it. Your calculator doesn't have calculations for permutations and combinations? Just ask for it. The changes will persist across Oz sessions, meaning you can always come back later and see the same software that you left behind. Not just that, you technically created something, and that means you can publish it. Cmd+G again and click on Publish, now you have your own piece of software out there that others might find useful.

The question now would be: how powerful can my software be? The answer to that is: Really powerful. Typically executables can access OS syscalls to access the filesystem, read files, create new files etc. We need to provide the same insane ability to the software generated within Oz. So we created an OzSDK by mimicing the syscalls you might find on Linux. The LLM is then taught how to use these functions, and it can generate software that calls these functions to manipulate the filesystem.

Believe it or not, we can go even meta than this. What if the AI generated software can call an LLM itself. That's like code generating code (metaprogramming). We also provide an AI SDK in the OzSDK for the agent to be able to call an AI model within the software it generates. So now, you even have access to ability to generate chatbots of your choice.

With these primitives in place, you can build pretty much anything imaginable and use it as software within Oz.

How we built it

As complex as the project sounds, with the right constraints and scope, the project becomes tractable.

The ability of handle primitives is directly extended from Google Drive. Oz can read, write, move, rename and list files from within Drive. The LLM used is OpenAI GPT-5.2-chat-latest which handles the generation of one shot software. And the agent also uses the same model but with access to skills that enable it to generate better code.

Challenges we ran into

the WiFi was slow at times 🫡 there were minor hiccups along the way, like weird UI rendering, missing APIs, or issues with image encoding, but most were resolved swiftly