[opensourcedex]

sidex is a free, open source ides & code editors project written in TypeScript and released under MIT. It has 2,954 GitHub stars, 238 forks and 50 open issues, and was last pushed 23 days ago. On this registry it ranks #14 of 14 tracked projects in IDEs & Code Editors, with 5 head-to-head comparisons available.

What is sidex?

SideX is a port of Visual Studio Code that replaces Electron with Tauri — a Rust backend running against the operating system's native webview — for developers who want the VS Code workbench, editor, terminal and Git tooling without the bundled browser that normally comes with them.

What it is

SideX sits in the Developer Tools / IDEs & Code Editors category, is written in TypeScript with a Rust backend, and is released under the MIT licence. It is a port of Visual Studio Code that replaces Electron with Tauri, keeping the same TypeScript workbench, the same editor, the same terminal and the same Git integration. Rather than bundling a browser engine, it uses the webview already present on the machine — WKWebView on macOS, WebView2 on Windows — which is shared across applications. The project's short description puts it as "VS Code rebuilt on Tauri. Same architecture, 96% smaller. Early release."

The concrete problem it solves is memory. VS Code's memory usage comes almost entirely from its bundled Chromium rather than from the editor itself, and Tauri removes that duplication by reusing a system webview that costs almost nothing extra. The stated target is under 200 MB at idle on macOS, where WKWebView is shared with Safari and the savings have been tested most. On Windows the picture is more nuanced, because WebView2 memory can appear higher depending on how it is measured, and the project describes this as an active area in the Tauri ecosystem. Real benchmarks are promised once the app is stable enough for them to be meaningful.

Key capabilities

  • Monaco editor with syntax highlighting and basic IntelliSense, plus multiple built-in themes drawn from the VS Code catalogue.
  • Integrated terminal backed by a full PTY implemented in Rust, with shell detection, resize and signal handling.
  • Git integration covering status, diff, log, stage, commit, branch, push/pull/fetch, stash and reset.
  • File explorer that opens folders and supports create, rename and delete, alongside file watching, file search, full-text search and a Rust-backed search index.
  • SQLite storage and document management, including autosave, undo/redo and encoding handling.
  • Extension installation from Open VSX, and native OS menus on macOS, Windows and Linux.
  • Built-in AI agent for chat, inline diffs, shell commands and multi-file edits, with no SideX account of any kind and a bring-your-own model provider model.

Who uses it and how

  • macOS developers working under memory pressure, where the shared WKWebView is the tested path to lower idle RAM.
  • Windows and Linux users who want the same workbench with native OS menus, accepting that the Windows webview memory story is more nuanced.
  • Developers running models locally: a keyless local model server on loopback — Ollama, LM Studio, llama.cpp or vLLM — is detected automatically, so no hosted provider is required.
  • Individuals and teams that already hold a Claude Code or Codex CLI login can opt in per provider; usage then counts against that subscription.
  • Users who prefer a billed key add a provider and model ID under Settings → Models, with Anthropic called through its native Messages API (/v1/messages) and every other provider treated as OpenAI-compatible (/chat/completions).

Getting started

The README's Getting Started section is the entry point for building and running SideX; the material available here does not name a published package, container image or compose file. Community support runs through the project's Discord.

How it compares

The nearest named point of comparison is VS Code itself: SideX keeps the same TypeScript workbench, Monaco editor and Open VSX extension source, but swaps Electron and bundled Chromium for Tauri and the system webview. Everything that is normally paid for in the AI path is replaced here by keys the user already owns or a local model server, and credentials are passed only through the process environment of the agent server rather than written to a config file. The trade is maturity rather than licence or cost.

When to use it — and when not to

Use it when a lighter macOS editor matters more than a finished IDE, and when owning your own model credentials is the point. A self-hoster still has to build the Go agent server (sidexai/sidex-server); if that binary is not built, the rest of the editor works but the chat panel reports itself as disconnected. Avoid it if you need the extension host or debugger in production, since both are still in progress, or if you need published benchmarks before deciding — this is an early release with no meaningful numbers yet.

project readme (upstream, from github) — read inline

SideX

VSCode's workbench, without Electron.

Discord Contributing MIT License Built with Tauri



Why · What's Working · AI Agent · Getting Started · How It's Built · Contributing · Discord

SideX is a port of Visual Studio Code that replaces Electron with Tauri — a Rust backend and OS's native webview. The same TypeScript workbench, the same editor, terminal, and Git integration, running without a bundled browser.

Early release. Core editing and the terminal are solid. The extension host and debugger are still in progress. See What's Working for the full picture.

Why

VSCode's memory useage is almost entirely from its bundled Chromium, not the editor itself. Tauri replaces that with the webview already on your system — WKWebView on macOS, WebView2 on Windows — shared across apps and costing almost nothing extra.

RAM savings are most tested on macOS, WKWebView is shared with Safari. On Windows the picture is more nuanced — WebView2 memory can look higher depending on how it's measured, and it's an active area in the Tauri ecosystem. The target is under 200 MB at idle on macOS. We'll publish real benchmarks once the app is stable enough for them to be meaningful.

What's Working

Solid:

  • Monaco editor with syntax highlighting and basic IntelliSense
  • File explorer — open folders, create, rename, delete
  • Integrated terminal — full PTY via Rust, shell detection, resize, signals
  • Git — status, diff, log, stage, commit, branch, push/pull/fetch, stash, reset
  • Themes — multiple built-in themes from the VSCode catalogue
  • Native OS menus (macOS, Windows, Linux)
  • Extension installation from Open VSX
  • File watching, file search, full-text search, Rust-backed search index
  • SQLite storage, document management (autosave, undo/redo, encoding)
  • Built-in AI agent — chat, inline diffs, shell commands, multi-file edits; bring your own model provider, no account needed (see AI Agent)

AI Agent

SideX has a built-in coding agent, and it needs no SideX account of any kind — no sign-in, no identity provider, no hosted service in the path. Every request goes from the editor to a server running on your own machine, and from there straight to whichever model provider you point it at.

How it starts

On launch, the app spawns its own agent server (sidexai/sidex-server, written in Go) as a child process bound to 127.0.0.1 on a random free port. It's supervised from src-tauri/src/server.rs and stopped when the app exits. If the server binary isn't built, the rest of the editor still works — the chat panel just reports itself as disconnected.

Bring your own model

There are no built-in model presets. You add a provider and a model ID yourself in Settings → Models. Credentials are resolved in this order, first match wins (see src-tauri/src/commands/providers.rs):

  1. a key entered in Settings → Models
  2. an environment variable already in your shell (ANTHROPIC_API_KEY, OPENAI_API_KEY, and so on — see .env.example for the full list)
  3. an existing Claude Code or Codex CLI login on your machine, opt-in per provider
  4. a keyless local model server on loopback — Ollama, LM Studio, llama.cpp, or vLLM — detected automatically

Anthropic is called through its native Messages API (/v1/messages); every other provider, including local servers, is treated as OpenAI-compatible (/chat/completions).

Credentials reach the agent server only through its process environment (SIDEX_PROVIDER__KEY / _BASE_URL / _AUTH), set fresh each time the app starts or restarts it. They're never written to a config file and never sent to the webview.

Claude Code / Codex CLI logins are optional, per provider, and off by default. SideX talks to Anthropic and ChatGPT with the same first-party client identity those CLIs use, so a connected login can run models. Usage still counts against that subscription. A billed API key in Settings → Models is the path that does not depend on a CLI login or the provider's consumer terms.

Security: this server runs commands on your machine

The agent server executes shell commands and edits files on your behalf — that's what lets it act as an agent. Binding it to 127.0.0.1 only is a deliberate security boundary, not an accident: nothing else on your network can reach it.

SIDEX_BIND_ADDR can widen that if you need to, but the server refuses to start on a non-loopback address unless you explicitly opt in with SIDEX_ALLOW_UNAUTHENTICATED=1. Don't set that unless you understand the exposure and have your own authentication sitting in front of it — an open port on this server means arbitrary code execution for whoever can reach it.

Building the agent server

The agent server needs Go 1.26 or later to build (see sidexai/sidex-server/go.mod):

cd sidexai/sidex-server
go build -tags fts5 -o sidex-server ./cmd/server

The app looks for a binary at that path automatically when running from a source checkout. Without it, everything except the chat panel works normally. See sidexai/sidex-server/.env.example if you'd rather run the server yourself instead of letting the app manage it.

Getting Started

Run in Development

git clone https://github.com/Sidenai/sidex.git
cd sidex
npm install
npm run tauri dev

Build from Source

npm install
npx tauri build

npx tauri build runs the frontend build for you (npm run build), which already raises Vite's Node heap limit to 12 GB internally — no NODE_OPTIONS needed on a normal machine. If you still hit an out-of-memory error, raise it further yourself with NODE_OPTI before the command.

First build takes 5–10 minutes (Rust compile time). Pre-built binaries are not distributed yet.

Everything above runs standalone, with no account and no setup. Want the chat panel connected too? See AI Agent above — building the agent server is a separate, optional step.

How It's Built

SideX maps VSCode's Electron architecture onto Tauri layer by layer:

VSCode (Electron) SideX (Tauri)
Electron main process Tauri Rust backend
BrowserWindow WebviewWindow
ipcMain / ipcRenderer invoke() + Tauri events
Node.js fs, pty, etc. Rust commands (std::fs, portable-pty)
Menu / Dialog / Clipboard Tauri plugins
Renderer (DOM + TypeScript) Same — runs in native webview
Extension host Sidecar process (in progress)

The TypeScript frontend is a direct port of VSCode's workbench. The Rust backend is in src-tauri/src/commands/ and handles everything that would have been a Node.js native module: file I/O, terminal PTY, Git, file watching, search indexing, SQLite, and process management.

readme truncated — read the full docs on github

Frequently asked questions

Is sidex free to use?

sidex is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does sidex do?

VS Code rebuilt on Tauri. Same architecture, 96% smaller. Early release.

What is sidex written in?

sidex is primarily written in TypeScript. Its source is publicly available at https://github.com/Sidenai/sidex, and it has 2,954 GitHub stars.