Best TypeScript ORM 2026: Drizzle, Prisma, Kysely, TypeORM

For most TypeScript projects in 2026, Drizzle is the right default: zero codegen, full type inference, a 7.4 KB gzipped bundle, and a query API that maps directly to SQL. Prisma wins if you need MongoDB, nested writes, or prefer schema-first DX. Kysely is for teams that want a type-safe query builder — not an ORM at all. TypeORM and MikroORM are viable for large NestJS codebases already using them, but neither belongs in a greenfield project.

If you are only choosing between Prisma and Drizzle, our dedicated head-to-head covers that comparison in full, including migration story, type safety gaps, and performance benchmarks. This article is broader — all five candidates, and a verdict on which is right for which situation.

Who this is for

TypeScript backend developers starting a new project or evaluating whether to migrate away from an existing ORM. If you are already on Drizzle or Prisma and the setup is working, this article is probably not your immediate problem.

What we tested

Node 22, PostgreSQL 17, npm ecosystem snapshot from May 2026. Bundle sizes from bundlephobia. GitHub data from official repositories. We did not run independent performance benchmarks — that gap is called out in the Caveats.

ORM	Stable version	Weekly downloads	GitHub stars	Bundle (gzip)
Prisma	7.8.0	~7.8M	45,968	~600 KB
Drizzle	0.45.2	~4.2–5.1M	34,395	~7.4 KB
TypeORM	0.3.29	~4.2M	36,500	Unverified — see note
Kysely	0.29.1	~1.2–2.5M	13,800	~340 KB (2024; verify)
MikroORM	7.0.16	~459K	9,000	Not published

Bundle note: TypeORM bundles all database drivers into a monolithic package; its gzipped size was not independently verified at time of writing. Kysely’s ~340 KB figure is from bundlephobia (April 2024). Verify both before using bundle size as a deciding factor. Drizzle and Prisma figures come from the head-to-head article (primary sources there).

Drizzle v1 pre-release notice: v1.0.0-rc.2 was the latest pre-release as of writing (May 2026). The JIT row mapper and several API changes ship in v1. Verify GA status before adopting v1 in production. The stable version in the table above (0.45.2) is safe.

Findings by theme

Type safety

Prisma generates TypeScript types from a .prisma schema file. Every query result is fully typed at compile time, including where() arguments. Prisma 7 also reduced TypeScript type evaluation overhead by ~98%, making full type checks 70% faster.

Drizzle infers types directly from TypeScript table definitions. Results from select() and insert().returning() are typed. The gap: Drizzle’s where() clause accepts some logically invalid filter combinations without a TypeScript error. This is by design — Drizzle trusts you know SQL. For complex multi-join queries with conditional filters, that gap surfaces.

Kysely is fully typed at each method chain step. Every JOIN, WHERE, and SELECT is validated at compile time. You write every piece of SQL structure yourself — that is the cost of the surgical type safety.

TypeORM types work well for straightforward CRUD. Complex QueryBuilder chains lose TypeScript accuracy. The Partial<Entity> type gaps in join results are a known pain point. It also requires experimentalDecorators and reflect-metadata, which can conflict with modern TypeScript and ESM.

MikroORM’s unit-of-work pattern adds type gaps on raw queries. The identity map and entity lifecycle add cognitive overhead. Types on the entity manager API are solid; types on edge cases are not.

Query DX

Prisma’s API is the most approachable: findMany, create, update, delete with a relation API that generates SQL for you. Nested writes — creating a user and their posts in one call — are a genuine productivity advantage for data-heavy applications.

Drizzle exposes SQL explicitly. You write leftJoin, where, orderBy. Developers with SQL background prefer this because debugging a wrong result means reading the query, not guessing what translation layer produced it. The query API in 0.45.x is stable and covers the full SQL surface.

Kysely is purely a query builder. There is no ORM layer: no entity lifecycle, no lazy loading, no change tracking. You get precisely typed SQL composition. Teams that distrust ORM abstractions often land on Kysely as the endpoint of their migration away from TypeORM.

TypeORM’s decorator API is familiar to Angular and Java developers. The ActiveRecord pattern (entity methods for CRUD) is fast to prototype with. The DataMapper pattern (repository + entity manager) is more testable. Switching between them is awkward. The QueryBuilder’s type safety degrades as query complexity grows.

MikroORM’s unit-of-work pattern is its distinguishing feature. The entity manager tracks all changes and flushes them in one batch. This is natural for teams migrating from PHP/Doctrine or Java/Spring. For everyone else, it is an unfamiliar mental model that takes time to internalize.

Migration story

Prisma manages migrations with a prisma migrate dev command that compares the schema file against the database and generates SQL. The migration history is reliable. Drift detection (database state diverged from recorded history) is handled more consistently than Drizzle.

Drizzle generates migrations from TypeScript schema changes. The tooling is younger. One documented community issue (GitHub #2114): drizzle-kit generate can emit DROP commands for FK constraints created by other tools — Prisma, manual SQL — that Drizzle has no record of creating. If you are migrating from Prisma, budget time to reconcile the migration history.

TypeORM’s migration system is mature. It has handled enterprise-scale schema evolution for years. MikroORM’s migration system also works reliably and gained ESM support in v7.

Kysely has a migration system (kysely/migration) but it is manual — you write the SQL directly. No schema-diffing.

Edge and serverless fit

Drizzle at ~7.4 KB gzipped fits comfortably on any edge runtime. Cloudflare Workers has a 1 MB bundle limit. Vercel Edge Functions, same. Drizzle leaves ~993 KB for your application code.

Prisma 7 now supports edge runtimes after the Rust→TypeScript rewrite. At ~600 KB gzipped, it consumes 60% of the Cloudflare Workers free-tier budget. It works, but there is no headroom.

TypeORM does not run on edge runtimes due to its size and the reflect-metadata dependency. MikroORM v7 removed Node.js coupling and may support edge runtimes in the future; this was not verified at time of writing. Kysely’s minimal footprint makes it edge-compatible — the type-safe query layer ships without ORM overhead.

For teams on Supabase or Neon with Drizzle, note: Supabase Transaction pooling mode requires prepare: false in the Drizzle config. Missing this causes cryptic production errors.

Ecosystem health

Prisma is the largest ecosystem. Third-party tools — Zod schema generators, tRPC adapters, jest-prisma, ERD generators — cover most integration points. Prisma also offers Accelerate (connection pooling + query cache, paid service, free up to 60K ops/month) and Pulse (change data capture).

Drizzle’s ecosystem is smaller but growing fast. Stars went from ~15K in 2024 to 34K+ by May 2026. Weekly downloads crossed Prisma in some Q4 2025 measurement windows. Drizzle Kit, Drizzle Studio, and Drizzle Seed cover the core development workflow.

TypeORM has the widest NestJS integration by default — the NestJS official docs still treat it as the primary ORM example. This explains the ~4.2M weekly downloads despite it being rarely recommended for greenfield projects. The ecosystem is large but not actively expanding.

Kysely has a focused ecosystem. It is well-maintained (v0.29.1 shipped May 16, 2026, concurrent with this article). Tooling is smaller than Prisma’s by a large margin.

MikroORM v7 dropped all runtime dependencies from @mikro-orm/core, replaced Knex with Kysely as the query runner, and added native ESM and polymorphic relations. The project has a loyal, niche user base. The weekly download count of ~459K reflects its audience accurately.

TypeScript ORM verdict — pick X if Y

Pick Drizzle if: you are deploying to Cloudflare Workers or Vercel Edge; your team thinks in SQL; you want zero dependencies and a bundle that will never be the size problem; you are starting a new TypeScript project on Postgres or MySQL, or SQLite.

Pick Prisma if: you need MongoDB (no other TypeScript ORM here supports it); you want nested writes across relations in a single call; you prefer schema-first DX where a .prisma file is the source of truth for both migrations and types; or you want Accelerate for edge-aware connection pooling without managing it yourself.

Pick Kysely if: you want a query builder, not an ORM — full control over every JOIN, no entity lifecycle, no change tracking. Also valid as a pair with Drizzle: use Drizzle for schema and migrations, Kysely for query composition.

Stay on TypeORM or MikroORM if: you have a large NestJS codebase already using one of them and migration risk outweighs the benefits. Both are actively maintained. Neither is the right starting point for a new project.

Caveats

No independent benchmarks. Performance data above is vendor-supplied (Prisma) or unquantified (Drizzle JIT mapper). The prisma-vs-drizzle.md article calls this out the same way. Treat any performance claim here as directional.

Drizzle v1 is pre-release. The JIT row mapper and breaking API changes ship in v1. v0.45.2 is stable. The latest pre-release is v1.0.0-rc.2. Check orm.drizzle.team/docs/latest-releases before adopting any v1 RC in production.

TypeORM 1.0.0 is planned for H1 2026 but had not shipped as of writing. If it has shipped, the “legacy” framing here may need revisiting.

Bundle sizes for TypeORM, MikroORM, and Kysely were not independently verified. Verify via bundlephobia before using bundle size as a hard criterion.

MongoDB via Prisma only. No other ORM in this field supports it. If MongoDB is in scope, the comparison ends there.

Kysely is not an ORM. It omits entity lifecycle, lazy loading, and change tracking by design. Do not expect those features.