00_athva.md

v0.1.0 · MIT · unreleased

अथवा athva · अथवा — "or else, another way"

Today, I am open-sourcing Athva · One of India's first open-source code editors 🇮🇳

Tell it the task.
Watch your editor
build it for you.

This is not autocomplete. Athva's agent reads your entire repo, opens the terminal, runs git, drives real VS Code extensions — and keeps looping until the job is done. A full native IDE with an AI that works like a teammate, not a suggestion box. Made in India. MIT-licensed. Yours forever, for ₹0.

Agent with real hands — fs · git · shell Runs your VS Code extensions Any model — Claude, GPT, Gemini, local Native Rust + Tauri 2 speed ₹0 · MIT · free forever

00_download.sh

pick your OS

Download

Get Athva on your machine — free, right now.

● detected — this one's yours

⌘

macOS

Apple Silicon & Intel · macOS 11+ · .dmg installer

Download .dmg

Intel .dmg

● detected — this one's yours

⊞

Windows

Windows 10 / 11 · 64-bit · installer

Download .exe

.msi

● detected — this one's yours

🐧

Linux

Any distro via AppImage · Debian/Ubuntu · Fedora

Download .AppImage

.deb .rpm

Fetching the latest release…

01_bharat.md

जय हिन्द

Built in India · for the world

Every great developer nation deserves its own tools.

Millions of Indian developers power the world's codebases every day — yet almost every editor we open was imagined somewhere else. Athva is a small act of belief: that world-class developer tools can be dreamed, designed, and shipped from India — and open-sourced, so they belong to everyone.

From India, not just in India. Conceived, architected, and built here — the Devanagari on the logo isn't decoration, it's the name.
Open by conviction. The tools a nation's developers depend on shouldn't be black boxes owned abroad. MIT-licensed, auditable, forkable.
An invitation. If you've ever wanted an Indian project on your contribution graph you're proud of — this is it. जय हिन्द, and happy hacking.

01_problem.md

why now

The problem

AI coding tools stopped at the chat box.

Bolted on

Extension, not editor

Most AI coding tools are a panel wedged into an existing IDE — the agent can suggest, but the editor wasn't designed around it.

Closed loop

Can't touch your tools

Terminal, git, extensions, debuggers — the agent sees text, not the environment a developer actually works in.

Locked in

One vendor, one model

Proprietary editors tie you to a single provider's roadmap, pricing, and model choice.

02_what.md

the idea

What we built

The editor is the agent's environment.

Athva rebuilds the IDE from the ground up so the agent loop is a first-class citizen — not a plugin talking to an API over a wall.

Native, not embedded. Rust + Tauri 2 core, so the agent's tool calls run as real system operations — file I/O, shell, git — not sandboxed approximations.
Runs real VS Code extensions. A from-scratch vscode-shim re-implements the extension host API, so the ecosystem you already use just works.
Model-agnostic by design. Anthropic, OpenAI, Google, Mistral, and more — swap providers without leaving the editor.

screenshots_01.png

the app, not a mockup

What it looks like

A real editor shell — projects, files, terminal, agent, all native.

Athva welcome screen showing recent projects and quick actions

Welcome — recent projects, clone, quick access

Athva editor shell with file explorer, terminal, and AI chat panel

Editor shell — explorer, terminal, Athva AI chat panel

screenshots_02.png

zero learning curve

Editor experience

Feels exactly like your normal editor — because it is one.

Explorer, tabs, minimap, hover tooltips with go-to-definition, integrated terminal, git branch in the status bar — everything is where your muscle memory expects it. You don't relearn an editor to get the agent; you just open your project and keep coding.

Athva editing main.ts with file explorer, hover tooltip showing module definition, minimap, and status bar — a familiar full editor experience

main.ts open in Athva — hovers, definitions, minimap, terminal: the editor you already know

screenshots_03.png

extensions in the wild

The shim, in action

Your VS Code extensions. A built-in browser tab. In the same window.

Athva extensions marketplace showing installed VS Code extensions including Claude Code

Extensions — real VSIX packages, installed and running

Athva built-in browser tab open to YouTube inside the editor

Browser tabs — open docs or the web without leaving the IDE

03_agent-loop.ts

core loop

How it works

One clean loop. No hidden state machine.

runAgentLoop() → streamAgentTurn() // native tool_use / function_calling over SSE → executeToolCalls() // real fs, git, shell, search — via Tauri → loop until done or MAX_TURNS // no legacy phase-based workflow. one path, same for every provider.

Anthropic / OpenAI

→

native tool_use

→

Tauri command

→

your repo

04_vscode-shim.md

compatibility

Under the hood

We re-implemented the VS Code API. On purpose.

Rather than lock users into a brand-new, empty ecosystem, Athva ships a real extension host — vscode-shim — so extensions built for VS Code run largely unmodified.

SCMSource control providers, diffing, staged/unstaged state
LANGLanguage providers — completions, diagnostics, hovers
DEBUGDebug adapters and tracker lifecycle
TERMTerminal profiles and link handlers
NBNotebook rendering, kernels, cell status bars
CMDCommand execution, webviews, custom URI schemes

05_providers.json

model support

Bring your own model

No single vendor owns your agent.

Native tool use

Anthropic

tool_use blocks over SSE

Native tool use

OpenAI

function_calling over SSE

Compatible

Google · Mistral · MiMo

Streaming with tool-call fallback parsing

Switch providers mid-project. Point it at a local model later. The agent loop doesn't care.

06_why-oss.md

license: MIT

Why open source

The editor you trust with your repo shouldn't be a black box.

Trust. An agent with shell and filesystem access is worth auditing — so you can.
Speed. The extension ecosystem is enormous. We can't cover it alone; contributors can.
Direction. No roadmap dictated by a fundraising story — built in the open, shaped by the people using it.

07_status.md

honest state

Where it stands today

Early. Working. Moving fast.

v0.1.0

pre-release

5

model providers wired in

~30k

lines, core modules + shim

10

native agent tools

The agent loop, native tool-use, and the core extension shim work today. Coverage of the long tail of the VS Code API is ongoing — that's exactly the kind of gap contributors close fastest.

08_contribute.md

good first issues welcome

Get involved

The shim needs more of the API. The agent needs more tools.

Good first PR

Extension host coverage

Pick an unimplemented VS Code API in vscode-shim and wire it up against the compatibility checklist.

Good first PR

New agent tool

Add a tool definition + Tauri command + executor case — the pattern is consistent across all ten.

Good first PR

Provider adapter

Wire native tool-use for a provider currently on the regex fallback path.

09_start.sh

let's go

Try it

Clone it.
Break it.
Send a PR.

git clone https://github.com/devjs1000/athva-agent cd athva-agent pnpm install pnpm tauri dev

★ Star on GitHub Open an issue @devjs1000 on GitHub

Tell it the task.Watch your editorbuild it for you.

Get Athva on your machine — free, right now.

Every great developer nation deserves its own tools.

AI coding tools stopped at the chat box.

The editor is the agent's environment.

A real editor shell — projects, files, terminal, agent, all native.

Feels exactly like your normal editor — because it is one.

Your VS Code extensions. A built-in browser tab. In the same window.

One clean loop. No hidden state machine.

We re-implemented the VS Code API. On purpose.

No single vendor owns your agent.

The editor you trust with your repo shouldn't be a black box.

Early. Working. Moving fast.

The shim needs more of the API. The agent needs more tools.

Clone it.Break it.Send a PR.

Tell it the task.
Watch your editor
build it for you.

Clone it.
Break it.
Send a PR.