Melty is the first AI code editor that treats every chat interaction as a git commit, allowing developers to revert, branch, and squash their AI-assisted changes just like traditional code. It’s designed for engineers who use AI for coding but struggle with fragmented chats, lost context, or untracked changes. Melty integrates AI deeply into the development workflow, ensuring every modification is versioned and traceable.
Built with TypeScript, Melty runs as a desktop application and integrates with existing tools like GitHub, compilers, debuggers, and project management systems like Linear. It leverages real-time AI to make multi-file changes, understand codebase context, and auto-generate commits—making it a true pair programmer for modern development teams.
What You Get
- Chat-to-Commit - Every AI-generated change is automatically committed to git with descriptive messages, enabling full version control over AI-assisted edits.
- Multi-File Refactoring - AI can refactor code across multiple files in a single interaction, preserving dependencies and structure without manual copy-pasting.
- Codebase Navigation - AI understands and navigates large codebases by analyzing file relationships, enabling context-aware suggestions and edits.
- Self-Generating Code - Melty writes up to 50% of its own codebase, demonstrating its ability to learn and improve from internal development patterns.
- Workflow Integration - Deeply integrates with compilers, debuggers, terminals, GitHub, and Linear for seamless development pipeline compatibility.
- Persistent Context - AI remembers your codebase state and past interactions, eliminating the need to re-explain context between sessions.
Common Use Cases
- Refactoring legacy codebases - A senior engineer uses Melty to safely refactor a 10k-line codebase by chatting with the AI, which proposes and commits changes while preserving dependencies.
- Onboarding new developers - A team uses Melty to let new hires ask questions in natural language and receive versioned, contextual code changes instead of static snippets.
- Building full-stack apps from prompts - A solo founder creates a React + Node.js web app by describing features in chat, and Melty generates, organizes, and commits all files automatically.
- Debugging complex issues - A developer describes a bug in natural language, and Melty analyzes logs, traces execution paths, and proposes fix commits with test updates.
Under The Hood
Architecture
- Heavily inspired by VS Code’s modular extension system, with strict layering between Electron main, sandbox, browser, and Node.js environments enforced via ESLint and explicit module boundaries.
- Implements dependency injection through a service registry pattern, enabling clean RPC-like communication between main and extension hosts.
- Uses AMD and ESM coexistence with dynamic loading and polyfills to support cross-environment compatibility, while core components leverage observer patterns for state management and lifecycle cleanup.
- Bootstrapping and configuration are isolated into platform-specific modules with conditional logic for dev, portable, and production modes, ensuring clean separation of concerns.
- Build system relies on Gulp with complex pipelines for compiling, bundling, and watching across multiple targets, reflecting a mature but intricate monorepo structure.
Tech Stack
- Core functionality is split between Rust for low-level operations and TypeScript for application logic and UI, creating a performant and type-safe foundation.
- Built on Electron with Webpack for bundling and VS Code’s extension framework as the architectural backbone.
- Comprehensive testing includes unit tests with Mocha, browser integration tests with Playwright, and static analysis via CodeQL for security and quality.
- Dependency and license management is enforced through npm/yarn, cgmanifest.json, and cglicenses.json, ensuring strict open-source compliance.
- Development tooling features ESLint with custom TypeScript rules, tsfmt for formatting, and EditorConfig for consistent styling across environments.
- Deployment is automated via electron-builder with CI/CD pipelines for auto-updates and versioned releases.
Code Quality
- Extensive test coverage spans unit, integration, and edge cases with disposable cleanup patterns and custom assertions for reliability.
- Strong type safety is maintained through comprehensive TypeScript annotations, type guards, and strict assertions throughout source and test code.
- Consistent naming, modular design, and clear separation of concerns follow established VS Code patterns, enhancing maintainability.
- Robust error handling and resource management via DisposableStore ensure graceful degradation and clean cleanup in failure scenarios.
- Linting, JSDoc annotations, and structured comments enforce high standards for readability and correctness.
- Reactive patterns and event-driven architectures are deeply integrated to manage dynamic editor states and real-time document changes.
What Makes It Unique
- Seamlessly bridges Node.js and browser environments through a hybrid AMD/ESM module system, enabling identical extension behavior across platforms without duplication.
- Introduces a virtual document content provider architecture that treats remote and synthetic content as first-class text models with full editor capabilities.
- Features a dynamic test coverage visualization system using reactive observables and themable gradients to render multi-metric thresholds in real time.
- Implements real-time diff editor breadcrumbs that reactively update symbol hierarchy based on live document changes, eliminating static UI state.
- Offers an extension-managed URI opener registry with automatic lifecycle binding to extension activation, ensuring clean resource synchronization.
- Employs a sophisticated configuration validation framework that infers type constraints and enum validity from JSON schemas, with localized error messages and runtime coercion.