Web Frameworks

next.js143.4k★

Next.js is the React framework that fills in what React leaves out: routing, server rendering, API routes, image optimization and caching. It's the default way most teams build React apps, and it's free under MIT. Vercel, the company behind it, makes its money on hosting. Self-hosting is real. next build and next start on any Node server or Docker container runs every feature, per the docs. Since 16.2 a stable Adapter API lets any platform target Next.js, and Vercel's own adapter uses the same public contract. The gap is running more than one server: keeping cache and revalidation in sync is your job. Vercel's free Hobby plan is non-commercial only. Pro is $20/month with one deploying seat and $20 of usage credit, then $20/month per extra deploying seat. Solo: free on a VPS, or Hobby for side projects. Small teams: Pro or one container. Larger teams: price Vercel usage against your ops time. The catch: patching is a standing job. Next.js shipped five critical remote code execution advisories between August and October 2026. Self-host it and that upgrade cadence is yours, so stay on an LTS line and update the week a fix lands.

FastAPI104.4k★

FastAPI is the Python framework for building APIs, the endpoints a web or mobile app calls for data. You write ordinary Python functions with type hints, and FastAPI validates incoming requests and generates interactive API docs (Swagger UI and ReDoc) for you. The framework is free under MIT. Setup is uv add "fastapi[standard]", then fastapi dev runs a local server. It sits on Starlette for the web layer and Pydantic for validation, and TechEmpower benchmarks put it among the fastest Python frameworks. It runs anywhere Python does. The same team now sells FastAPI Cloud, which deploys with one fastapi deploy. In public beta, Hobby is $0/month for 3 apps on a shared 0.1 vCPU, and Pro is $20/seat/month for 25 apps and up to 10 teammates. Compute usage isn't billed yet, so expect changes. Solo: free, Hobby for side projects. Small teams: Pro if you'd rather not run servers. Larger teams: self-host, no SSO or SLA yet. The catch: it's an API framework, not Django. No admin panel, no ORM; bring SQLAlchemy or SQLModel. It's also still pre-1.0, and five releases with breaking changes landed between October 8 and 19, 2026 (0.148 stopped validating omitted defaults). Pin your version.

Django91.5k★

Django is the Python web framework that hands you a database layer, an auto-built admin panel, user logins, forms and security protections in one install. It's free under the BSD 3-Clause license, backed by the nonprofit Django Software Foundation, with no paid edition of any kind. Getting started is pip install Django. The real ops work is everything around it: a Postgres or MySQL database, an app server, static files and a host that runs Python. Keep up with patch releases: the October 6 security release alone fixed four issues across 6.1, 6.0 and 5.2. Hate upgrades? 5.2 LTS is supported until April 2028. Solo builders: free, and the admin panel saves weeks of building internal screens. Small teams: free, and the conventions mean nobody argues about where code goes. Larger teams: free, with Django REST Framework for APIs and Celery for background jobs as add-ons. The catch: Django was built synchronous and async is still catching up. Async views and most ORM queries work now, but the docs still say transactions do not yet work in async mode. For an API built around long-held connections, FastAPI is the more natural fit.

Gin89.5k★

Gin is a fast, minimal HTTP web framework for Go: you define routes, attach handlers, add middleware for things like logging and auth, and it handles the plumbing. MIT license. Gin is to Go what Express is to Node.js, the default answer when someone asks "which framework?" It's fast (built on httprouter), has a clean API, and the documentation is solid. You can go from zero to a working API in 20 minutes. Everything is free. No paid tier, no commercial version, no cloud offering. It's a library you import into your Go project. The catch: Gin is showing its age. The Go ecosystem has moved toward lighter frameworks like Echo and Chi, or even just the standard library's net/http with Go 1.22's improved routing. Gin adds convenience but also adds a dependency, and in Go culture, fewer dependencies is better. Starting a new project today? Look at Hono (for the edge) or the standard library first. Gin is fine, battle-tested, and everywhere, but it's not the only answer anymore.

Svelte88.6k★

Svelte compiles your components into plain JavaScript at build time, with no virtual DOM and only a small runtime. You write components that look like HTML with superpowers, and the compiler turns them into lean, fast code. MIT licensed. SvelteKit, the full-stack framework built on Svelte, handles routing and server rendering, and deploys through adapters for Vercel, Netlify, Cloudflare, Node or plain static hosting. Svelte 5 replaced the old reactivity model with runes ($state, $derived), so tutorials from before late 2024 use syntax you'll need to translate. Fully free. No paid tier, no enterprise edition, no hosted product. Deploy anywhere. The catch: the ecosystem is smaller than React's. If you need a specific UI component library, auth wrapper, or enterprise integration, React probably has 10 options where Svelte has 2. The job market is thinner too, which means fewer answers out there when you're stuck.

Laravel85.3k★

Laravel is the PHP framework that ships with the boring parts already built: routing, the Eloquent database layer, queues, auth, migrations, validation, testing and starter kits for React, Vue, Svelte and Livewire. This repo is the starter app you get from composer create-project laravel/laravel, and it's MIT and free. Running it yourself is ordinary PHP hosting: PHP 8.3 or newer, Composer, a database and a web server on any VPS. Queue workers and the scheduler are extra processes you keep alive yourself. Laravel the company sells everything around it. Laravel Cloud, the managed host, is $5/month plus usage, Growth $20, Business $200. Forge manages your own servers for $12, $19 or $39 a month ($120, $199 or $399 a year). Nightwatch monitoring is free to 300k events, then $20/month. Solo: framework plus Forge Hobby. Small teams: Forge Growth or Cloud Growth. Larger teams: Cloud Business or Enterprise. The catch: patching is your job. On October 19, 2026 Laravel disclosed a critical token API auth bypass on MySQL and MariaDB, fixed in 13.29.0 and 12.68.0. Two days later PHP shipped fixes for two critical remote code execution bugs. And Vapor no longer takes signups, so skip old guides pointing there.

Spring Boot81.7k★

Spring Boot takes the Spring Framework, Java's big enterprise toolkit, and removes most of the setup. You get opinionated defaults, auto-configuration and an embedded web server, so a service starts with java -jar instead of a pile of XML. It's Apache 2.0 and free, maintained by Broadcom's Spring team. Setup is a Spring Initializr download or a few Maven or Gradle lines. Security, metrics, health checks and external config come in as starters, add-on dependencies that wire themselves up. Running it is ordinary JVM hosting: a container, a VM or a PaaS. There's no paid tier for features. The money is in support windows. Each minor version gets about 13 months of free fixes: 4.0.x ends December 2026, and 3.5.x already ended in June. After that, patches come from TrueSource Spring Enterprise, Broadcom's paid subscription, quote-only. Solo and small teams: free, stay current. Large teams pinned to old branches: budget for the subscription or for upgrades. The catch: that treadmill has teeth. In March, an Actuator auth bypass got free fixes for 4.0 and 3.5 while the 3.4 fix shipped Enterprise Support Only. Fall a minor version behind and security costs money.

NestJS77.0k★

NestJS brings structure to backend TypeScript with dependency injection, modules, guards, and interceptors. Basically, Angular's architecture applied to the server side. The framework, the CLI, and every official module (GraphQL, WebSockets, microservices, CQRS, TypeORM, queues) are MIT licensed and free. Version 12 landed in August 2026 and it is a real upgrade. Packages are ESM-ready while existing CommonJS apps keep working, validation now accepts Standard Schema libraries like Zod and Valibot, and the rebuilt CLI defaults to Rspack, oxlint, and Vitest. It needs Node 20.19 or later. Version 11 is still getting patches, so there is no rush. Nothing in the framework is paywalled. The core team makes money around it: enterprise support by quote, official courses from about $89, and paid SaaS products, including Devtools, the Mau deployment platform, and the new Observe monitoring service, which has a free plan. Solo: only if you like structure, otherwise expressjs/express or honojs/hono ships faster. Small teams: a good fit once the API keeps growing. Medium and large: this is what it was built for. The catch: the learning curve is real. Coming from Express, the decorators, dependency injection, and module system feel over-engineered for a simple CRUD API. And the decorator-heavy style couples your code to NestJS conventions, so migrating away is not trivial.

Express69.6k★

Express is the minimal, unopinionated web framework that most Node.js applications and APIs are built on. It gives you routing, middleware, and request handling with minimal opinions about how you structure everything else. MIT license, the most-used Node.js framework by a wide margin. Express doesn't do much on its own. That's the point. You pick your database, your template engine, your auth strategy, your validation library. It just handles HTTP and gets out of the way. The middleware ecosystem is enormous. Passport for auth, helmet for security headers, cors, body-parser, thousands more. Fully free. No paid tier, no hosted version, no premium features. It's a 600KB dependency in your package.json. Solo through enterprise, Express works at every scale. The trade-off is that at scale, 'unopinionated' becomes 'you built a custom framework without realizing it.' Every Express app over a certain size is basically a bespoke framework. The catch: Express is showing its age. It's callback-based at its core (async/await works but isn't native). Newer frameworks like Hono, Fastify, and Elysia are faster, have better TypeScript support, and were designed for modern JS. Express 5 spent years in beta. Starting a new project? Look at the alternatives. Maintaining an existing Express app? It still works fine.

Astro63.8k★

Astro builds content sites (blogs, docs, marketing pages, portfolios) that ship zero JavaScript by default. Pages render to plain HTML; only components you mark interactive send JS to the browser. The whole framework is MIT licensed and free, with no paid edition. Hosting is your only cost. A static build runs on any static host, and both GitHub Pages and Cloudflare serve static files free. Server rendering needs a Node host or an adapter for Netlify, Vercel or Cloudflare. Astro 7 shipped in June with a Rust compiler and Vite 8, and Astro's own benchmarks show builds 15 to 61 percent faster. Solo builders and small teams get the best free content stack going. Bigger teams should use it for docs and marketing and leave the product app to Next.js. For simpler file-based sites, Eleventy and Hugo are still excellent. Astro DB was removed in 7.0; bring your own database. The catch: Cloudflare acquired the Astro company in January 2026, and every full-time Astro employee now works there. It stays MIT and deploys anywhere, but one host now funds the roadmap. Patch server builds too: a critical remote code execution bug in AVIF image handling was fixed in 7.2.8.

Zustand58.9k★

Zustand manages React state in about 5 lines of code: no boilerplate, no providers, no reducers, no actions. Create a store, use the hook, done. Your state updates, your component re-renders, nothing else does. MIT licensed. The API is tiny: create and useStore. That's basically it. It handles async actions naturally (just use async/await in your store), works outside React (vanilla JS), supports middleware (persist to localStorage, devtools, immer), and plays nicely with React's concurrent features. Fully free. No paid tier. No cloud. No enterprise version. This is a community library maintained by the pmndrs collective (same folks behind Three.js React bindings). Bundle size is ~1KB gzipped. Compare that to Redux Toolkit at ~12KB. If your state needs are simple to moderate: theme, auth, UI state, API cache, Zustand is the right call. The catch: for very large apps with complex state relationships, Redux's structure (enforced patterns, middleware chain, devtools ecosystem) can be an advantage. Zustand's simplicity means you define your own patterns, which is freedom for experienced devs and rope for beginners.

Ruby on Rails58.9k★

Ruby on Rails is the framework that proved one developer can build what used to take a team. It gives you everything out of the box: database ORM, routing, views, email, background jobs, WebSockets, API mode. You generate a scaffold and you have a working CRUD app in minutes. MIT license, created by DHH in 2004 and still actively developed. Shopify, GitHub, Basecamp, and thousands of startups run on Rails. It prioritizes developer happiness and convention over configuration, which means less decision fatigue, but also less flexibility. Fully free. No paid tier, no commercial version, no strings. You deploy it anywhere: Heroku, Render, Fly.io, a $5 VPS, AWS. The ecosystem of gems (plugins) is massive and mature. The catch: Ruby is slower than Go, Rust, or even Node.js for raw throughput. Rails apps can get monolithic and hard to maintain at scale without discipline. The job market for Rails developers has shrunk compared to JavaScript/Python frameworks. And "convention over configuration" means when you need to do something unconventional, Rails fights you.

Fiber40.3k★

Fiber is a Go web framework modeled after Express.js, built on fasthttp for high throughput. Routes, middleware, static files, template rendering, all with Express-like syntax but running on Go's fasthttp library instead of Node.js. It's consistently one of the fastest web frameworks in benchmarks. The pitch is simple: Go's performance with an API that JavaScript developers already understand. If you're moving from Node to Go and don't want to learn a completely new routing paradigm, Fiber's learning curve is almost flat. MIT. Fully free, no paid tier, no cloud service, no commercial edition. The catch: Fiber uses fasthttp instead of Go's standard net/http library. That means some Go middleware and libraries that expect net/http won't work without adapters. The Go community has opinions about this; many prefer Chi or Echo because they stick to the standard library. If you care about long-term compatibility with the Go ecosystem, the fasthttp dependency is a real trade-off.

Solid36.2k★

SolidJS delivers fine-grained reactivity and smaller bundles by compiling to surgical DOM updates. It looks like React (JSX, components, hooks-like primitives) but compiles down to direct DOM updates. No diffing, no reconciliation, no wasted renders. MIT licensed. The framework consistently tops JavaScript framework benchmarks. Bundle sizes start around 7KB gzipped. It uses signals for reactivity: when a value changes, only the exact DOM node that uses it updates. Nothing else re-renders. SolidJS itself is fully free. The pricing page is for SolidStart (their meta-framework, like Next.js is to React) and SolidCloud, but SolidJS the library costs nothing. The ecosystem is smaller than React's. Fewer component libraries, fewer tutorials, fewer Stack Overflow answers. But it's growing steadily with an active Discord and an enthusiastic community. The catch: you're betting on a smaller ecosystem. Hiring Solid developers is harder than hiring React developers. Some React patterns don't translate (early returns in components break reactivity, destructuring props loses tracking). The mental model is subtly different even though the syntax looks familiar.

Remix33.4k★

Remix leans into web standards (forms, HTTP caching, URL-based routing) instead of inventing its own abstractions. It's React-based but treats the server as a first-class citizen, not an afterthought. Fully free under MIT. No paid tier, no cloud service. Remix was acquired by Shopify, which funds development. The framework itself has no monetization. There's nothing to host: it's a framework you build with. Deploys anywhere: Vercel, Cloudflare Workers, Fly.io, Node.js servers, Deno. The adapter system means you're not locked to any platform. Solo developers: Remix is a great choice if you like working with web fundamentals. The mental model is simpler than Next.js in many ways: data loading is per-route, mutations use forms, errors have boundaries. Small to large teams: the nested routing and data loading patterns scale well. The catch: Remix merged with React Router v7 in late 2024, which confused the ecosystem. The project is stable and actively maintained, but the branding transition means some docs and tutorials reference the old structure. Also, Next.js has a much larger ecosystem of examples, templates, and third-party integrations.

Hono32.8k★

Think Express.js but 10x smaller, 10x faster, and it deploys to any JavaScript runtime without code changes. What's free: Everything. MIT license. The entire framework, all middleware, all adapters. No paid anything. Hono's sweet spot is edge computing and serverless. At ~14KB, it starts faster than most frameworks can parse their config files. The API is Express-like (get, post, middleware) so the learning curve is nearly flat if you know Express. TypeScript-first with great type inference. The middleware ecosystem covers JWT auth, CORS, compression, rate limiting, and more. The catch: Hono is a backend/API framework, not a full-stack solution. No built-in SSR, no file-based routing (without a plugin), no database ORM. If you need a full-stack framework, look at Next.js or Remix. And while 'runs everywhere' is the pitch, the edge runtime restrictions (no Node.js APIs, limited filesystem access) still apply. You're writing for Web Standards, which means some npm packages won't work.

Echo32.8k★

Routing, middleware, request binding, validation, and template rendering. That's it. No ORM, no migration tool, no opinions about your database. MIT license. The benchmarks put Echo among the fastest Go web frameworks. Optimized router using a radix tree, automatic TLS via Let's Encrypt, HTTP/2 support, and a middleware ecosystem (CORS, JWT, logging, rate limiting, gzip) that covers the common needs. Fully free. No paid tier, no hosted version. A Go module you import. Every team size: free. Echo's performance means you rarely think about framework overhead; your bottleneck will be your business logic or database, not the HTTP layer. The catch: Go's web framework landscape is crowded. Gin has more stars (83K) and a larger community. Fiber (which uses Fasthttp instead of net/http) benchmarks even faster. Chi is closer to the standard library. Echo sits in a comfortable middle: more batteries than Chi, less middleware than Gin, standard net/http under the hood. The choice between Echo, Gin, and Chi mostly comes down to API preference. If you're new to Go web frameworks, Gin's larger community means more tutorials and StackOverflow answers.

symfony31.2k★

Symfony is the PHP framework a big chunk of the PHP world quietly runs on. It's a full framework for web apps, APIs and command-line tools, plus standalone components (console, routing, HTTP, mail, caching) that other projects pull in piecemeal. Laravel and Drupal both depend on them. MIT-licensed and free. symfony new my_app --webapp gets you a working project. In production it's a normal PHP app. The real commitment is the release calendar: a new minor every May and November, and non-LTS lines die fast (8.1 support ends January 2027). Sit on the LTS: 7.4 gets bug fixes until November 2028 and security fixes until November 2029. Nothing in the framework is paywalled. The money sits around it: SymfonyCloud hosting (run by Upsun, formerly Platform.sh), SymfonyInsight code scans, SensioLabs consulting and training. Solo and small teams: free, host it anywhere. Larger teams: still free, buy SensioLabs support if you want the creators on call. The catch: 2026 was a heavy security year. Symfony published 29 GitHub advisories in May alone, including a firewall bypass that let unauthenticated users reach protected routes, then three more high-severity fixes in October. All patched. Run composer update on a schedule, not when you remember.

Phoenix23.2k★

Phoenix is a web framework built on Elixir and the Erlang VM, the same system that powers telecom infrastructure handling millions of connections, perfect for real-time dashboards, chat, and live updates. Plain terms: it's a web framework like Rails or Django, but built for apps where lots of users are connected at once. MIT license, Elixir. LiveView is the headline feature: it lets you build interactive, real-time UIs without writing JavaScript. Your server renders HTML, pushes diffs over a WebSocket, and the page updates instantly. For dashboards, admin panels, and collaborative tools, it eliminates an entire frontend build step. Fully free. No paid tier, no hosted offering, no premium features. The entire framework, including LiveView, is open source. Solo developers: great if you're willing to learn Elixir. Small to large teams: Phoenix scales beautifully, but hiring Elixir developers is hard. The talent pool is a fraction of Ruby, Python, or JavaScript. The catch: Elixir. The language is excellent, but the ecosystem is smaller than Node or Python. Fewer libraries, fewer tutorials, fewer Stack Overflow answers. If your team doesn't already know Elixir, the learning curve is real, and convincing your company to adopt it is a harder sell than the framework deserves.

Chi23.1k★

No framework magic, no custom context objects, no lock-in. Your handlers are regular http.HandlerFunc; Chi just routes requests to them and gives you middleware chaining. Go, MIT. The middleware system is Chi's best feature: compose authentication, logging, rate limiting, CORS, and compression as a stack. The built-in middleware collection covers the common cases. Route groups let you apply different middleware to different URL prefixes. Fully free. No paid tier, no hosted version. It's a Go package: go get github.com/go-chi/chi. Solo to large teams: free. Chi is what you use when you want the thinnest possible layer between your code and Go's HTTP server. It adds routing and middleware composition, nothing more. The catch: Chi does routing. That's it. No ORM, no template engine, no config management, no migration tools. If you're coming from Express.js, Django, or Rails and expect a full framework, Chi isn't one. You'll assemble everything else yourself, which is the Go way, but it means more decisions upfront. And if you're comparing HTTP routers specifically, Go 1.22+'s standard library mux now supports method-based routing and path parameters, narrowing Chi's advantage for simple APIs.

Qwik22.1k★

Qwik takes a fundamentally different approach to JavaScript delivery, making pages fast by default (not 'fast for a React app'). Instead of sending all your JS upfront and hydrating the page, Qwik sends near-zero JS on initial load and only downloads the code for a button when you actually click it. What's free: Everything. MIT license. The framework, the optimizer, the Qwik City meta-framework for routing and data loading. All free. The 'resumability' concept is innovative. Traditional frameworks (React, Next.js, Svelte) ship JavaScript, then re-execute it on the client to make the page interactive. Qwik serializes the app state into HTML and resumes exactly where the server left off. The result: near-instant interactivity regardless of app size. The catch: the ecosystem is tiny compared to React or even Svelte. Finding Qwik developers is hard. Third-party component libraries are scarce. If you need a rich component ecosystem, you'll be building a lot from scratch. And the mental model (lazy-loading everything, dollar-sign functions, serialization boundaries) takes real adjustment even for experienced developers.

Jotai21.3k★

Jotai strips React state management back to the basics: atoms that hold values and update components, nothing more. You create atoms (small pieces of state), use them in components, and React re-renders only what changed. That's it. Think of atoms like individual useState hooks that any component in your app can read and write to. No providers wrapping your entire app, no boilerplate. You write const countAtom = atom(0) and use it anywhere. Derived state is just an atom that reads other atoms. What makes Jotai different from Zustand (its sibling from the same team): Jotai is bottom-up. You build small atoms and compose them. Zustand is top-down: one store with slices. For apps with lots of independent pieces of state that occasionally depend on each other, Jotai's model clicks faster. Async atoms handle data fetching without extra libraries. Integration with React Suspense works out of the box. TypeScript support is excellent. The catch: the ecosystem is smaller than Redux or Zustand. If your team already knows Redux, switching saves zero time. And for simple apps, useState plus context is still fine; Jotai shines when you have 20+ pieces of interconnected state.

Elysia19.3k★

We're talking handling more requests per second than most Go and Rust web frameworks, in TypeScript. The developer experience is the other selling point. End-to-end type safety. Define your API once and the types flow from server to client automatically. Validation, OpenAPI docs, and auth plugins built in. The API feels modern in a way that Express and Fastify don't. MIT. The Bun ecosystem's answer to Express. The catch: it requires Bun. If your deployment target is Node.js, Lambda, or Cloudflare Workers, Elysia won't work. Bun adoption is growing but it's not Node-level ubiquitous yet. The ecosystem of middleware and plugins is smaller than Express (thousands of packages) or even Fastify. And 'fastest benchmarks' matter less than you think in production where your database query takes 100x longer than framework overhead.

frappe11.1k★

Frappe is a full-stack Python web framework built for business apps. If you need forms, workflows, user roles, email, and a REST API without stitching together a dozen packages, this gives you all of it out of the box. The framework is MIT-licensed and completely free. Self-hosting runs on Docker via the frappe_docker repo. You will need MariaDB (default) or Postgres, Redis, and the Bench CLI tool to manage sites. The setup is well-documented but not trivial. Expect a few hours to get production-ready, and ongoing maintenance for upgrades. The metadata-driven architecture (everything is a "DocType") means fast development but deep coupling to the Frappe ecosystem. Solo developers and small teams can run this for free indefinitely. If you want managed hosting, Frappe Cloud handles installs, upgrades, and monitoring for a fee. ERPNext, accounting, HR, and helpdesk apps are all built on this framework, so you are betting on an ecosystem with real production users, not a weekend project. The catch: once you go deep on DocTypes and Frappe's conventions, you are locked into their way of doing things. This is not Django with extra batteries. It is its own world. If your app outgrows the framework's opinions, migrating off is painful.

orpc5.8k★

oRPC solves a specific annoyance: your frontend calls your backend, and nothing tells you when the two quietly disagree about the shape of the data. Define the contract once and TypeScript flags the mismatch in your editor instead of in production. MIT licensed, no paid tier, no hosted service waiting to upsell you. There is nothing to run. oRPC is npm packages you import into whatever stack you already have, with adapters for Next.js, NestJS, Bun, and Cloudflare Workers. Contract-first is the real differentiator: you write the API shape as a standalone artifact and get an OpenAPI spec out of it, so consumers that are not TypeScript are not locked out. tRPC gives you type safety without the spec; ts-rest gives you the contract without the adapter breadth. Solo and small teams running TypeScript on both ends get the most out of this. Medium teams with a mixed stack still come out ahead because of the OpenAPI output. Large teams already deep in tRPC should leave it alone; the win is real but not migration-sized. The catch is that this is still pre-1.0 with more than twenty packages in the monorepo. Breaking changes are landing, and "which packages do I actually need" is a real first-day question. Pin your versions.

modern.js5.0k★

modern.js is ByteDance's full-stack React framework. It bundles the pieces you'd otherwise wire together yourself: routing, server rendering, and an integrated backend layer. It's built on Rspack, the Rust bundler from the same team, so builds are fast. MIT licensed and completely free. The pitch is "progressive." Start with a static site, add server rendering or a backend-for-frontend later without switching tools. The standout feature is the BFF layer, which lets you call backend functions straight from frontend code. Running it in production means owning and scaling a Node server yourself, same as any server-rendered app. Zero-config to start, real ops once you ship. The honest comparison is Next.js, and that's the problem. Next.js has the ecosystem, the docs, and the Stack Overflow answers. modern.js is technically excellent, but the community leans ByteDance and China. Solo and small teams: pick the framework that has answers when you get stuck, which today is Next.js or Remix. Larger teams already standardized on Rspack and Rsbuild: this is worth a serious look. The catch is mindshare. A great framework that nobody around you uses means you debug alone.

salvo4.5k★

Salvo is a Rust web framework built so writing a Rust server doesn't feel like a fight with the type system. Handlers are plain async functions, middleware is just another handler, and routes nest as a tree, so auth can sit on one branch. HTTP/3, WebSockets, automatic Let's Encrypt certificates and OpenAPI docs come in the box. Apache 2.0, free. Setup is cargo add salvo tokio, a dozen lines, cargo run. You deploy one binary that can handle its own TLS. Official crates cover CSRF, sessions, JWT auth, rate limiting, caching and a reverse proxy. No paid tier, no cloud, just a donate link. Solo, small and larger teams: free. Axum and Actix Web are the more common Rust picks; Salvo's pitch is more batteries included. The catch: this is mostly one person's project, and only the latest release line gets security fixes. That matters, because 2026 brought four high-severity advisories: two XSS bugs in the static file listing, a proxy path traversal that bypassed gateway rules, and a memory-exhaustion DoS in form parsing. All fixed. Version 1.0 only landed in September, so pin versions and upgrade promptly.

neo3.3k★

Neo.mjs is a JavaScript framework with one real trick: it runs your app across multiple browser threads instead of cramming everything onto one. Most web apps freeze when the main thread gets busy. Neo.mjs pushes rendering and data work into Web Workers, so the UI stays responsive even under heavy load, with no build step required. MIT licensed and free. That multi-threading is genuinely useful for a specific kind of app: trading dashboards, IDEs, multi-window tools, anything pushing thousands of updates a second where a frozen tab is unacceptable. For a normal CRUD site, it's overkill, and React or Vue have far bigger ecosystems and far more people who can help when you're stuck. The framework's own benchmarks look great, but you're trading a crowded, well-documented mainstream for a niche one. Worth a look if you're building something performance-critical and multi-window and the main-thread bottleneck is a real problem you've already hit. For most teams shipping most apps, the mainstream frameworks are the safer call. Free either way, nothing to pay for. The catch is the marketing. The repo now describes itself as a "self-evolving software organism" with an AI agent swarm that opens its own pull requests, and that framing buries the actual engineering under buzzwords. The threading architecture is real and solid. The AI-orchestration layer is experimental and best ignored when you're deciding whether the framework fits your app.

Ts.ED3.1k★

Ts.ED is a TypeScript framework for building APIs on Node.js. You write classes with decorators for routes, validation, and dependency injection, and it runs them on Express by default, or Koa, Fastify, or serverless. JSON Schema and OpenAPI sit at the core, so your validation and your API docs come from the same decorators. MIT and free. Nothing to host beyond your own app. Version 8 needs Node 20.11 or later and is ESM only, so CommonJS projects have a migration ahead. Bun works as a runtime. The integration list is long: Prisma, TypeORM, Mongoose, MikroORM, GraphQL, Socket.io, BullMQ, Temporal, Stripe, Passport, and an OIDC provider. Keep every @tsed package on the same version or things break. Free at every size. The honest comparison is nestjs/nest, which does the same decorator and dependency injection style with a far larger community and paid enterprise support. Pick Ts.ED for schema-first APIs on plain Express without Nest's Angular-style module system. For a team hiring Node developers, Nest is the safer bet. The catch is bus factor. One maintainer wrote the overwhelming majority of the commits. Some features only work on Express: Passport is Express only, and Fastify has documented gaps. The docs also describe premium plugins behind a $14/mo GitHub sponsorship, though several of those packages now sit on public npm under MIT.

actionhero2.4k★

Actionhero is a Node.js framework for building API servers with integrated task processing. It's a batteries-included approach for building APIs that also need to do work in the background. Apache 2.0, TypeScript. Built around the concept of 'actions' (API endpoints), 'tasks' (background jobs), and 'initializers' (startup logic). Supports HTTP, WebSocket, and TCP connections in one server. Uses Redis for clustering and task queuing. Fully free. No paid tier, no hosted version. It's a framework you install and build on. The honest take: ActionHero fills a real gap, the 'I need an API server AND background jobs AND WebSockets in one process' problem. But the community is quiet. That matters when you hit a bug and need help. Solo developers building something that needs all three capabilities: worth trying. Teams: the small community and sparse ecosystem make it a harder sell when NestJS or Fastify + BullMQ get you the same result with much larger communities. The catch: the community is tiny compared to Express, NestJS, or Hono. Documentation exists but examples are limited. If you need WebSockets + background jobs, you're probably better off composing dedicated tools (Hono + BullMQ + Socket.io) unless you strongly prefer the all-in-one approach.

platformatic2.2k★

Platformatic runs your Node.js apps faster by running them smarter. Its server, called Watt, runs any Node framework, Next.js, Astro, NestJS, Remix, as worker threads inside one process, with observability, auto-healing, and scaling built in. Instead of a dozen separate services chattering over the network, you compose them into one runtime and cut the overhead. The ops story is mixed: the core is Apache-licensed and free to run yourself, but you're adopting an application server, which is a real architectural commitment. The payoff is better resource use, especially on Kubernetes where the multi-threaded model packs more work into fewer pods, plus logging, metrics, tracing, and profiling you'd otherwise wire up by hand. Small teams running several Node services who feel the network and memory overhead are the sweet spot. Solo devs on a single app won't see the benefit and shouldn't bother. Larger teams already deep in microservices get the most, but should weigh the migration cost of moving onto someone else's runtime. The catch: it's open core. The framework is free, but the commercial cloud and enterprise architecture support are where Platformatic makes money, so expect the most polished operational features to live behind that. And adopting an app server is a one-way-ish door, you're betting your runtime on a young company's roadmap.

vue-promised1.9k★

Vue-Promised is a small Vue library by Eduardo San Martin Morote (posva, a Vue core team member) that handles promises in templates without the boilerplate. You get a Promised component and a usePromise composable that track pending, resolved, and rejected states automatically, with a 200ms delay before showing a loading indicator to avoid layout flicker, and data preservation during refreshes. There's no install ceremony beyond npm install vue-promised. It supports Vue 3 directly and Vue 2 via the composition API plugin. Twenty stable releases, version 2.2.0 since October 2021. Stable is the right word: this is a small library that does one thing and is essentially done. Solo and small Vue teams: install it and stop writing the same async boilerplate every component. Large Vue teams: same recommendation. If you're using Vue Query or Vue Apollo for data fetching, they already handle this for those specific cases; Vue-Promised is for the general async work those tools don't cover. The catch: it's a library, not a tool. It's also basically feature-complete and quiet, which looks like abandonment but isn't. posva still maintains the Vue ecosystem; this is just a small piece that doesn't need new features.

hummingbird1.9k★

Hummingbird is a lightweight web framework for writing servers in Swift, the language most people know from iPhone apps. It gives you a router, middleware, request and response encoding, TLS and HTTP/2 on top of SwiftNIO, Apple's networking engine, and pulls in as few dependencies as it can. Apache 2.0, free. You add it as a Swift package and deploy the result like any server binary. The core stays small on purpose. Authentication, WebSockets, Redis, job queues, Mustache templates, the Fluent ORM and AWS Lambda support are separate official packages you add when you need them. The current release needs Swift 6.1 tooling. Swift developers who want to share code and types between an iOS app and its backend are the natural fit. Vapor is the bigger, batteries-included option with a larger community. Pick Hummingbird when you want to assemble only the pieces you use. Every team size pays the same, nothing. The catch is Swift on the server itself. Hosting guides, libraries and hiring pools are a fraction of what Node, Go or Python offer, so you will do more of the deployment plumbing yourself. Great framework, niche ecosystem.