CodeMorph is the AI code editor that converts your codebase file by file, leaf modules first, and type-checks every file.
Windows 10/11 · Free during beta · Bring your own Claude key or use Ollama
Windows may show 'unknown publisher'. Click More info, then Run anyway.
A complete editor
CodeMorph is a full desktop editor with the keybindings, layout and extensions developers already know. The difference is Morph: a migration engine 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.
Review every converted file side by side before you keep it. CodeMorph saves a checkpoint before any change, so one click on Undo all restores your project byte for byte.
After every batch CodeMorph runs tsc across the whole project. Errors go back into a repair loop with the compiler output attached, and a batch is only marked verified when there are zero type errors. Running your tests is coming soon.
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 | No | No | No | Yes |
| Keeps circular imports together | No | No | No | Yes |
| Types inferred from real call sites | By hand | No | Partly | Yes |
| Type-checks the whole project after each step | By hand | No | No | Yes |
| Runs your tests and build | By hand | No | No | Coming soon |
| Every change reviewed as a diff | Yes | No | Copy and paste | Yes |
| Avoids blanket any and ts-ignore | Yes | No | Sometimes | Yes |
| Code goes only to the AI provider you choose | Yes | Yes | Depends on the tool | Yes |
| 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 type-checks the whole API at every step.
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? Turn on strict mode and migrate file by file to that bar with every step type-checked.
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 on your machine, and the graph is a local SQLite file. No code leaves your machine until you convert a file.
Conversion uses your own Anthropic key, stored in the OS keychain. Or point CodeMorph at Ollama, and the model runs on your own machine.
Telemetry and crash reporting are off by default in the build itself. Nothing phones home.
Thousands of extensions install in one click from Open VSX, the open extension registry.
Go deeper
Download the beta, open a project and see your migration plan in under a minute.
Windows 10/11 · Free during beta · Bring your own Claude key or use Ollama
Windows may show 'unknown publisher'. Click More info, then Run anyway.