DEV Community: Amritanshu Amar

PunamIDE — I Built a Full AI-Powered Desktop Code Editor From Scratch

Amritanshu Amar — Fri, 10 Jul 2026 13:35:14 +0000

This is a submission for Weekend Challenge: Passion Edition

What I Built

PunamIDE is a fully native AI-powered desktop code editor built with Tauri 2, React 19, and Monaco Editor — the same editor engine that powers VS Code.

This isn't a chat wrapper or a plugin. It's a complete IDE with:

Multi-provider AI — 7 providers (Gemini, Anthropic, OpenAI, Groq, OpenRouter, Ollama, Mistral) with real-time cost tracking in USD and INR
Agentic tool-calling — AI can autonomously read files, write code, apply patches, run commands, and iterate until the task is done
Multi-agent orchestration — spawn specialized agents (implementation, test, security, architecture, refactor) running in parallel with strict permission boundaries
Technical debt analyzer — AST-powered analysis using Tree-sitter for JS, TS, Python, and Rust — dependency graphs, dead code detection, circular dep finder, coupling analyzer, debt scoring
Architecture engine — define your own rules, validate every AI-proposed patch against them before it touches disk
Real PTY terminal — actual shell via Rust's portable-pty, not a fake simulation
Full GitHub integration — repos, issues, PRs, Actions, gists — all from inside the editor
Local embeddings — 100% offline semantic search via @xenova/transformers, no API key needed
Inline autocomplete — FIM / chat-fallback ghost text completion with per-model auto-detection
DAP debugger — Debug Adapter Protocol via Rust backend

My goal was to build the IDE I always wanted — one where AI is deeply integrated at every layer, not bolted on as an afterthought, and where everything runs locally on your machine.

Demo

🌐 Website: punamide.com
📦 Download v2.1.2: github.com/punamide/punamide-downloads/releases/tag/v2.1.2
💬 Discord: discord.gg/PFp9KWY3eY
🐦 X: @PunamIDE

Main Interface

AI Agent in Action

Technical Debt Dashboard

Architecture Dependency Graph

GitHub Integration

Debugger

Snapshot Manager

BYOK — Bring Your Own Key

Code

mandaloriantrader / PunamIDE

AI-powered native desktop code editor — Tauri 2, React 19, Monaco Editor. Multi-provider AI, agentic tool-calling, technical debt analysis, and full IDE features.

PunamIDE v2.1.2

A native AI-powered code editor built with Tauri 2, React 19, and Monaco Editor.
Multi-provider AI, agentic tool-calling, technical debt analysis, and a full IDE experience — all running locally on your machine.

PunamIDE is not just a chat wrapper around an AI — it's a full desktop IDE with a native Rust backend, real terminal, Git integration, GitHub management, DAP debugger, local embeddings, architecture analysis, and a multi-agent system that can autonomously read, write, and refactor your codebase.

Screenshots

Main Interface

BYOK — Bring Your Own Key (Multi-Provider)

Technical Debt Analysis

Architecture & Dependency Graph

GitHub Integration

Git Source

…

View on GitHub

How I Built It

The stack:

Layer	Technology
Desktop shell	Tauri 2 (Rust + WebView)
Frontend	React 19, TypeScript 6, Vite 8
Editor	Monaco Editor 0.55
State	Zustand 5
Styling	Tailwind CSS v4
Backend	Rust — Tokio, git2, rusqlite, portable-pty
AI (local)	@xenova/transformers (WebAssembly)
AST parsing	web-tree-sitter (JS, TS, Python, Rust)
Graph UI	@xyflow/react
Testing	Vitest + fast-check (property-based)

The interesting technical decisions:

1. Multi-provider tool-calling without a framework
Each AI provider handles tool-calling differently. Anthropic has native tool-use, Gemini has function calling, but most OpenAI-compatible providers need a JSON fallback. I built separate tool loop implementations (anthropicLoop, geminiLoop, openaiLoop, jsonFallbackLoop) that share a common interface — the agent code never knows which provider it's talking to.

2. Agent safety layers
Before any AI-proposed file write lands on disk it goes through: architecture rule validation → security scan → user approval gate. The AgentApplyGuard is the final checkpoint. Even a fully autonomous agent can't violate your architectural rules or introduce known vulnerability patterns.

3. Local embeddings with zero API cost
@xenova/transformers runs entirely in the browser via WebAssembly. The embedding generator runs in a Web Worker so it never blocks the UI. Combined with a Rust-side embedding pipeline for batch processing, semantic search over the codebase costs nothing and works fully offline.

4. Technical debt analysis via Tree-sitter
Instead of sending code to an API, everything runs locally. Tree-sitter parses JS/TS/Python/Rust into ASTs. The debt analyzer Web Worker extracts metrics, builds dependency graphs, detects cycles, measures coupling — all off the main thread. Results appear in seconds even on large codebases.

5. Context management
One of the hardest problems in coding AI is fitting the right context into a limited token window. I built a ContextAssembler that pulls from open files, git diff, LSP diagnostics, and symbol index, then a ContextCompressor that smart-truncates while preserving the most relevant sections. The context sidebar shows exactly what's going into each AI request.

This project is the thing I'm most passionate about. Every feature exists because I hit a real limitation in existing tools and decided to build past it.

Prize Categories

Best Use of Google AI — PunamIDE has deep native integration with Google Gemini (2.5 Pro, 2.5 Flash, 2.5 Flash-Lite, 2.0 Flash) including streaming, vision input, native function calling for agentic tool loops, and per-model cost tracking in USD and INR. Gemini is the recommended default provider for new users due to its generous free tier and strong coding performance.

I Built an AST-Based Technical Debt Analyzer Because Existing Tools Only Tell Me What, Not Why

Amritanshu Amar — Mon, 29 Jun 2026 07:38:50 +0000

Most code quality tools are really good at finding individual problems.

They'll tell you about:

Dead code
Unused dependencies
Complex functions
Large files
Style violations

These are all useful, and I use many of these tools myself.

But after working on larger codebases, I realized something was missing.

They tell me what is wrong.

Very few tools explain why a codebase is slowly becoming harder to maintain.

The Problem

Imagine opening a project and seeing this:

The analyzer tells you:

180 dead code locations
47 oversized functions
12 dependency hotspots
4 circular dependencies

That's useful.

But as a developer, my next question is always:

Why are these problems appearing?

Looking Beyond Individual Warnings

Technical debt isn't just about a long function.

Sometimes the real issue is structural.

For example:

One module becomes the dependency hub for the entire application.
Features that should be independent slowly become tightly coupled.
A single file grows because every new feature lands there.
Circular dependencies appear between modules that were originally separate.

Those patterns are difficult to notice by reading files individually.

Why I Chose AST Analysis

Instead of searching source code with regular expressions, I parse the project into an Abstract Syntax Tree (AST).

That allows the analyzer to understand:

Functions
Modules
Imports
Calls
Type definitions
Relationships between files

Rather than treating files as plain text.

What the Analyzer Looks For

The current implementation detects patterns such as:

Dead code
Oversized functions
Dependency hotspots
Circular dependencies
Complexity hotspots
Structural relationships across the project

Instead of reporting isolated warnings, it tries to build a picture of the overall architecture.

Existing Tools Are Still Great

This isn't meant to replace tools like Clippy, cargo-udeps, or SonarQube.

Those tools solve different problems extremely well.

My goal is different.

I want to answer questions like:

Why does this module keep growing?
Why does every feature touch the same files?
Which parts of the architecture are becoming bottlenecks?
Where is technical debt accumulating before it becomes obvious?

Building It

The analyzer is written in Rust and is currently part of PunamIDE.

The most interesting challenge hasn't been parsing Rust syntax.

It's been deciding which structural metrics actually represent technical debt rather than simply producing more warnings.

Finding the right balance between useful insight and information overload is much harder than building another linter.

What's Next

I'm continuing to experiment with additional architectural metrics and improving how results are visualized.

I'd also love to hear from other developers.

When you think about technical debt, what patterns do you wish your tools detected automatically?

I Built an AI IDE That Creates Automatic Safety Snapshots Before Every Change

Amritanshu Amar — Fri, 19 Jun 2026 10:01:23 +0000

Why I Started Building PunamIDE

I noticed a common problem while working with AI coding assistants.

AI can generate code incredibly fast, but one bad edit can break an entire project.

Most developers either:

Trust the AI completely
Keep making manual backups
Depend on Git commits for every small experiment

None of these felt ideal.

So I started building PunamIDE.

What Is PunamIDE?

PunamIDE is an AI-first development environment focused on safe autonomous coding.

The goal is simple:

Let AI move fast without risking your project.

One Feature That Surprised Me

Today I watched Punam SafeCode automatically create a snapshot before an AI agent modified files.

I wasn't even thinking about backups.

The snapshot happened silently in the background.

When I noticed it, I realized:

The IDE was protecting the codebase before anything could go wrong.

Current Features
AI-powered development workflow
Automatic code snapshots
SafeCode protection layer
Workspace management
Multi-agent development experiments
Local-first development
What I'm Building Next

My roadmap includes:

Autonomous coding agents
Visual project architecture
Project memory
AI-assisted debugging
AI workspace operating system concepts
Looking for Feedback

I'm still actively building PunamIDE.

What features would you want in an AI-native IDE?

I'd love feedback from developers who use:

VS Code
Cursor
Windsurf
Cline
Claude Code

I built a safety-first AI IDE in Tauri/Rust – local, free, $0 (7 months solo)

Amritanshu Amar — Wed, 17 Jun 2026 03:48:25 +0000

Yesterday, Cursor was acquired by SpaceX for $60 billion.

I've been building a free, local-first AI IDE for 7 months. Alone.
No VC money. No team. No MIT network.

This is that story.

Why I built PunamIDE

Most AI IDEs are built around one idea: code faster.

PunamIDE is built around a different idea: don't let AI break
your codebase.

After watching AI agents silently overwrite files, ignore merge
conflicts, run dangerous shell commands, and hallucinate
architecture decisions — I wanted an IDE where AI is powerful
but never unsupervised.

What makes it different

Native Snapshots — Before any AI edit, you can snapshot your
project. Named reasons: "Before AI Edit", "Before Refactor",
"Before Debugger". node_modules and dist are automatically
excluded. One click to restore.

AgentApplyGuard — Every change an AI agent proposes goes
through validation before touching your code. You see exactly
what changes, what files, what risk.

Architecture Rules Engine — A visual drag-and-drop interface
where you define layer constraints. "services CANNOT import from
ui". The IDE enforces it. No more AI casually breaking your
architectural boundaries.

Technical Debt Intelligence — AST-based analysis using
Tree-sitter. Cyclomatic complexity scoring, god class detection,
dependency cycle detection, refactor queue with time estimates.
Built in. No plugins.

3-way merge — AI can never silently overwrite your edits.
Conflict markers are generated. You stay in control.

$0 to run — Supports Gemini, Groq, OpenRouter, Ollama.
All free tiers. No subscription. No cloud lock-in.
Everything runs locally.

The stack

Built on Tauri 2 + Rust + React 19 + TypeScript.
The binary is ~15MB. Electron apps are ~200MB.

Rust handles everything heavy: filesystem, git, LSP, DAP,
PTY, AI API calls, indexing, snapshots, security validation.

The name

Punam means "full moon" in Hindi.

I named it after my late mother.

She taught me that real work is done with care, not shortcuts.
That's what I tried to build — an IDE that doesn't cut corners
on your safety.

Where it is today

Windows alpha (v2.0.0 released)
105 Rust backend tests passing
60+ UI components
LSP, DAP debugger, Git, GitHub integration, Docker panel, CI/CD monitoring, RAG workbench, multi-agent orchestration

I'm looking for 5-10 developers willing to try it and give
honest feedback. Not looking for hype — looking for real usage.

Website: https://punamide.com
Download: https://github.com/punamide/punamide-downloads/releases
Discord: https://discord.gg/PFp9KWY3eY

If you try it — thank you. Every piece of feedback matters.