Motia: #1 Backend in JS Rising Stars 2025
Motia: #1 Backend in JS Rising Stars 2025
TL;DR
Motia is the fastest-growing backend npm package of 2025. It ranked #1 in the Backend/Full-Stack category of JS Rising Stars — ahead of every established framework — by collapsing APIs, background jobs, queues, cron, state management, and AI agent workflows into a single primitive called the Step. Download numbers are still in "early adopter" territory (~1.5K weekly on the core package), but the GitHub star velocity tells the story developers usually miss in download charts: Motia isn't competing with Express for the current market. It's competing for the next decade of backend architecture.
Key Takeaways
- #1 Backend/Full-stack in JS Rising Stars 2025 — more stars gained in 2025 than Express, NestJS, Fastify, and Hono combined
- 13.8K GitHub stars total with the majority added in a single year — a rate comparable to how Next.js grew in its first two years
- Downloads are still early — @motiadev/core at ~1.5K weekly vs Express at 35M+ — this is an architectural bet, not a migration
- The core package is Apache 2.0 (frameworks, SDK, CLI, docs) with the iii engine under ELv2
npm install motiais the wrong mental model — you scaffold vianpx motia@latest create, not install a library- Direct replacement target: NestJS + BullMQ + node-cron + a Redis state layer — four dependencies become one runtime
The npm Package Story: Why Downloads Mislead Here
PkgPulse usually leads with weekly download numbers. For Motia, that number needs context before it means anything.
The motia npm package and @motiadev/core together show roughly 3K–5K combined weekly downloads as of March 2026. Compare that to the incumbents:
| Package | Weekly Downloads | GitHub Stars | Category |
|---|---|---|---|
express | ~35M | 66K | HTTP framework |
fastify | ~6M | 33K | HTTP framework |
@nestjs/core | ~3M | 70K | Full framework |
hono | ~1.5M | 24K | Edge framework |
motia | ~3–5K combined | 13.8K | Unified backend |
temporal | ~200K | 12K | Workflow engine |
On raw downloads, Motia is a rounding error compared to Express. But the download-to-stars ratio tells a different story. Motia has more GitHub stars per weekly download than any other backend package in its category by a wide margin.
This ratio is a leading indicator. It means developers are watching, bookmarking, and architecting with Motia in mind — but most haven't migrated production codebases yet. This is exactly what the Express and NestJS charts looked like in 2017 and 2019 respectively, before their download numbers exploded.
Why Motia Won Rising Stars: The Architecture Argument
To understand why the JS community awarded Motia the #1 backend spot, you need to understand what it's replacing. A typical production Node.js backend in 2025 looks like this:
{
"dependencies": {
"express": "^5", // HTTP routing
"bullmq": "^5", // Background job queues
"redis": "^4", // Queue backing store
"node-cron": "^3", // Scheduled tasks
"ioredis": "^5", // State management
"@temporalio/client": "*" // Complex workflows (if you've hit that wall)
}
}
Six packages, six configuration systems, six sets of deployment concerns, six observability stories. Each time you need to move logic from an HTTP handler to a background job, you're making a multi-file architecture change.
Motia's pitch: one package.json entry, one execution model, one observability system.
The Step Primitive
Every piece of backend logic in Motia is a Step file. The config export declares what triggers it. The handler export does the work. The type field in config is the only thing that changes between an HTTP endpoint, a background job, a cron task, and a streaming event:
// An HTTP endpoint
export const config = { type: 'api', method: 'POST', path: '/jobs', emits: ['job.created'] }
// A background job (same handler pattern)
export const config = { type: 'event', subscribes: ['job.created'], emits: ['job.processed'] }
// A cron task (same handler pattern)
export const config = { type: 'cron', cron: '0 9 * * 1-5', emits: ['report.triggered'] }
The handler function signature is identical across all three. Moving logic from HTTP to queue requires changing type: 'api' to type: 'event' and adding a subscribes field. No queue definitions, no worker files, no new dependencies.
This is the architectural insight that generated 13.8K stars in one year.
Package Metrics Deep Dive
Version History
Motia is on an aggressive release cadence. The 1.0-RC milestone released in early 2026 marked the transition to the iii engine under the hood — a Rust-based runtime that handles queues, state, streams, cron, and observability through a single iii-config.yaml. This is a significant architectural shift:
- Pre-1.0: Node.js runtime managing its own queue/state adapters
- 1.0-RC: iii Rust engine takes over infrastructure, SDK + Steps stay in Node.js/Python/TypeScript
The Rust engine explains one of Motia's under-discussed advantages: performance. When the queue backing store, state management layer, and event router are written in Rust rather than JavaScript, the overhead per event is measured in microseconds rather than milliseconds.
License Structure
The dual-license model is worth understanding:
| Component | License |
|---|---|
| Motia SDK, CLI, framework | Apache 2.0 |
| iii engine | Elastic License 2.0 (ELv2) |
Apache 2.0 is fully permissive — build commercial products, no restrictions. ELv2 is permissive for almost every developer use case. The restriction: you can't sell the iii engine itself as a standalone managed service. Building apps, SaaS products, internal tools, and client projects on top of Motia is fully allowed under both licenses.
Language Support
| Language | Status |
|---|---|
| TypeScript | ✓ Stable |
| JavaScript | ✓ Stable |
| Python | ✓ Stable |
| Ruby | Beta |
| Rust | Via iii SDK |
Python support is first-class, not bolted on. TypeScript steps and Python steps can exchange events in the same Motia application. A POST /api/analyze TypeScript HTTP step can emit an event that a Python step processes with a pandas or scikit-learn pipeline, and the Motia runtime handles the cross-language message passing transparently.
How Motia Compares in the Ecosystem
Motia isn't a direct competitor to Express or Fastify — it sits at a different abstraction layer. Here's the honest architectural comparison:
vs. Express / Hono
Express is the HTTP routing primitive. Hono is the modern, edge-compatible alternative. Both do one thing: map HTTP requests to handler functions.
Motia includes an HTTP routing layer (the api Step type) that's roughly equivalent to Express route handlers. But the comparison breaks down immediately: you wouldn't use Express to handle background jobs, cron scheduling, or stateful workflows. Those require additional packages. Motia handles all four natively.
If you're building a simple REST API with no async side effects: Hono or Fastify will be lighter. Motia's runtime is overkill for a CRUD API over a database.
If your API triggers background processing, has scheduled tasks, or manages workflow state: Motia is architecturally more honest than Express + BullMQ + cron.
vs. NestJS
NestJS is the opinionated, full-framework approach to Node.js backends. Its module/controller/provider structure is excellent for large teams enforcing architectural consistency. The DI container, decorators, and testing utilities are mature.
Motia takes the opposite approach: minimal convention, maximum composability. There's no module system to learn, no DI container to configure. A Step is a file with two exports. The framework disappears.
The NestJS comparison is where Motia's download trajectory will become visible over the next 18 months. NestJS grew from ~200K to ~3M weekly downloads between 2019 and 2023. If Motia captures the "greenfield backend" market the way NestJS captured the "Angular-style backend" market, the download charts will look very different by 2027.
vs. Temporal
Temporal is the gold standard for durable workflow orchestration — complex, multi-step processes with retry semantics, timeouts, and activity compensation. It's genuinely powerful and genuinely complex.
Motia's workflow model (event chains with subscribe/emit) handles 80% of what teams reach for Temporal to solve, at a fraction of the setup complexity. For teams that need Temporal's full durability guarantees and compensation patterns, Temporal remains the right tool. For teams that reach for Temporal because their Express + BullMQ stack became unwieldy, Motia is the more accessible path.
The PkgPulse Verdict: Worth Watching
Motia's package metrics are pre-hockey-stick. The GitHub star count is real but the download numbers reflect early adopter status, not production ubiquity. This is the window to evaluate it before the crowd arrives.
The questions to ask when evaluating Motia for a new project:
- Does my backend have side effects beyond HTTP? If yes, Motia's unified execution model saves significant architectural complexity.
- Am I comfortable with a 1.0-RC framework? The API has been reasonably stable but ELv2 on the engine is worth understanding before enterprise adoption.
- Do I need multi-language backend support? If Python and TypeScript need to exchange events, Motia is the cleanest solution available.
The download trajectory of every breakout backend framework in the last decade looked like Motia's today — roughly 18 months before the chart went vertical.
Methodology
- Sources consulted: 7
- Data from: JS Rising Stars 2025, MotiaDev/motia GitHub, npm registry, motia.dev, Socket.dev @motiadev/core metrics
- Download numbers: Approximate weekly figures, captured March 2026
- Date: March 2026
See how Motia's design philosophy compares to the frameworks it's replacing: Express vs Fastify in 2026
Why developers are moving away from the status quo: The Decline of Express — What Developers Are Switching To
For edge-first API development alongside Motia: Hono.js 2026: Edge Framework Guide