SozoIDE

Why SozoIDE

• One binary, three systems. sozo runs the same on Windows, macOS and Linux, on x86_64 and ARM64, and installs with a native installer.
• Fast while you type. Highlighting is redone only from the line you changed (at most a few tens of milliseconds a key on long files), a frame draws in under a millisecond, and language servers, Git, builds and videos run in their own processes or threads: the editor never waits for them.
• Your terminal's look. SozoIDE has no colours of its own: it draws with the 16 ANSI colours of your terminal theme and shows every shortcut the way your system types it.
• Nothing to hunt for. Help's Dependencies tab lists every tool it and your projects use (git, ffmpeg, Rust, Node.js, Python, Java, Go, Docker, CMake, the language servers and debuggers) with its version, and installs or updates one with your package manager when you press Enter; its row changes by itself once it is done, and a language server installed there starts at once. Nothing is installed without asking.
• Live. What you do elsewhere shows at once: the open Source Control follows commits and changes made in a terminal, the Database reads its tables again after CREATE, ALTER or DROP, and the Explorer, the open tabs and the Git marks follow the disk.

Features

Explorer

• Every file and folder with an icon for its type, in your terminal's colours.
• Right-click to create a file (its icon follows the extension you type) or a folder, to rename, to delete (it asks first), and to cut, copy and paste files and folders; Ctrl+X, Ctrl+C and Ctrl+V do the same on the selected entry. A copy in the same folder becomes name copy, name copy 2…; a move never overwrites anything.
• Properties in the same menu: kind, location, size, what a folder contains, when it was created, modified and last opened, and its permissions. A big folder says Calculating… while it is counted in the background, then shows its size in KB, MB, GB or TB.
• Git marks, as in VS Code: the Source Control letter (M, A, U, D, R…) at the right of every changed file, its name in the same colour, and * on a folder with changes inside.
• The tree follows other programs: what they create, rename or delete shows up within a second.
• Long names scroll sideways with Shift and the mouse wheel (or a sideways wheel), with a bar along the bottom.
• Each folder opens as you left it, like VS Code: the folders you had open, your tabs with their cursors, the active tab and the panels.

Editor

• Tabs with a scrolling tab bar; drag a tab to an edge of the editor to split it side by side or stacked, each side with its own tabs.
• Git marks in the margin, as in VS Code: a green bar on lines added since the last commit, a yellow one on lines changed and a red mark where lines were deleted, also for edits not saved yet.
• Edits save themselves after two idle seconds and before you switch tabs or quit. A file changed by another program is read again (your unsaved edits are kept).
• Select with the mouse or Shift and the arrows, Ctrl+A for everything; copy, cut and paste with Ctrl+C, Ctrl+X, Ctrl+V or the right-click menu, through the system clipboard (and OSC 52 over SSH). Ctrl+Z undoes, a word or a paste at a time.
• Syntax highlighting for more than 30 languages, from Rust, Go, C, Java and Python to SQL, JSP, Astro and Mermaid, and for configuration files by their name (.env, Cargo.lock, .config, .properties, Dockerfile, Makefile, .gitignore…).
• Markdown drawn as you read it: headings, quotes, rules, framed code blocks, aligned tables with inline formatting, italic, bold and ==highlight==, and Mermaid diagrams in box-drawing characters (flowchart, sequence, class, state, C4, ZenUML, Kanban, Radar, Treemap and more). The source comes back under the cursor or the mouse.
• Ctrl+P finds in the file as you type and marks every match (◂ 3/12 ▸); Ctrl+Shift+P searches the whole folder in the background, groups the results by file and skips what .gitignore lists.

IntelliSense

Problems underlined in red (errors) or yellow (warnings), with the message of the cursor's line in the footer; suggestions with Ctrl+Space, and by themselves after ., ::, -> and the second letter of a word. Hold Ctrl and rest the mouse on a word for 2 seconds, or press Ctrl+K, to read its type and documentation in a small box; F12 or Ctrl+click goes to the definition, in a new tab when it is in another file (a list when there are several), Alt+F12 peeks at it in a box without leaving the tab, Shift+F12 lists every reference, and Alt+Left goes back. Right-click a word for the same questions: moving over one shows its answers in a small box beside the menu, and a click on an answer opens it. They come from the language server of each language, started when you open its first file; a file without one says so and edits as before. When the server is not installed, or cannot start, asking it something shows the command that installs it on your system; Enter runs it in the bottom terminal and, once the server is there, SozoIDE goes on with what you asked:

Language	Server
Rust	rust-analyzer
C, C++	clangd
Python	pyright
Java	jdtls
TypeScript, JavaScript	typescript-language-server
Go	gopls
Shell (sh, bash, zsh)	bash-language-server
YAML	yaml-language-server
PHP	intelephense
HTML, CSS, SCSS, Less, JSON	vscode-langservers-extracted
Lua	lua-language-server

Run

Ctrl+R saves everything, opens the bottom terminal and runs the file there with the tool of its language; a Cargo project or a Go module runs whole. The command stays in the shell's history, so you can run it again.

F7 builds the project of the open folder, Shift+F7 cleans it, Ctrl+F7 cleans and builds it and Ctrl+F5 runs it; Shift+F5 stops what it started. The project is found by its manifest, and only commands it really has are used:

Project	Build / Clean / Run
Cargo, Go	cargo build / clean / run; go build ./... / go clean / go run .
Node.js (package.json)	the build, clean and dev or start scripts, with npm, pnpm, yarn or bun by the lockfile
CMake, Make	cmake -S . -B build && cmake --build build, --target clean; make, make clean, make run when there are such targets
Maven, Gradle	mvn package / mvn clean; ./gradlew build / clean / run (Gradle's run with the application plugin)
.NET, Swift, Flutter, Dart	dotnet, swift, flutter, dart
Django, Laravel, Rails	manage.py runserver, artisan serve, bin/rails server
Docker	docker compose build / down / up --build; a lone Dockerfile builds and runs its image

The first time, a dialog shows the project, its folder, the file that says so and the command; Enter runs it in the bottom terminal. A folder with several projects (a frontend and a backend, say) asks which one. For anything else, put your own commands in .sozo.toml at the root of the project:

[tasks.run]
program = "python3"
args = ["serve.py", "--port", "8000"]
cwd = "backend"   # optional, from the project's root

Language	Command
Rust	cargo run (in a Cargo project) or rustc
C, C++	gcc/clang, g++/clang++
Python	python3 (python on Windows)
JavaScript, TypeScript	node; deno, bun or npx tsx
Java, Kotlin	java, kotlinc
Go	go run
Ruby, PHP, Lua, Perl, R, Swift, Dart, Zig, Haskell, Elixir, Julia	their own interpreter or compiler
Shell, PowerShell, Batch	bash, zsh, pwsh, cmd.exe

Debug

F9 puts a breakpoint (●) on the cursor's line. F5 saves, builds the file with debug symbols in the background (a Cargo project with cargo build, a single Rust, C or C++ file with rustc -g, clang -g or gcc -g) and starts the debugger; when it stops, the editor jumps to the line (▶) and a panel on the right shows the call stack, the variables and the program's output. F5 continues, F10 steps over, F11 steps into and Shift+F5 stops.

Language	Debugger (Debug Adapter Protocol)
Rust, C, C++	lldb-dap (comes with Xcode and LLVM), or GDB 14 and later (gdb -i dap)
Python	debugpy
Go	Delve (dlv dap)

Pictures, videos, 3D models and PDF

• Pictures (PNG, JPEG, GIF, WebP, BMP, ICO, TIFF, TGA, PNM, QOI, HDR), animated GIFs and videos (MP4, MOV, MKV, WebM, AVI, M4V) are drawn in half blocks in their own colours, two pixels a cell, on any terminal. Videos play through the system's ffmpeg at 15 frames a second, in your terminal's picture protocol when it has one (Kitty, Sixel, iTerm2), with sound through ffplay: a bar under the video shows the time and has buttons to play, pause, stop, seek, change the volume and the speed and fill the screen; click or drag the bar to seek, click the video to pause, and the wheel changes the volume.
• 3D models (.glb, .gltf) open in a tab, lit and with their colours: ←/→ turn them, ↑/↓ tilt them, +/- or the wheel zoom, and a drag turns them with the mouse.
• PDF files open one page at a time. A page with only text shows its text, sharp, to select, copy and search with Ctrl+P; a page with a picture, a diagram or another drawing shows whole as a small picture through your terminal's picture protocol (Sixel, Kitty or iTerm2), or half blocks without one.

Terminals

A bottom and a right terminal, each with its own shell, with scrollback on the mouse wheel or Page Up and Page Down. The bottom one opens up to three shells, each in a tab: click + for another one and the x of a tab to close it (one always stays). The right one always has two tabs. Ctrl+PageDown and Ctrl+PageUp switch tabs. Drag the mouse over a terminal to select its text: letting go copies it. Shift+Enter writes a new line without running it, as zsh, fish and tools like Claude Code expect (your terminal has to tell SozoIDE about Shift: kitty, WezTerm, Ghostty, iTerm2 and Windows do). Drag the dividers to resize every panel. On Windows the terminals need Windows 10 version 1809 or newer; on an older one SozoIDE opens without them.

Your own shortcuts

Every command that works anywhere or in the editor can have the key you choose: open Help (F1), click its key (or move to it with Tab and press Enter), then press the new keys, with Ctrl, Alt (Option on a Mac) or a function key. A key that another command had swaps with it, so no command is left without one. Your keys are saved in keys.toml in SozoIDE's settings folder and show everywhere: the footer, the panel titles, the tutorial and Help. Reset shortcuts [R] brings back the ones SozoIDE came with.

Source Control

Stage and commit, and scroll back through a timeline of every branch, each in its own colour with dots and merge lines: click a commit to slide in its files, and a file to see what was added (green), removed (red) or modified (yellow). Every branch in a tree grouped by remote and folder; click one to switch to it. The Launchpad shows your branch, its upstream, how far ahead and behind it is, and the staged, unstaged and untracked files. The diff numbers its lines, folds its hunks, goes side by side and moves to the next changed file. Pull is fast-forward only; rebase and checkout ask before they run.

Database

Connect to SQLite, PostgreSQL and MySQL and the tables and views appear on the left. Draw some as a diagram with their keys and relations, tick columns to build the query (group, count, sum, average, sort and filter) and get the SELECT with its joins in the SQL tab, ready to edit, copy or run with Ctrl+Enter or F5. The rows scroll both ways. Passwords stay in your system's keychain, never on disk.

A guided start

A short tutorial on the first start (skip it with Esc), and after an update a note with what is new in every version since the one you had. In About, Release notes [N] shows the notes of every version; Tab shows only what is new or only what was fixed. F1 lists every key in boxed sections; the footer shows what just happened.

Install

Download the installer for your system and open it. Then open a new terminal in any folder and run sozo .

System	Download	Install
macOS (Apple silicon)	SozoIDE-macos-arm64.dmg	Drag SozoIDE to Applications and open the app once: it offers to install the sozo command in /usr/local/bin.
Windows x86_64	SozoIDE-windows-x86_64.msi	Follow the setup wizard. Installs for your user only, without administrator rights, and adds sozo to your PATH.
Windows ARM64	SozoIDE-windows-arm64.msi	Same as x86_64.
Debian, Ubuntu	x86_64, ARM64 .deb	Open it in your software installer, or sudo apt install ./SozoIDE-linux-*.deb
Fedora, openSUSE	x86_64, ARM64 .rpm	Open it in your software installer, or sudo dnf install ./SozoIDE-linux-*.rpm
Other Linux	x86_64, ARM64 .tar.gz	Extract into a folder on your PATH.

The installers are not signed yet:

• macOS: if the app does not open, go to System Settings, Privacy & Security, and choose Open Anyway.
• Windows: if SmartScreen appears, choose More info, then Run anyway.

Each release includes SHA256SUMS.txt. Check a download with shasum -a 256 -c SHA256SUMS.txt --ignore-missing on macOS, sha256sum -c SHA256SUMS.txt --ignore-missing on Linux, or Get-FileHash on Windows.

Requirements

• A Nerd Font in your terminal for the icons.
• SozoIDE runs git (Source Control), curl (updates), ffmpeg with ffprobe and ffplay (videos and their sound) and the language servers instead of linking them. After a new installation and after each update the footer says what is missing; Help's Dependencies tab (F1, then Right) shows each one and installs it, after Enter, in the bottom terminal:

Tool	macOS	Windows	Linux
git, curl, ffmpeg	Homebrew	winget	apt-get or dnf (also recommended by the DEB and RPM packages)
rust-analyzer	rustup or Homebrew	rustup	rustup
clangd	Xcode command line tools	winget (LLVM)	apt-get or dnf
pyright, typescript-language-server	npm (or pip for pyright)	npm	npm
gopls	go install	go install	go install
jdtls	Homebrew	—	Homebrew
Debuggers	lldb-dap with Xcode; debugpy with pip; Delve with go install or Homebrew	lldb-dap with LLVM; debugpy with pip; Delve with go install	GDB with apt-get or dnf; debugpy with pip; Delve with go install
Rust, Node.js, Python, Java, Go, Docker, CMake	Homebrew	winget	apt-get or dnf

On Linux the command starts with sudo, which asks for your password in the terminal.

Usage

sozo                   # open the current folder
sozo path/to/project   # open another folder
sozo --help
sozo --version

These are the keys SozoIDE comes with; change them in Help.

Key	Action
Ctrl+B	Show or hide the Explorer
Ctrl+J	Show or hide the bottom terminal
Ctrl+Shift+B (macOS: Ctrl+Option+B, Linux: Ctrl+Alt+B)	Show or hide the right terminal
Ctrl+PageDown / Ctrl+PageUp (terminal)	Next / previous tab of the terminal
Click + / x (bottom terminal)	Another shell in a tab, up to three / close that tab
Drag the mouse (terminal)	Select text; letting go copies it
Shift+Enter (terminal)	New line without running it
Ctrl+G	Open or close Source Control
Ctrl+D	Open or close Database
Ctrl+P	Search the open file
Ctrl+Shift+P	Search the whole folder
Up / Down, ◂ / ▸ (search)	Previous / next result; Enter opens it selected
Right-click in the Explorer	New file, new folder, cut, copy, paste, rename, delete (after a confirmation), properties
Ctrl+X / Ctrl+C / Ctrl+V in the Explorer	Cut / copy / paste the selected file or folder (paste goes into the selected folder)
Ctrl+W	Close the active tab
Ctrl+Enter or F5	Run the SQL query
F1	Help with every command; Left / Right switch to the Dependencies tab and back
Up/Down, Enter, R (Dependencies)	Choose a tool; show its install or update command, then Enter runs it; check again
Click a key, or Tab and Enter (Help)	Change that shortcut: press the new keys; gives up, then resets them all

Motion

Panels grow from their divider, Source Control and Database draw in line by line, a tab comes in from its side, and dialogs open from their middle row with the rest of the screen dimmed. Transitions never hold up saving, commits or queries. In About the SozoIDE flower grows from its centre. Set SOZO_REDUCED_MOTION=1 to turn them off.

Updates

When a newer release is out, SozoIDE tells you at startup. Press Enter (or U) to update: SozoIDE downloads the installer for your system, installs it and restarts in the same folder. Press S to skip that version, or Esc to decide later. On Debian, Ubuntu and Fedora the update runs sudo, so it asks for your password. Set SOZO_NO_UPDATE_CHECK=1 to turn the check off. The first start after an update shows what the new version brings.

Privacy

On its first start SozoIDE counts the installation once: it downloads the small SozoIDE-<system>-<arch>.installed.txt file of its release, and GitHub's public download counter goes up by one. The first start after an update does the same with SozoIDE-<system>-<arch>.updated.txt. That counter only knows the system, the architecture and the version; nothing about you or your files is sent, and SozoIDE has no server of its own. Set SOZO_NO_TELEMETRY=1 to turn both off. The startup check for updates also asks GitHub for the latest release (SOZO_NO_UPDATE_CHECK=1 turns it off).

Build from source

You need Rust stable and Git.

git clone https://github.com/vritik246800/SozoIDE.git
cd SozoIDE
cargo build --release
./target/release/sozo .

Before sending changes, run:

cargo fmt --check
cargo clippy --all-targets -- -D warnings
cargo test

Native packages

System	Command	Output
macOS	bash packaging/build-macos.sh	Apple silicon .dmg in target/package/macos
Linux	bash packaging/build-linux.sh	.deb, .rpm and .tar.gz in target/package/linux
Windows	powershell -ExecutionPolicy Bypass -File packaging/build-windows.ps1	.msi in target/wix

Packaging tools are installed into target/tools, never globally. bash packaging/test-install.sh (macOS, Linux) and packaging/test-install.ps1 (Windows) install the package the way a user would and check sozo --version.

Website

cd site
npm ci
npm run dev

Project layout

src/          the application:
  app/        state, keys and your own shortcuts, mouse, Explorer, IntelliSense list, project tasks and Dependencies, each folder's session
  editor/     text, highlighting, Markdown, Mermaid, PDF, search
  lsp/        language server client (JSON-RPC over stdio)
  run/        the command Ctrl+R runs, and the project F7, Shift+F7, Ctrl+F7 and Ctrl+F5 build, clean and run
  debug/      the debugger client (Debug Adapter Protocol)
  media/      pictures, GIFs, videos and 3D models in half blocks
  terminal/   the PTY terminals and their tabs
  git/        Source Control
  database/   SQLite, PostgreSQL and MySQL
  update/     updates and Help's Dependencies tab
  ui/         drawing
  animation/  transitions
tests/        CLI, end-to-end and interaction tests in a real PTY
packaging/    native installers for Linux, macOS and Windows
site/         landing page (Astro), published to GitHub Pages; site/scripts captures its SozoIDE screens
assets/       logo
.github/      CI, release and Pages workflows, and repository rulesets
.githooks/    local pre-commit and pre-push hooks

Contributing

• Development happens on the preview branch. main only changes through pull requests with green CI.
• Open pull requests against preview.
• After cloning, turn on the local hooks: git config core.hooksPath .githooks
• Commit messages start with create:, update:, fix: or docs:, followed by a short summary in English.

Releases

1. Raise version in Cargo.toml on preview and merge it into main through a pull request.
2. Tag main with the same version and push the tag: git tag v0.1.0 && git push origin v0.1.0
3. The Release workflow builds every installer, installs it on its own system, and publishes the release with install notes and SHA256SUMS.txt. Package names carry no version, so releases/latest/download/<name> always points at the newest one.
4. Check that every download link on the website now delivers the new version: bash packaging/check-downloads.sh

Security

Report vulnerabilities privately on GitHub, under Security, Report a vulnerability. Please do not open a public issue for them.

License

Apache License 2.0 © Vritik Valabdas