01/OS

New: The 8th Architecture

/01
    start.sh # entrypoint, runs server, device, llm
    server.py # uses tts and stt if it must, exposes "/"
    device.py # also uses tts and stt, hits "/"
    llm.py # starts an openai-compatible server
    model.llamafile
    i.py # creates an interpreter which server just imports
    tts.py
    stt.py
    /conversations
        user.json
    /skills # files in here will run in the 01's interpreter
        schedule.py
        ...

This is flatter and simpler.

Device handles the device — i.e. everything the user interacts + watching the kernel + running code (which produces computer LMC messages) if DEVICE_EXECUTE_CODE is true. Runs TTS and STT, sends LMC messages to "/".

Server serves "/", a websocket that accepts user LMC messages and sends back assistant LMC messages. Runs code (which produces computer LMC messages) if SERVER_EXECUTE_CODE is true.

Llm starts an OpenAI-compatible server with model.llamafile. Downloads a heavily quantized Phi-2 if model.llamafile doesn't exist.

I creates an interpreter object. This is where you configure the 01's behavior.

What is this?

This is the operating system that powers the 01.

No, I mean what's this folder?

It's the diff between 01OS and Ubuntu.

01OS should be a customized version of Linux. Ubuntu is popular, stable, runs on lots of different hardware. (open question: Should this be Xubuntu, which is lighter? or something else?)

We want to build on Ubuntu by customizing the stable branch programatically, not by forking it — which would mean we'd have to maintain the underlying OS, merge in security patches, etc. Yuck.

This folder contains everything we want to change from the base Ubuntu. A folder here represents a folder added/modified at the root. You can think of it like the diff between 01OS and Ubuntu.

I imagine we'll use something like Cubic to then press this + Ubuntu into an ISO image.

Setup & Usage

Clone this repo, then run OS/01/start.sh.

Structure

start.sh

The start script's job is to start the core and the app (in full-screen mode).

/core

The core's job is to:

1. Set up the language model
2. Set up the interpreter
3. Serve the interpreter at "/"

/app

The app's job is to be the interface between the user and the interpreter (text in). This could be text only, audio, video, who knows, but it becomes LMC messages or plain text.

For the first version, I think we should just handle audio in/out. So the app's job here is to:

1. Be a fullscreen app for the user to use 01
2. Turn the user's speech into text and send it to "/"
3. Turn the interpreter's text into speech and play it for the user

Changes to Linux

We need to make the following changes:

1. Modify the bootloader to just show white circle on black
2. Auto start the start script, start.sh
3. Put detectors everywhere, which will put LMC Messages from the computer into /01/core/queue. Michael suggested we simply watch and filter the dmesg stream (I think that's what it's called?), so I suppose we could have a script like /01/core/kernel_watcher.py that puts things into the queue? Honestly knowing we could get it all from one place like that— maybe this should be simpler. Is the queue necessary? How about we just expect the computer to send computer messages to the websocket at /? Then yeah, maybe we do have redis there, then instead of looking at that folder, we check the redis queue...
4. (open question: should we do this? do we want the first 01 to be ready for GUI control?) Make the display that's shown to the user (and filled with the app) the secondary display. The primary display will be a normal Ubuntu desktop, invisible to the user. Why? So the interpreter can control the primary display "under the hood".