Prisma 8 Is Stable: No Rust Engine, Graph Migrations, and Its Own Hosting

Prisma 8 is now prisma@latest. The Rust query engine that shipped with every version of Prisma since 2019 is gone. What replaced it is a pure TypeScript runtime — 148.5 KB gzipped, down from a 14 MB native binary — alongside a new schema model called the data contract, a graph-based migration system that eliminates branch merge conflicts, and a full hosting platform for TypeScript apps called Prisma Compute. If you have a Prisma project and run npm update prisma today, you get a fundamentally different piece of software than you had last week.

The Rust Engine Is Gone — Here Is What Actually Changed

Let’s be precise, because the marketing is doing some work here. Prisma’s old query engine was a native Rust binary that shipped alongside your app. It caused real problems: cold-start penalties in serverless environments, binary distribution headaches across architectures, and a bundle that ballooned to roughly 14 MB. Moving to TypeScript and WASM eliminated all of that. The bundle is now 148.5 KB gzipped — a genuine 90% reduction.

What that reduction is not is evidence that TypeScript beats Rust. It is evidence that removing a native binary from your bundle makes the bundle smaller. The actual performance wins come from eliminating the cross-language serialization boundary between TypeScript and Rust. Prisma 8 now reaches about 87% of the raw pg driver’s peak throughput and sustains 52% more requests per second than Prisma 7. In internal benchmarks, findMany over 25,000 records dropped from 185ms to 55ms. Those numbers are meaningful. The bundle stat is mostly a deployment story.

Should You Upgrade? Check Your Database First

Prisma 8 is Postgres-first at launch. PostgreSQL is at general availability. MongoDB is in early access. MySQL, SQLite, SQL Server, and CockroachDB are not yet supported in Prisma 8.

That means: if your team is on MySQL or SQLite, do not upgrade yet. Stay on Prisma 7 until database support catches up. If you are on PostgreSQL — which covers most production Prisma deployments — the upgrade path is straightforward and the performance gains are real enough to justify the migration effort.

The Contract System: A New Mental Model

Prisma 8 replaces the generated client package with a data contract. You author your schema in a contract.prisma or contract.ts file, and a build step emits two artifacts: a deterministic contract.json and TypeScript types. Those artifacts become the single source of truth — your app, your migration tools, and AI coding agents all read from the same contract.

The query API changed too. Queries are now composed inline as a typed DSL against the contract, and each compiles to a verifiable plan at runtime. When you need SQL-level control, there is a type-safe SQL builder:

const plan = db.sql.public.post
  .select("id", "title", "userId")
  .where((f, fns) => fns.eq(f.published, true))
  .limit(10)
  .build();

const posts = await db.runtime().execute(plan);

This is Prisma’s answer to the “I ditched Prisma for raw SQL” crowd. You can drop to SQL-shaped queries without leaving the type-safe ecosystem. The contract also enables streaming results — processing records one by one as they arrive, rather than holding a full result set in memory — which matters when querying large datasets.

Prisma’s homepage now reads “Agent Infrastructure for TypeScript.” The contract system is where that positioning earns its keep: a machine-readable, deterministic schema artifact that AI agents can consume directly to plan migrations. Whether that framing is visionary or just a rebrand depends on how quickly agent-driven development becomes your team’s actual workflow.

Graph Migrations End the Linear Conflict Problem

Prisma migrations used to be a linear, timestamp-ordered list. Two developers on different branches each add a migration — at merge time, that becomes a conflict requiring manual resolution. Prisma 8 changes the model entirely.

Migrations now form a DAG (directed acyclic graph). Each migration records the contract hash it starts from and the hash it moves the database to. Those hashes are nodes; migrations are edges. When two branches each add a migration and merge, the graph has a fork and a join, and db migrate finds a path from wherever the database currently sits to wherever you tell it to go. Branch conflicts resolve automatically. Partial failures are safe to retry. Data migrations are TypeScript files validated against the contract, so you can backfill columns alongside schema changes.

Prisma Compute: They Built a Hosting Platform

Alongside Prisma 8, the company launched Prisma Compute into production — a TypeScript app hosting platform co-located with Prisma Postgres. Apps run on Bun (not Node.js), scale to zero when idle, and every Git branch gets its own isolated environment: app, environment variables, and optionally a dedicated database branched from production.

The pricing is the headline for anyone currently on Vercel: at 20 million requests per month, Prisma Compute runs about $98 versus Vercel’s approximately $236. Prisma does not charge per seat, per deploy, or per preview environment. The free plan covers 1 million requests per month, 360 GB-hours of memory, and 10 GB of bandwidth — no credit card required.

The pitch is integration density: one config, per-PR branching across app and database, and microsecond latency between the app and Postgres because they share the same infrastructure. The trade-off is lock-in. If you build on Prisma Compute, you are betting on the Prisma ecosystem staying healthy and competitive. For teams already all-in on Prisma and PostgreSQL, that bet got easier to make this week.

The Bottom Line

Prisma 8 is a genuine architectural shift — not a minor version increment dressed up as one. The Rust engine removal simplifies deployment and makes Prisma viable in serverless and edge environments where it previously struggled. Graph-based migrations solve a real workflow problem. The contract system is a coherent new mental model, and the type-safe SQL builder gives developers an escape hatch from abstraction when they need it.

The caveats are real: PostgreSQL only at GA, MySQL and SQLite users should hold off, and upgrading from Prisma 7 will take care. But for greenfield TypeScript projects on Postgres, prisma@latest is the right starting point now.