Kirimase vs Create T3 App: CLI-Generated Starters 2026
Two CLIs for Full-Stack Next.js Development
When you want to start a new full-stack Next.js project with TypeScript, tRPC, and Prisma, you have two well-regarded free CLIs to choose from: Create T3 App and Kirimase.
Both target the same developer — someone who wants a typesafe, modern stack without manually wiring up every dependency. Both are open source, both are free, and both reflect the opinions of developers who ship real products.
But they solve the initialization problem differently, and the difference matters more than it might seem at first glance.
TL;DR
- Create T3 App (24,000+ stars, actively maintained) — Initializes a typesafe Next.js project with your choice of packages. Sets you up and steps aside. No ongoing code generation.
- Kirimase (2,800+ stars, maintenance mode) — Initializes a project AND generates CRUD operations from schema definitions. Rails-style scaffolding for Next.js. Currently in maintenance mode.
The headline recommendation: Create T3 App is the safer choice for new projects. Kirimase's code generation feature is genuinely compelling, but the maintenance pause is a real risk in a fast-moving ecosystem.
Key Differences at a Glance
| Feature | Create T3 App | Kirimase |
|---|---|---|
| Price | Free | Free |
| License | MIT | MIT |
| GitHub stars | 24,000+ | 2,800+ |
| Maintenance status | Actively maintained | Maintenance mode (rewrite planned) |
| Package initialization | Yes (interactive CLI) | Yes (interactive CLI) |
| ORM choices | Prisma (primary), Drizzle (via flag) | Prisma, Drizzle |
| Auth choices | Auth.js (primary) | Auth.js, Clerk, Lucia, Kinde |
| Database | PostgreSQL (default), SQLite | PostgreSQL, MySQL, SQLite |
| API layer | tRPC (optional) | tRPC, Server Actions |
| Code generation | No | Yes (CRUD from schema) |
| UI components | No (add Shadcn manually) | Shadcn UI (via add) |
| Payments | No | Stripe (via add stripe) |
| No | Resend (via add resend) | |
| Community | Very large (Discord, GitHub) | Smaller |
| Documentation | Excellent (create.t3.gg) | Good (kirimase.dev) |
Create T3 App: The Typesafe Stack Template
Create T3 App is the CLI for the T3 Stack — a TypeScript-first stack built around the principle of "typesafe from end to end." It was created by Theo Browne and is maintained by the T3 community.
npm create t3-app@latest
The interactive prompts ask:
- TypeScript or JavaScript? (TypeScript strongly recommended)
- tRPC? (yes/no)
- Tailwind CSS? (yes/no)
- Prisma? (yes/no)
- NextAuth.js? (yes/no)
From these choices, it generates a configured Next.js project. That is where Create T3 App's role ends. It is a project initializer, not an ongoing scaffolding tool.
What Create T3 App Does Well
Excellent documentation. The T3 Stack documentation at create.t3.gg covers every aspect of the stack with tutorials, FAQ, and architecture explanations. When you are stuck, the docs (or the Discord) have an answer.
Minimal opinions beyond the stack. Create T3 App does not tell you how to organize your components, where to put your API routes, or what your folder structure should look like. It gives you the configured stack and gets out of the way.
Active, fast-moving maintenance. Updates track the latest Next.js, tRPC, Prisma, and Auth.js versions. When tRPC v11 shipped, Create T3 App was updated quickly.
Massive community. 24,000+ GitHub stars and an active Discord. Questions get answered. Problems get filed as issues. The ecosystem around T3 is enormous.
What Create T3 App Does Not Do
It does not generate code for you after initialization. If you want a new data model with CRUD operations, you write the Prisma schema, the tRPC router, the server components, and the client-side mutations yourself.
This is not a criticism — it is the design. Create T3 App is about starting with the right foundation. The ongoing development is up to you.
Kirimase: The T3 Stack with Code Generation
Kirimase starts from the same T3 Stack philosophy and adds the feature that T3 App deliberately omits: ongoing code generation.
npx kirimase@latest init # Initialize project (like create-t3-app)
npx kirimase@latest add # Add packages interactively
npx kirimase@latest generate # Generate CRUD from schema definition
The generate Command: Kirimase's Differentiator
This is the feature that makes Kirimase compelling:
npx kirimase generate
? Model name: BlogPost
? Fields:
- title (String, required)
- content (String, required)
- published (Boolean, default: false)
- authorId (Foreign key → User)
? Generate tRPC router? Yes
? Generate UI components? Yes
Kirimase generates:
| Generated file | Contents |
|---|---|
prisma/schema.prisma | BlogPost model added |
src/server/db/blogPosts.ts | Type-safe queries (getAll, getById, create, update, delete) |
src/app/api/blogPosts/route.ts | REST API routes (if REST chosen) |
src/server/routers/blogPosts.ts | tRPC router with all CRUD procedures |
src/app/(app)/blogPosts/page.tsx | List view with data fetching |
src/app/(app)/blogPosts/[id]/page.tsx | Detail view |
src/components/blogPosts/BlogPostForm.tsx | Create/edit form |
For a model like BlogPost, this saves 60-90 minutes of writing repetitive boilerplate. For a product with 8-10 models, the time savings add up to a day or more.
Kirimase's Maintenance Mode Problem
The significant caveat for 2026: Kirimase is in maintenance mode. The creator announced that only critical bugs are being addressed while a comprehensive rewrite is planned.
In a fast-moving ecosystem (Next.js releases frequently, Auth.js v5 shipped, Drizzle evolves), maintenance mode means the generated code may not reflect current best practices. If a package Kirimase integrates (Lucia, Auth.js, or a specific Prisma adapter) releases a breaking change, Kirimase may not update.
This is the central risk: you are starting a potentially long-lived project on a tool that is not being actively improved. The planned rewrite may never ship, may ship but break compatibility, or may ship as a significantly different tool.
Head-to-Head: Initialization Experience
Create T3 App initialization:
npm create t3-app@latest my-app
? Will you be using TypeScript or JavaScript? TypeScript
? Will you be using tRPC? Yes
? What authentication provider would you like to use? NextAuth.js
? What database ORM would you like to use? Prisma
? Would you like to use Tailwind CSS? Yes
? How would you like to initialize your project? Initialize a new git repository
✓ my-app scaffolded successfully!
Result: A fully configured Next.js project with tRPC, Prisma, NextAuth, and Tailwind. No additional packages added — you extend it yourself.
Kirimase initialization:
npx kirimase@latest init
? What package manager do you use? pnpm
? What ORM would you like to use? Drizzle-ORM
? Please choose your DB: PostgreSQL
? Please choose your authentication solution: Clerk
? Would you like to include shadcn/ui? Yes
? Would you like to add Stripe? Yes
? Would you like to add Resend? Yes
✓ Project initialized successfully!
Result: A configured Next.js project with Drizzle, Clerk, Shadcn UI, Stripe, and Resend — more packages configured in a single pass. Subsequent kirimase add commands can add more packages interactively.
Auth Options: Kirimase Wins on Breadth
| Provider | Create T3 App | Kirimase |
|---|---|---|
| Auth.js | Yes (primary) | Yes |
| Clerk | No (manual) | Yes |
| Lucia | No (manual) | Yes |
| Kinde | No (manual) | Yes |
Kirimase's four auth options let you pick Clerk (best DX, monthly cost) or Lucia (free, full control) at initialization time. Create T3 App defaults to Auth.js and leaves other providers to manual integration.
Database Options
| Database | Create T3 App | Kirimase |
|---|---|---|
| PostgreSQL | Yes | Yes |
| MySQL | No (manual) | Yes |
| SQLite | Yes (for dev) | Yes |
Kirimase's MySQL support is useful for developers deploying to PlanetScale or other MySQL-compatible hosts.
When the Code Generation Matters
Kirimase's generate command is most valuable for data-heavy applications:
- Internal tools with many models and CRUD operations
- Admin dashboards with resource management
- Multi-tenant SaaS with per-tenant data isolation patterns
- Content management systems with custom content types
For these use cases, Rails developers recognize the pattern immediately — define a model, scaffold the CRUD, modify to fit your business logic. The alternative (writing every list page, form, query, mutation, and API endpoint by hand) is significant overhead.
For simpler applications — a landing page with auth and Stripe, a single-feature SaaS — code generation provides less benefit. The overhead of learning Kirimase's patterns may not be worth it.
The Recommendation
Choose Create T3 App if:
- You want the most actively maintained free CLI with the largest community
- You are building a relatively simple SaaS where code generation is less valuable
- You want maximum flexibility in how your project evolves
- You need latest Next.js compatibility — Create T3 App tracks releases quickly
- You want access to excellent documentation and a large Discord community
Choose Kirimase if:
- You are building a data-heavy application where CRUD scaffolding saves significant time
- You understand the maintenance mode risk and are comfortable with it
- You specifically want Clerk or Lucia as your auth provider (Kirimase integrates them; T3 App does not)
- You want Stripe and Resend added at initialization time
- You are building an internal tool or admin dashboard where the code generation shines
The pragmatic advice for 2026: Start with Create T3 App. Kirimase's code generation is genuinely valuable, but the maintenance mode situation means recommending it as a primary choice for new projects is difficult. If Kirimase v2 ships and returns to active development, this recommendation should be revisited.
Methodology
This comparison is based on publicly available information from each project's GitHub repository, documentation, npm package data, and community discussions as of March 2026. GitHub stars reflect the state at time of writing.
Looking for a complete SaaS boilerplate instead of a stack template? StarterPick compares paid and free options with landing pages, billing, and auth pre-built.