CodeMorph is the AI code editor that converts your codebase file by file, leaf modules first, and proves every file still compiles and passes your tests.
Free during the beta · Windows 10 and 11 · macOS and Linux waitlist open
Built on the editor developers already know
CodeMorph is a full desktop editor built from Code - OSS, the open-source core of VS Code. Same keybindings, same layout, extensions from Open VSX. The difference is Morph: a migration engine and agent that understands how your files depend on each other.
CodeMorph parses every file, resolves every import and builds a dependency graph of your project. Then it orders the work: leaf modules first, so types flow upward through your imports.
Each batch is converted against imports that are already TypeScript, so the model infers real types from real call sites instead of guessing. The explorer shows progress file by file.
Nothing is written behind your back. Review each file side by side, accept or reject it, and ask Morph to explain any type it chose before you commit.
After every batch CodeMorph runs tsc and your own test suite. Errors go back into a repair loop with the compiler output attached, and a batch is only marked verified when both pass.
Morph lives in the side panel with your dependency graph as context. Ask why a type was chosen, tighten an any, or request a change, and it answers with the files and lines that justify it.
End to end
Seven steps from an open folder to verified TypeScript. Each one produces something you can inspect before the next begins.
Before and after
CodeMorph types each file against modules that are already TypeScript, so shapes come from the code itself instead of guesses. Logic stays exactly the same.
// src/api/orders.js
const { db } = require("../lib/db");
const { money } = require("../utils/money");
async function placeOrder(userId, cart) {
const total = cart.items.reduce((sum, i) => sum + i.price * i.qty, 0);
const order = await db.orders.create({ userId, total, items: cart.items });
return { ...order, display: money(total) };
}
module.exports = { placeOrder };// src/api/orders.ts
import { db } from "../lib/db";
import { money } from "../utils/money";
import type { Cart } from "../models/cart";
import type { Order } from "../models/order";
export interface PlacedOrder extends Order {
display: string;
}
export async function placeOrder(userId: string, cart: Cart): Promise<PlacedOrder> {
const total = cart.items.reduce((sum, i) => sum + i.price * i.qty, 0);
const order = await db.orders.create({ userId, total, items: cart.items });
return { ...order, display: money(total) };
}Why leaf-first
Migrating a file before its dependencies forces the model to guess at shapes it can't see. CodeMorph converts files in topological order, so every file is typed against imports that are already TypeScript and already verified.
Compared with the usual approaches
Every approach can produce TypeScript. The difference is whether you can trust the result without re-reading every line.
| Capability | By hand | Rename and suppress | AI chat, file by file | CodeMorph |
|---|---|---|---|---|
| Converts in dependency order | ||||
| Keeps circular imports together | ||||
| Types inferred from real call sites | By hand | Partly | ||
| Type-checks the whole project after each step | By hand | |||
| Runs your tests and build | By hand | |||
| Every change reviewed as a diff | Copy and paste | |||
| Avoids blanket any and ts-ignore | Sometimes | |||
| Code stays on your machine | ||||
| Weeks of engineer time | Yes | Less | Less | Least |
"Rename and suppress" means renaming files to .ts and silencing errors with any or ts-ignore, by hand or with a codemod.
Who it's for
An Express or Fastify backend that grew for years without types. CodeMorph types the data layer first, then models, then routes, and proves the API still passes its tests.
JSX components become TSX with props inferred from how each component is actually rendered across the app, leaf components first.
Ship real type definitions generated from typed source instead of hand-written .d.ts files that drift from the code.
Map an unfamiliar project in seconds: what depends on what, where the cycles are, which imports don't resolve, before you touch anything.
Already on TypeScript but loose? Ask Morph for strict mode and migrate file by file to that bar with every step verified.
Turn a migration nobody owns into a plan with batches, progress and a definition of done the whole team can see.
Works with your stack
Front end, back end and tests. If it's JavaScript or JSX, CodeMorph can graph it.
Your code stays yours
Scanning, graph building and planning run entirely on your machine. The graph is a local SQLite file.
AI features use your own Anthropic key, stored in the OS keychain. Or point Morph at Ollama and stay offline.
Telemetry and crash reporting are off by default in the build itself. Nothing phones home.
The editor is built from Code - OSS under the MIT license. Extensions come from Open VSX.
Go deeper
Download the beta, open a project and see your migration plan in under a minute.