SynthOS: An AI Powered Interactive Shell Experience

SynthOS is an interactive shell experience powered by generative AI, featuring a user interface that is entirely AI-generated. Similar to a wiki, it organizes everything into pages, but with a twist: these pages are self-modifying and can transform into anything. Each page includes a chat panel and a content viewer. Entering a command into the chat panel prompts the configured Large Language Model (LLM) to completely rewrite the current page. The page can morph into anything—from providing answers to questions to becoming a tool that assists you with complex tasks. It supports the latest language models like Claude-Opus-4.5 and GPT-5.2.

SynthOS has access to tools in the form of APIs and scripts. Built-in APIs enable SynthOS to read and write objects to local storage or make additional generative AI calls. Scripts are user-defined extensions that allow SynthOS to perform local actions on your machine. You can add scripts that let SynthOS start a build, make a Git commit, or run a cURL command.

Version 0.4.0 is coming... Create complex presentations in less then 2 minutes. Star Trek Computer Deck

You can create anything you want from animations:

To games:

To developer tools:

SynthOS is like a wiki for apps. You can save the apps you create to your pages directory;

Installing SynthOS

To get started using SynthOS you'll need to first install a recent version of Node.js. I use version 22.20.0 but any version >20 should work.

Open a terminal window and run the following commands:

npm install --global synthos
synthos start

This will install the CLI and start the SynthOS server running. This terminal window needs to stay open to keep the server running. You should see a message saying SynthOS's server is running on http://localhost:4242. You can open your browser to that link and you should land on the settings page.

Configuring Your Model

When the server first runs it's going to show you a settings dialog. You'll need to pick the model you;d like to use and configure it with a developer key.

For Opus (recomended) you'll want to sign up for a developer account at Anthropics Developer Platform You can then generate an API key here. For GPT-5.2 you can sign up for an OpenAI Developer account and then generate an API key here

Using SynthOS

Once you've configured your model you will be then sent to the builder page. You can then specify any thing you want to create and it will be rendered to the display port.

You can make as many changes as you want to the app and you have controlls above the chat box that let you save the app to the pages gallery, reset the view port, or navigate to the pages gallery:

Each saved page is as stand alone HTML page that can be found in a .synthos folder in the directory where you started the server, There are system pages which can't be deleted but you can save changes to them and SynthOS will use those over the defaults. If you wish to delete a page/app just delete it from your .synthos folder:

Application Templates

There are a set of pre-built application templates that give you a good starting point.

The [application] template is great for creating tools:

The [markdown] template has a rich built-in markdown viewer:

The [sidebar] template allows for rich content that's not markdown based:

The [split-application] template has two panes with a movable splitter:

API Explorer

One of the more powerful capabilities of SynthOS is that it has built in APIs for things like storage that you're apps can use to persist data. You can use the API Explorer to test the API's out:

Script Editor

You can also create custom scripts that your apps can invoke vi a scripts API:

Contributing with Claude Code

This repo includes a SHARED-MEMORIES.md file that gives Claude Code project-level context (architecture, APIs, folder structure). When you first clone the repo and start working with Claude Code, ask it:

"Initialize my personal MEMORY.md file using SHARED-MEMORIES.md"

Claude will create a personal MEMORY.md inside ~/.claude/projects/ with the shared knowledge as a starting point.

You can then personalize it by telling Claude:

• What OS you're on
• Where your checkout lives on disk
• Your editor and path conventions (e.g. VS Code with forward-slash paths)

These personal details stay in your MEMORY.md and are never checked in.

Here's an example of what a developer's MEMORY.md might look like:

# Synthos — Developer-Specific Memory

Shared project knowledge (architecture, APIs, folder structure, etc.) lives in
`SHARED-MEMORIES.md` at the project root. This file holds per-developer context only.

## Session Start
- **Always** read `SHARED-MEMORIES.md` from the project root at the start of every new coding session to load project-level context.

## Environment
- **Windows** machine
- When opening files in VS Code, use `code "C:/source/synthos/<path>"` (quoted, forward slashes)
- **Auto-run VS Code launches** — when opening files in VS Code via `code`, run the Bash command without asking for permission

Note: The ## Environment section is entirely developer-specific. Your entries will differ based on your OS, editor, file paths, and workflow preferences. This is the right place to capture anything unique to your local setup.