Reference

Web Dev Tech Stack

A state-of-the-art map of the modern web development stack — the languages, runtimes, frameworks, build tools, styling systems, state & data libraries, backends, databases, ORMs, hosting platforms, DevOps tooling, version control, testing kit, package managers, auth & identity, API/GraphQL/realtime layers, mobile & desktop frameworks, content/CMS tooling, UI component libraries, and observability you actually assemble apps from. Each technology carries what it is, when to reach for it, what to learn first, how mature it is, how steep the learning curve is, what it pairs with, the alternatives, the gotcha that bites people, and a link to the docs.

How to use: pick a category tab, narrow by Layer (frontend / backend / tooling…), or filter live by typing into the search box (matches across name, tagline, description, use cases, features, and more). Click any column header to sort — Maturity, Learning Curve, and Since are ranked sorts. Tap any code example for a plain-English explanation, and tap any highlighted term for what it stands for. Prerequisites, Pairs well with, and Alternatives link straight to the matching row. The technology column stays pinned as you scroll horizontally.

21 categories 230 technologies Last updated

Maturity

How established and production-proven a technology is right now.

  • ★ standard Industry-standard / default choice
  • ● mainstream Widely adopted & safe
  • ▲ rising Gaining traction, newer
  • ▼ legacy Mature but fading / maintenance mode

Learning Curve

Roughly how much effort it takes to get productive.

  • gentle Pick up in a day or two
  • moderate A few weeks to feel fluent
  • steep Significant ramp-up / deep concepts

Layer

Where a technology sits in the stack. Many span more than one — use the Layer filter above the table to narrow by one.

  • Language
  • Frontend
  • Backend
  • Full-stack
  • Styling
  • Database
  • Tooling
  • Infrastructure
Web Dev Glossary 98 terms

Click any term to see a beginner-friendly explanation. Cross-references inside an explanation open in a stacked modal — Escape closes them one at a time.

Technology Layer Maturity Learning Curve Since What it is Use cases Prerequisites Key features Pairs well with Alternatives Example Gotchas Built in Maintained by License Docs
HTML The markup language every web page is built from.
★ standard{ }▤
{ } Language▤ Frontend
★ standard gentle 1993

The HyperText Markup Language defines the structure and semantics of a web page — headings, paragraphs, links, forms, media — as a tree of elements the browser parses into the DOM. It’s declarative, not a programming language, and the living standard evolves continuously rather than in numbered versions since HTML5.
3 use cases The structural foundation of every web page and app. Show all
  • The structural foundation of every web page and app.
  • Semantic, accessible document markup for content and forms.
  • Email templates and the output target of every frontend framework.
 —
4 features Semantic elements (
,
  • Semantic elements (<article>, <nav>, <main>) for structure and a11y.
  • Native form controls, validation, and input types.
  • Built-in media: <video>, <audio>, <picture>, <canvas>.
  • A living standard — no version churn, broad backward compatibility.

HTML is forgiving to a fault — browsers silently recover from unclosed or misnested tags, so broken markup often looks fine until a screen reader or a CSS selector trips over it. Use semantic elements over a sea of <div>s, and validate to catch accessibility regressions early.

 n/a (markup) WHATWG (living standard) open standard
CSS The styling language that paints the web.
★ standard{ }▤◈
{ } Language▤ Frontend◈ Styling
★ standard moderate 1996

Cascading Style Sheets control the presentation of HTML — layout, colour, typography, animation, and responsiveness. The cascade and specificity rules decide which declarations win, and modern CSS has absorbed features (grid, flexbox, custom properties, container queries, nesting) that once required preprocessors or JavaScript.
3 use cases All visual styling and layout of web pages and apps. Show all
  • All visual styling and layout of web pages and apps.
  • Responsive and adaptive design via media and container queries.
  • Animations, transitions, and theming with custom properties.
4 features Flexbox and Grid for two-dimensional layout. Show all
  • Flexbox and Grid for two-dimensional layout.
  • Custom properties (CSS variables) and calc() for dynamic theming.
  • Container queries and :has() for component-aware styling.
  • Native nesting and cascade layers (@layer) without a preprocessor.

The cascade and specificity are where CSS bites — a stray !important or an over-specific selector quietly overrides everything downstream, and debugging means reasoning about source order, specificity, and inheritance all at once. Cascade layers and a consistent methodology tame this.

 n/a (stylesheet) W3C CSS Working Group open standard
JavaScript The language of the web — and increasingly, everywhere else.
★ standard{ }▤
{ } Language▤ Frontend
★ standard moderate 1995

The only programming language browsers run natively. A dynamically typed, multi-paradigm language standardized as ECMAScript, with a yearly spec cadence. It runs in the browser, on servers (Node, Deno, Bun), at the edge, and in build tools — and modern code ships as ESM modules.
3 use cases Client-side interactivity and SPA frameworks in the browser. Show all
  • Client-side interactivity and SPA frameworks in the browser.
  • Server-side and edge runtimes (Node.js, Deno, Bun, Workers).
  • Build tooling, scripting, and CLIs across the JS ecosystem.
4 features First-class functions, closures, and async/await for conc... Show all
  • First-class functions, closures, and async/await for concurrency.
  • Prototype-based objects with class syntax sugar.
  • ES modules, destructuring, optional chaining, and yearly new syntax.
  • Runs unchanged across browsers, servers, and edge runtimes.

The famous foot-guns are real — implicit type coercion (== vs ===), this binding that shifts with call site, and floating-point math where 0.1 + 0.2 !== 0.3. Lean on ===, arrow functions, and a linter, and reach for TypeScript once a project grows.

 n/a (specified language) Ecma TC39 (ECMAScript) open standard
TypeScript JavaScript with a type system bolted on at build time.
★ standard{ }🔧
{ } Language🔧 Tooling
★ standard moderate 2012

A typed superset of JavaScript from Microsoft: every valid JS file is valid TS, but you add static types the compiler checks before transpiling down to plain JavaScript. The types are erased at build time — they exist only to catch bugs and power editor autocomplete, never at runtime.
3 use cases Any non-trivial JavaScript codebase needing type safety. Show all
  • Any non-trivial JavaScript codebase needing type safety.
  • Large team projects where types document contracts and prevent regressions.
  • Library authoring where shipping .d.ts types is expected.
4 features Static structural typing erased at compile time — zero ru... Show all
  • Static structural typing erased at compile time — zero runtime cost.
  • World-class editor autocomplete, refactoring, and inline errors.
  • Generics, unions, and type inference for expressive contracts.
  • Ships .d.ts declaration files for typed library APIs.

Types are erased, so they don’t validate runtime data — JSON from an API can lie about its shape, and any or a careless cast silently disables all checking. Validate external input at the boundary (e.g. with a schema library) and keep strict mode on.

 TypeScript Microsoft + OSS community Apache-2.0
PHP The veteran server language that still powers most of the web.
★ standard{ }⚙
{ } Language⚙ Backend
★ standard gentle 1995

A dynamically typed server-side language designed for the web, embedded directly in HTML templates. Long mocked for its early inconsistencies, modern PHP (8.x) is a fast, type-hinted language with a strong framework ecosystem, and it still runs an enormous share of the web — WordPress alone powers a large slice of all sites.
3 use cases Server-rendered web apps and APIs (Laravel, Symfony). Show all
  • Server-rendered web apps and APIs (Laravel, Symfony).
  • Content management — WordPress, Drupal, and their plugin ecosystems.
  • Cheap, ubiquitous shared-hosting deployments.
4 features Embeddable in HTML with a simple request-per-script model. Show all
  • Embeddable in HTML with a simple request-per-script model.
  • Gradual typing, enums, and JIT compilation in PHP 8.
  • Composer package manager and a mature framework ecosystem.
  • Runs on virtually every host out of the box.

The ecosystem spans decades, so tutorials and Stack Overflow answers mix ancient mysql_* calls and global state with modern typed, framework-based code — and they look superficially alike. Target PHP 8.x, use a framework’s conventions, and ignore pre-PHP-7 advice.

 C The PHP Group + OSS community PHP License
Python Readable, batteries-included, and everywhere from web to AI.
★ standard{ }⚙
{ } Language⚙ Backend
★ standard gentle 1991

A dynamically typed, readability-first language used far beyond the web — in data science, machine learning, scripting, and automation. On the backend it powers fast async frameworks (FastAPI) and full-featured ones (Django), and optional type hints checked by external tools add safety to large codebases.
3 use cases Backend web APIs and full-stack apps (Django, FastAPI, Fl... Show all
  • Backend web APIs and full-stack apps (Django, FastAPI, Flask).
  • Data science, ML, and AI tooling and pipelines.
  • Automation, scripting, and glue code across systems.
 —
4 features Clean, indentation-based syntax with a huge standard libr... Show all
  • Clean, indentation-based syntax with a huge standard library.
  • Optional type hints checked by mypy / pyright (erased at runtime).
  • async/await for concurrent I/O in modern frameworks.
  • The dominant ecosystem for data, ML, and scientific computing.

Environment management is the classic pain — global installs, virtualenvs, and competing tools (pip, poetry, uv, conda) make reproducible setups fiddly. The Global Interpreter Lock also caps CPU-bound threading; reach for multiprocessing or async I/O instead.

 C (CPython) Python Software Foundation PSF License
Go Google’s simple, fast language for servers and tooling.
★ standard{ }⚙
{ } Language⚙ Backend
★ standard moderate 2009

A statically typed, compiled language from Google built for simplicity and concurrency. It compiles ahead of time to a single static binary with no runtime to install, has a tiny deliberate feature set, and ships goroutines and channels for lightweight concurrency — making it a favourite for backend services and cloud tooling.
3 use cases High-throughput backend services and microservices. Show all
  • High-throughput backend services and microservices.
  • CLI tools and cloud infrastructure (Docker, Kubernetes, Terraform).
  • Network servers where concurrency and a single binary matter.
 —
4 features Compiles to a single dependency-free static binary. Show all
  • Compiles to a single dependency-free static binary.
  • Goroutines and channels for cheap, built-in concurrency.
  • Fast compilation, gofmt, and a strong standard library.
  • Deliberately minimal — small language, fast to learn.

Go’s minimalism cuts both ways — verbose if err != nil error handling everywhere, and (until generics arrived in 1.18) repetitive code for generic containers. The deliberate lack of features that other languages take for granted frustrates some, but it’s the point: read-once, obvious code.

 Go (self-hosted) Google + OSS community BSD-3-Clause
Rust Memory safety without a garbage collector.
● mainstream{ }⚙
{ } Language⚙ Backend
● mainstream steep 2015

A systems language that guarantees memory and thread safety at compile time through its ownership and borrow-checker model — no garbage collector, no runtime overhead. It powers performance-critical backends, the fastest JavaScript build tools, and is a primary source language for WebAssembly.
3 use cases Performance-critical backend services and systems software. Show all
  • Performance-critical backend services and systems software.
  • JS toolchains compiled to native speed (SWC, Turbopack, Biome).
  • WebAssembly modules for CPU-heavy work in the browser.
 —
4 features Compile-time memory safety via ownership and borrowing — ... Show all
  • Compile-time memory safety via ownership and borrowing — no GC.
  • Zero-cost abstractions and predictable, native performance.
  • Fearless concurrency — data races caught at compile time.
  • Cargo: an excellent built-in build tool and package manager.

The borrow checker is a famously steep wall — ownership, lifetimes, and move semantics fight you constantly until they click, and compile times are slow. The payoff is that whole classes of bugs (use-after-free, data races) become impossible, but expect a real learning investment.

 Rust (self-hosted) Rust Foundation + OSS community MIT / Apache-2.0
WebAssembly Near-native speed in the browser, from any language.
● mainstream{ }▤
{ } Language▤ Frontend
● mainstream steep 2017

A portable binary instruction format — WASM — that runs at near- native speed in browsers and standalone runtimes. It’s a compile target, not a language you hand-write: code in Rust, C/C++, or Go compiles to a .wasm module that JavaScript can call, bringing heavy computation to the web.
3 use cases CPU-heavy browser work — image/video editing, games, simu... Show all
  • CPU-heavy browser work — image/video editing, games, simulations.
  • Porting existing C/C++/Rust libraries to run on the web.
  • Sandboxed plugin systems and edge compute (via WASI).
4 features Near-native execution speed in a sandboxed VM. Show all
  • Near-native execution speed in a sandboxed VM.
  • Compile target for Rust, C/C++, Go, and more.
  • Runs in every modern browser and standalone runtimes.
  • WASI extends it to server and edge compute outside the browser.

WASM can’t touch the DOM directly — every interaction crosses a JS boundary, and marshalling complex data across it can erase the speed win for chatty workloads. It shines on compute-bound tasks, not as a wholesale replacement for JavaScript UI code.

 n/a (bytecode target) W3C WebAssembly Working Group open standard
Ruby An elegant, developer-happiness-first scripting language.
★ standard{ }⚙
{ } Language⚙ Backend
★ standard gentle 1995

A dynamic, object-oriented scripting language designed by Yukihiro “Matz” Matsumoto to optimize for programmer happiness and readable, expressive code. Everything is an object, blocks and metaprogramming make it endlessly malleable, and on the web it powers Ruby on Rails — the framework that popularized convention-over-configuration.
3 use cases Web backends and full-stack apps via Ruby on Rails. Show all
  • Web backends and full-stack apps via Ruby on Rails.
  • Build tooling and static sites (Jekyll, Bundler, Fastlane).
  • Scripts, automation, and command-line tools.
 —
4 features Pure object model — even integers and nil are objects. Show all
  • Pure object model — even integers and nil are objects.
  • Blocks, procs, and lambdas for concise iteration.
  • Metaprogramming (define_method, method_missing) for DSLs.
  • Huge gem ecosystem managed by Bundler.

Ruby’s expressiveness comes at a raw-speed cost — it is slower than compiled languages, and heavy metaprogramming or monkey-patching can make large codebases hard to reason about and debug. The YJIT compiler narrows the performance gap but does not close it.

 Ruby Ruby core team / Matz Ruby/BSD-2-Clause
SQL The declarative language for relational data.
★ standard{ }▣
{ } Language▣ Database
★ standard moderate 1974

Structured Query Language is the standard, declarative language for defining and querying relational data — you describe what result you want and the database’s query planner figures out how to get it. Nearly every relational database (PostgreSQL, MySQL, SQLite, SQL Server) speaks a dialect of it, making it one of the most durable skills in software.
3 use cases Querying and joining data across relational tables. Show all
  • Querying and joining data across relational tables.
  • Defining schemas, constraints, indexes, and migrations.
  • Aggregation, reporting, and analytics over large datasets.
 —
4 features Declarative SELECT/JOIN/WHERE/GROUP BY query model. Show all
  • Declarative SELECT/JOIN/WHERE/GROUP BY query model.
  • ACID transactions and referential integrity constraints.
  • Window functions and CTEs for advanced analytics.
  • Portable core standard across many database engines.

“SQL” is a standard with many dialects — LIMIT vs TOP, JSON functions, upserts, and date handling all differ between PostgreSQL, MySQL, and SQL Server, so queries rarely port unchanged. The infamous N+1 query pattern from ORMs also quietly destroys performance.

 — ISO/IEC (standard); RDBMS vendors ISO standard
C# Microsoft’s versatile, statically typed multi-paradigm language.
★ standard{ }⚙
{ } Language⚙ Backend
★ standard moderate 2000

A statically typed, object-oriented language from Microsoft that runs on the cross-platform, open-source .NET runtime. Modern C# blends OOP with functional features (pattern matching, records, LINQ) and powers web backends via ASP.NET Core, desktop and mobile apps, games (Unity), and cloud services.
3 use cases Web APIs and full-stack apps with ASP.NET Core and Blazor. Show all
  • Web APIs and full-stack apps with ASP.NET Core and Blazor.
  • Cross-platform game development with Unity.
  • Enterprise, desktop, and cloud (Azure) services.
 —
4 features Strong static typing with rich generics and nullable refs. Show all
  • Strong static typing with rich generics and nullable refs.
  • LINQ for declarative, composable data queries.
  • async/await — the pattern much of the industry copied.
  • Records, pattern matching, and source generators.

The .NET ecosystem has a churn of overlapping UI stacks (WinForms, WPF, MAUI, Blazor) and the legacy “.NET Framework” vs modern cross-platform “.NET” split still confuses newcomers — always target current .NET, not the Windows-only Framework, for new work.

 C# Microsoft + .NET Foundation MIT (Roslyn/.NET)
Dart The client-optimized language behind Flutter.
● mainstream{ }▤
{ } Language▤ Frontend
● mainstream moderate 2011

A statically typed, object-oriented language from Google designed for building fast apps on any platform. It is best known as the language of Flutter — Dart’s ahead-of-time compilation produces native binaries for mobile and desktop, while its JIT mode powers Flutter’s stateful hot reload during development.
3 use cases Cross-platform mobile and desktop apps with Flutter. Show all
  • Cross-platform mobile and desktop apps with Flutter.
  • Web frontends compiled to JavaScript or WebAssembly.
  • Command-line tools and backend services.
 —
4 features Dual JIT (dev) and AOT (release) compilation. Show all
  • Dual JIT (dev) and AOT (release) compilation.
  • Sound null safety baked into the type system.
  • Isolates for concurrency without shared-memory races.
  • Compiles to native, JavaScript, and WebAssembly.

Dart’s gravity is almost entirely Flutter — outside that ecosystem its library and hiring pool are thin, so adopting it for non-Flutter work means a smaller community than mainstream alternatives. Web output also ships a larger runtime than hand-written JavaScript.

 Dart Google BSD-3-Clause
Node.js The runtime that brought JavaScript to the server.
★ standard⚙🔧
⚙ Backend🔧 Tooling
★ standard moderate 2009

The original server-side JavaScript runtime, built on Google’s V8 engine with an event-driven, non-blocking I/O model. It anchors the entire JS toolchain — almost every build tool, framework, and package runs on it — and its npm ecosystem is the largest package registry in existence.
3 use cases Backend APIs, servers, and full-stack frameworks (Next.js... Show all
  • Backend APIs, servers, and full-stack frameworks (Next.js, Nest).
  • The runtime under nearly all JS build tooling and CLIs.
  • Real-time services using its event loop and streams.
4 features Event-driven, non-blocking I/O on a single-threaded event... Show all
  • Event-driven, non-blocking I/O on a single-threaded event loop.
  • The npm registry — the largest package ecosystem anywhere.
  • Native ESM, the test runner, and --watch mode built in.
  • Yearly major releases — one Active LTS at a time.

Years of churn left two module systems coexisting — older CommonJS (require) and modern ESM (import) — and mixing them across packages still causes friction. New code should be ESM. Also pick an LTS line (24 or 22) for production, not the Current release.

 C++ / JavaScript OpenJS Foundation + OSS community MIT
Deno A secure, batteries-included runtime from Node’s creator.
● mainstream⚙🔧
⚙ Backend🔧 Tooling
● mainstream moderate 2018

A modern JavaScript and TypeScript runtime built in Rust on V8, created by Node’s original author to fix its early design regrets. It runs TypeScript with no build step, is secure by default (explicit permission flags for file, network, and env access), and Deno 2 added strong npm compatibility.
3 use cases TypeScript-first backends and scripts with no build step. Show all
  • TypeScript-first backends and scripts with no build step.
  • Secure-by-default tooling where permission sandboxing matters.
  • Edge functions and serverless on Deno Deploy.
4 features First-class TypeScript — runs .ts directly, no config. Show all
  • First-class TypeScript — runs .ts directly, no config.
  • Secure by default — explicit --allow-net/--allow-read flags.
  • Built-in formatter, linter, test runner, and bundler.
  • Web-standard APIs (fetch, Request) and npm compatibility (Deno 2).

Despite Deno 2’s npm compatibility, some packages that depend on deep Node internals or native addons still don’t run cleanly — verify your critical dependencies. The default global install pulls remote URL imports, which can surprise teams used to a single package.json lockfile.

 Rust Deno Land Inc. + OSS community MIT
Bun The fast all-in-one runtime, bundler, and package manager.
▲ rising⚙🔧
⚙ Backend🔧 Tooling
▲ rising moderate 2022

A blazing-fast JavaScript runtime written in Zig on Apple’s JavaScriptCore engine (not V8), bundling a runtime, package manager, bundler, and test runner into one binary. It aims for drop-in Node compatibility while being dramatically faster at install and startup. Anthropic acquired Bun in December 2025 — it powers Claude Code and stays MIT-licensed and open source.
3 use cases Fast local dev — install, run, test, and bundle from one ... Show all
  • Fast local dev — install, run, test, and bundle from one tool.
  • Node-compatible backends wanting quicker startup and installs.
  • Scripts and tooling where the all-in-one binary cuts setup.
4 features Runtime + package manager + bundler + test runner in one ... Show all
  • Runtime + package manager + bundler + test runner in one binary.
  • Built on JavaScriptCore for fast startup; very fast bun install.
  • Drop-in Node compatibility for most packages and APIs.
  • Native TypeScript and JSX execution with no build step.

Compatibility is most of Node, not all — packages leaning on obscure Node internals or native addons can still break, so test production-critical dependencies before switching. Being the youngest runtime here, it’s the least battle-tested at scale despite its momentum.

 Zig Anthropic (acq. Dec 2025) + OSS community MIT
V8 Google’s JavaScript engine that powers Chrome and Node.
★ standard🔧
🔧 Tooling
★ standard steep 2008

Google’s open-source, high-performance JavaScript and WebAssembly engine written in C++. It compiles JS to machine code with a JIT compiler and powers Chrome, Node.js, Deno, Electron, and Cloudflare’s edge — you rarely use it directly, but nearly everything you run sits on top of it.
3 use cases The engine embedded in Chrome, Node.js, Deno, and Electron. Show all
  • The engine embedded in Chrome, Node.js, Deno, and Electron.
  • Powering Cloudflare Workers’ isolate-based edge runtime.
  • Embedding a JS engine inside a C++ application.
4 features JIT compilation of JavaScript to native machine code. Show all
  • JIT compilation of JavaScript to native machine code.
  • Generational garbage collector tuned for web workloads.
  • Runs WebAssembly alongside JavaScript.
  • Lightweight isolates enable thousands of sandboxes per process.

You almost never touch V8 directly — it’s an implementation detail of the runtime you actually use. The trap is over-tuning to its JIT quirks (hidden-class deopts, micro-benchmarks) when the engine is so fast that readable code wins in practice.

 C++ Google BSD-3-Clause
Cloudflare Workers Serverless code running on V8 isolates at the edge.
● mainstream⚙☁
⚙ Backend☁ Infra
● mainstream moderate 2017

A serverless platform that runs your code on V8 isolates across Cloudflare’s global edge network — close to users, with near-zero cold starts. The underlying runtime, workerd, is open source, and Workers use web-standard APIs plus a storage suite (KV, D1, R2, Durable Objects) rather than full Node.
3 use cases Low-latency edge APIs and middleware close to users. Show all
  • Low-latency edge APIs and middleware close to users.
  • Serverless functions with near-zero cold starts at global scale.
  • Static-site backends paired with Cloudflare Pages.
4 features V8 isolates — near-zero cold starts, not per-request cont... Show all
  • V8 isolates — near-zero cold starts, not per-request containers.
  • Global edge network — code runs near every user.
  • Storage suite: KV, D1 (SQLite), R2, Durable Objects.
  • Open-source workerd runtime with web-standard APIs.

It’s not Node — there’s no filesystem, long-running processes are limited, and CPU time per request is capped, so you rely on web-standard APIs and Cloudflare’s storage primitives instead of arbitrary npm packages. Code written for a full Node server won’t lift-and-shift unchanged.

 C++ / Rust (workerd) Cloudflare Apache-2.0 (workerd)
Edge runtimes The web-standard runtime model behind edge & serverless functions.
▲ rising⚙☁
⚙ Backend☁ Infra
▲ rising moderate 2021

A family of lightweight runtimes — Vercel Edge Functions, Netlify Edge, Deno Deploy, and the WinterCG-aligned standard — that run a restricted, web-standard JavaScript environment (fetch, Request, Response, Web Streams) on global infrastructure rather than full Node. The trade is faster cold starts and global distribution for a smaller API surface.
3 use cases Latency-sensitive middleware, redirects, and personalizat... Show all
  • Latency-sensitive middleware, redirects, and personalization.
  • Lightweight serverless functions distributed near users.
  • Framework edge rendering (Next.js, SvelteKit) at the network edge.
4 features Web-standard APIs (fetch, Request, Response, streams). Show all
  • Web-standard APIs (fetch, Request, Response, streams).
  • Fast cold starts and global distribution over single-region servers.
  • WinterCG-aligned API surface for portability across providers.
  • Restricted vs Node — no filesystem, limited CPU/runtime per request.

“Edge” means a restricted runtime, not just a faster Node — Node-only APIs, native addons, and many npm packages won’t run, and CPU/time limits are tight. Reach for it for light, latency-sensitive logic; keep heavy or Node-dependent work on a regular server runtime.

 JavaScript / C++ Vercel / Netlify / WinterCG + others varies (mostly permissive)
workerd The open-source runtime that powers Cloudflare Workers.
▲ rising⚙☁
⚙ Backend☁ Infra
▲ rising moderate 2022

The C++ JavaScript/WebAssembly runtime that Cloudflare extracted and open-sourced from the engine behind Cloudflare Workers. Built on V8, it implements web-standard APIs (Fetch, Streams, WebCrypto) and the edge-style request/response model, so you can run and self-host the same Workers code locally that ships to Cloudflare’s global network.
3 use cases Running and debugging Cloudflare Workers locally and in CI. Show all
  • Running and debugging Cloudflare Workers locally and in CI.
  • Self-hosting serverless functions on your own infrastructure.
  • A web-standard runtime target for portable edge code.
4 features V8-based with web-standard Fetch/Streams/WebCrypto APIs. Show all
  • V8-based with web-standard Fetch/Streams/WebCrypto APIs.
  • Same runtime locally as on Cloudflare’s edge network.
  • Nanoservice architecture wiring Workers together.
  • Powers Wrangler’s local dev and Miniflare.

It is not a general-purpose Node replacement — it deliberately offers the restricted Workers runtime, so Node-only built-ins, native addons, and long-running processes are unavailable, and configuration uses Cap’n Proto (.capnp) files rather than a familiar JSON/JS config.

 C++ Cloudflare Apache-2.0
React The component library that defined modern frontend.
★ standard▤
▤ Frontend
★ standard moderate 2013

A declarative JavaScript library for building user interfaces from composable components. Uses a virtual DOM and one-way data flow, and ships as a view layer you compose with a router, build tool, and state solution — or adopt a meta-framework that bundles those for you.
3 use cases Interactive SPAs and dashboards with lots of dynamic state. Show all
  • Interactive SPAs and dashboards with lots of dynamic state.
  • Design systems and reusable component libraries.
  • The base layer under a meta-framework like Next.js.
4 features Function components with hooks for state and side-effects. Show all
  • Function components with hooks for state and side-effects.
  • Virtual DOM diffing and reconciliation.
  • React Server Components for zero-JS server rendering.
  • The largest ecosystem and job market of any UI library.

React is just the view layer — you assemble routing, data fetching, and a build tool yourself (or adopt a meta-framework). The rules of hooks (no conditional hooks) and stale-closure bugs trip up newcomers.

 JavaScript Meta + OSS community MIT
Vue The approachable, progressively adoptable framework.
★ standard▤
▤ Frontend
★ standard gentle 2014

A progressive framework with single-file components (.vue files bundling template, script, and style). Its reactivity system tracks dependencies automatically, and you can drop it into a page or scale up to a full SPA with Vue Router and Pinia.
3 use cases SPAs where a gentle learning curve and clear conventions ... Show all
  • SPAs where a gentle learning curve and clear conventions matter.
  • Progressive enhancement — sprinkle Vue onto existing pages.
  • Teams wanting batteries-included official router + store.
4 features Single-file components with scoped styles. Show all
  • Single-file components with scoped styles.
  • Composition API with automatic, fine-grained reactivity.
  • Official router (Vue Router) and store (Pinia).
  • Experimental Vapor mode compiles away the virtual DOM.

Two API styles coexist — the older Options API and the newer Composition API (<script setup>); tutorials mix them, which confuses beginners. Prefer the Composition API for new code.

 TypeScript Evan You / Vue core team + OSS MIT
Svelte A compiler, not a runtime — reactivity that disappears at build.
● mainstream▤
▤ Frontend
● mainstream gentle 2016

A UI framework that shifts work to a compile step: it compiles your components into small, imperative vanilla JS that updates the DOM directly, so there’s almost no framework runtime to ship. Svelte 5’s runes ($state, $derived, $effect) make reactivity explicit and fine-grained.
3 use cases Performance- and bundle-size-sensitive apps and widgets. Show all
  • Performance- and bundle-size-sensitive apps and widgets.
  • Embeddable components dropped into other sites.
  • Developers who want less boilerplate than React.
4 features Compile-time reactivity — minimal runtime overhead. Show all
  • Compile-time reactivity — minimal runtime overhead.
  • Runes ($state/$derived/$effect) for explicit signals.
  • Scoped styles and transitions built in.
  • Tiny bundles versus virtual-DOM frameworks.

Svelte 5 replaced the old let-is-reactive magic and $: labels with runes — a real migration. Older tutorials and libraries written for Svelte 4 won’t match current syntax.

 TypeScript Svelte core team (Vercel-sponsored) + OSS MIT
Angular Google’s batteries-included, opinionated framework.
★ standard▤
▤ Frontend
★ standard steep 2016

A complete, opinionated framework (not just a view layer) from Google, built around TypeScript, dependency injection, and a powerful CLI. Recent versions move to standalone components, explicit Signals, and zoneless change detection, modernizing what was a heavyweight reputation.
3 use cases Large enterprise apps needing strong structure and conven... Show all
  • Large enterprise apps needing strong structure and conventions.
  • Teams that want routing, forms, HTTP, and i18n in one package.
  • Long-lived codebases where consistency beats flexibility.
4 features Full framework: router, forms, HTTP client, DI, CLI. Show all
  • Full framework: router, forms, HTTP client, DI, CLI.
  • Signals + zoneless change detection in modern versions.
  • Standalone components (no NgModules required).
  • First-class TypeScript and RxJS integration.

The steepest curve of the mainstream frameworks — DI, decorators, modules vs standalone, and RxJS are a lot to absorb at once. The framework has also churned its idioms (modules → standalone, zones → signals) across versions.

 TypeScript Google + OSS community MIT
SolidJS React-like ergonomics with true fine-grained reactivity.
▲ rising▤
▤ Frontend
▲ rising moderate 2021

A reactive UI library with JSX that looks like React but has no virtual DOM. Components run once; fine-grained signals update only the exact DOM nodes that depend on changed state, giving excellent performance and tiny bundles.
3 use cases Performance-critical UIs where React's re-render model is... Show all
  • Performance-critical UIs where React’s re-render model is a bottleneck.
  • Developers who like JSX but want finer reactivity.
  • Interactive widgets with a minimal footprint.
4 features Fine-grained signals — no virtual DOM, no re-renders. Show all
  • Fine-grained signals — no virtual DOM, no re-renders.
  • JSX syntax familiar to React developers.
  • SolidStart meta-framework for SSR.
  • Very small runtime and fast benchmarks.

It looks like React but isn’t — components run once, so destructuring props or calling a signal outside a tracking scope silently breaks reactivity. The mental model differs more than the syntax suggests.

 TypeScript Ryan Carniato + OSS community MIT
Preact A 3 KB React-compatible alternative.
● mainstream▤
▤ Frontend
● mainstream gentle 2015

A fast, ~3 KB alternative to React with the same modern API. A preact/compat shim lets most React libraries run on it unchanged, so you can shrink an existing React app’s bundle or build new lightweight widgets.
3 use cases Bundle-size-sensitive apps and embeddable widgets. Show all
  • Bundle-size-sensitive apps and embeddable widgets.
  • Drop-in shrink of an existing React app via preact/compat.
  • Browser extensions and ads where every KB counts.
3 features ~3 KB runtime with React-compatible hooks API. Show all
  • ~3 KB runtime with React-compatible hooks API.
  • preact/compat aliases most React libraries.
  • Signals package for fine-grained reactivity.

“React-compatible” is ~95% — some libraries lean on React internals and need the preact/compat alias configured, and a few don’t work at all. Test third-party React components before committing.

 JavaScript Jason Miller + OSS community MIT
Alpine.js jQuery for the modern web — behavior in your markup.
● mainstream▤
▤ Frontend
● mainstream gentle 2019

A tiny (~15 KB) framework for sprinkling reactive behavior directly into HTML via x- attributes — no build step, no components, no virtual DOM. Ideal for adding interactivity to server-rendered pages.
3 use cases Adding interactivity to server-rendered HTML (Laravel, Ra... Show all
  • Adding interactivity to server-rendered HTML (Laravel, Rails, Django).
  • Small dropdowns, modals, tabs without a full SPA framework.
  • Projects that want zero build tooling.
3 features Declarative x-data / x-show / x-on attributes in markup. Show all
  • Declarative x-data / x-show / x-on attributes in markup.
  • No build step — drop in a single script tag.
  • Tiny footprint, pairs with Tailwind for the ‘TALL’ stack.

Great for sprinkles, painful for real app state — there’s no component model or routing, so complex UIs become a tangle of attributes. Reach for a real framework once logic outgrows the markup.

 JavaScript Caleb Porzio + OSS community MIT
Lit Tiny library for fast, standards-based Web Components.
● mainstream▤
▤ Frontend
● mainstream moderate 2019

A lightweight library from Google for building reusable Web Components — custom elements that work in any framework or none. Uses tagged-template literals for fast, declarative rendering with reactive properties.
3 use cases Framework-agnostic design systems and shared component li... Show all
  • Framework-agnostic design systems and shared component libraries.
  • Components that must work across React, Vue, and plain HTML.
  • Long-lived widgets built on web standards, not a framework.
3 features Standards-based custom elements — run anywhere. Show all
  • Standards-based custom elements — run anywhere.
  • Reactive properties with efficient template rendering.
  • ~5 KB core; decorators for ergonomic TypeScript.

Web Components bring their own quirks — Shadow DOM style encapsulation, form-association gaps, and SSR that’s less mature than framework rendering. Great for portable widgets, less so for full apps.

 TypeScript Google + OSS community BSD-3-Clause
htmx Access AJAX, WebSockets & more straight from HTML attributes.
▲ rising▤
▤ Frontend
▲ rising gentle 2020

A small library that lets any HTML element issue HTTP requests and swap the returned HTML fragment into the page via attributes (hx-get, hx-post, hx-target). It pushes rendering back to the server, shrinking or eliminating client-side JavaScript for many apps.
3 use cases Server-rendered apps that want SPA-like interactivity wit... Show all
  • Server-rendered apps that want SPA-like interactivity without a JS framework.
  • Backends in Go, Python, PHP, or Ruby driving the UI with HTML fragments.
  • Teams minimizing frontend build complexity.
3 features AJAX, WebSockets, SSE via HTML attributes — minimal JS. Show all
  • AJAX, WebSockets, SSE via HTML attributes — minimal JS.
  • Server returns HTML fragments, not JSON.
  • ~14 KB, no build step, no dependencies.

The interactivity ceiling is real — rich client-side state (drag-drop, complex forms, offline) still wants a JS framework. And every interaction is a server round-trip, so latency and endpoint sprawl can grow.

 JavaScript Big Sky Software + OSS community BSD-2-Clause
Ember.js The original convention-over-configuration JS framework.
▼ legacy▤
▤ Frontend
▼ legacy steep 2011

A highly opinionated, batteries-included framework that brought convention-over-configuration to ambitious SPAs years before React. It ships a router, data layer (Ember Data), and a powerful CLI, and its modern “Polaris” edition adopts Glimmer components and reactive signals — but its ecosystem and mindshare have faded against React and Vue.
3 use cases Long-lived, large enterprise apps that value stability an... Show all
  • Long-lived, large enterprise apps that value stability and convention.
  • Teams wanting an all-in-one framework with a strong upgrade path.
  • Maintaining existing Ember codebases.
4 features Batteries-included: router, data layer, CLI, testing. Show all
  • Batteries-included: router, data layer, CLI, testing.
  • Strong conventions and a managed multi-year upgrade path.
  • Glimmer components with template-tag (.gjs) authoring.
  • Reactive tracked properties / signals in modern Ember.

Ember has churned heavily — classic components, Glimmer components, Octane, and now Polaris each shifted idioms, so much of the documentation and add-on ecosystem is stale. Hiring and community momentum lag far behind React and Vue, making it a hard sell for greenfield projects.

 JavaScript Ember core team + OSS MIT
Stencil A compiler that outputs standards-based Web Components.
● mainstream▤🔧
▤ Frontend🔧 Tooling
● mainstream moderate 2017

A toolchain from the Ionic team that compiles TypeScript + JSX components into tiny, framework-agnostic Web Components. The output runs in any framework or none, making Stencil a popular choice for building portable design systems.
3 use cases Framework-agnostic design systems shared across React, Vu... Show all
  • Framework-agnostic design systems shared across React, Vue, Angular.
  • Reusable UI component libraries distributed as custom elements.
  • Micro-frontends that must interoperate across stacks.
4 features Compiles JSX/TSX to standard custom elements. Show all
  • Compiles JSX/TSX to standard custom elements.
  • Lazy-loading, prerendering, and SSR-friendly output.
  • Auto-generated framework wrappers (React/Angular/Vue).
  • Built-in lazy hydration and small runtime.

You inherit Web Component constraints — Shadow DOM style isolation, slot quirks, and form-participation gaps — and the auto-generated framework wrappers can lag behind framework releases. It is purpose-built for component libraries, not for whole applications.

 TypeScript Ionic team MIT
Marko eBay’s HTML-first framework with streaming SSR.
▲ rising▤▦
▤ Frontend▦ Full-stack
▲ rising moderate 2014

An HTML-first UI framework created at eBay that pioneered streaming server rendering and partial hydration. Marko 6 introduced a fine-grained, compiler-driven reactivity model that ships almost no JavaScript for static parts of a page, making it one of the most performance-focused frameworks available.
3 use cases High-traffic, SEO- and performance-critical e-commerce si... Show all
  • High-traffic, SEO- and performance-critical e-commerce sites.
  • Content-heavy pages that benefit from streaming SSR.
  • Apps that want minimal client-side JavaScript by default.
4 features HTML-superset syntax with components in .marko files. Show all
  • HTML-superset syntax with components in .marko files.
  • Streaming SSR with automatic, fine-grained partial hydration.
  • Compiler ships near-zero JS for static content.
  • Resumability rather than full client re-hydration.

Marko’s ecosystem and hiring pool are small relative to its capabilities, and Marko 6 is a substantial rewrite, so older tutorials and tags do not match current syntax. Tooling outside the official Vite/Run setup is limited.

 JavaScript eBay + OSS MIT
Next.js The default full-stack React framework.
★ standard▦▤
▦ Full-stack▤ Frontend
★ standard moderate 2016

Vercel’s React meta-framework and the most common way to ship a React app in production. The modern App Router is built on React Server Components and supports every rendering mode — SSR, SSG, and ISR — alongside server actions, file-system routing, and built-in image and font optimization.
3 use cases Production React apps that need SSR or SSG out of the box. Show all
  • Production React apps that need SSR or SSG out of the box.
  • Content sites, dashboards, and e-commerce on one framework.
  • Teams that want routing, data fetching, and an API layer bundled.
4 features App Router built on React Server Components. Show all
  • App Router built on React Server Components.
  • SSR, SSG, and ISR per route — mix and match.
  • Server actions and file-system routing.
  • Built-in image, font, and script optimization.

The App Router’s server/client split is a real mental shift — the "use client" boundary, where data fetching may run, and caching defaults all trip people up. It also leans toward Vercel’s platform; self-hosting works but some features (ISR, image optimization) need extra setup elsewhere.

 TypeScript Vercel + OSS community MIT
React Router Routing library turned full-stack React framework.
★ standard▦▤
▦ Full-stack▤ Frontend
★ standard moderate 2014

Long the de-facto router for React, v7 absorbed Remix’s framework features so the same package now spans a plain client-side router up to a full SSR framework with loaders, actions, and nested routing. You adopt it as a library or opt into “framework mode” for the batteries-included experience.
3 use cases Client-side routing in any React SPA. Show all
  • Client-side routing in any React SPA.
  • Full-stack React apps wanting loaders/actions without Next.js.
  • Migrating an existing Remix app — it’s the same code now.
4 features Nested routes with data loaders and actions. Show all
  • Nested routes with data loaders and actions.
  • Works as a plain router or a full SSR framework.
  • Framework mode is the former Remix, merged in.
  • Vite-based dev and build in framework mode.

The Remix-to-React-Router-v7 merge means docs, tutorials, and package names from before the rename now point at “framework mode” — expect confusion about which name and version a given guide assumes. Library mode and framework mode also look quite different.

 TypeScript Remix team (Shopify) + OSS MIT
Nuxt The full-stack framework for Vue.
★ standard▦▤
▦ Full-stack▤ Frontend
★ standard moderate 2016

Vue’s meta-framework — what Next.js is to React. It adds file-system routing, SSR / SSG, auto-imports, and a server engine (Nitro) that deploys to almost any host or edge runtime. A large module ecosystem covers auth, content, images, and SEO.
3 use cases Production Vue apps needing SSR, SSG, or hybrid rendering. Show all
  • Production Vue apps needing SSR, SSG, or hybrid rendering.
  • Content-heavy sites via Nuxt Content.
  • Teams wanting Vue with conventions and auto-imports.
4 features File-system routing and component auto-imports. Show all
  • File-system routing and component auto-imports.
  • SSR, SSG, and hybrid rendering per route.
  • Nitro server engine deploys anywhere, including the edge.
  • Rich module ecosystem (content, image, auth, SEO).

The magic — auto-imports, implicit server/client boundaries, and module conventions — is convenient until something breaks and you have to figure out where a function came from. Pinning module versions across a Nuxt major upgrade can also be fiddly.

 TypeScript Nuxt core team + OSS community MIT
SvelteKit The official app framework for Svelte.
● mainstream▦▤
▦ Full-stack▤ Frontend
● mainstream gentle 2022

Svelte’s full-stack framework, built on Vite. It adds file-system routing, load functions, form actions, and an adapter system that targets Node, serverless, static, or edge hosts — mixing SSR, SSG, and SPA rendering per route.
3 use cases Production Svelte apps with SSR or static output. Show all
  • Production Svelte apps with SSR or static output.
  • Small-to-medium apps wanting minimal boilerplate.
  • Sites deployed to varied hosts via swappable adapters.
4 features File-system routing with load functions and form actions. Show all
  • File-system routing with load functions and form actions.
  • Adapters for Node, serverless, static, and edge targets.
  • Per-route choice of SSR, SSG, or client rendering.
  • Vite-powered dev server with fast HMR.

You must pick the right adapter for your host — deploy errors often trace back to using adapter-auto or the wrong target. And SvelteKit rides Svelte’s own churn, so a Svelte 5 runes migration ripples into your app code too.

 TypeScript Svelte core team (Vercel-sponsored) + OSS MIT
Astro Content-first framework that ships zero JS by default.
● mainstream▦▤
▦ Full-stack▤ Frontend
● mainstream gentle 2021

A framework optimized for content-heavy sites. Its islands architecture renders pages to static HTML and ships JavaScript only for the interactive components you explicitly hydrate — and those islands can be React, Vue, Svelte, or Solid in the same project. It also supports SSR when you need a server.
3 use cases Blogs, docs, and marketing sites where speed and SEO matter. Show all
  • Blogs, docs, and marketing sites where speed and SEO matter.
  • Content sites that need a few interactive islands, not a full SPA.
  • Mixing components from React, Vue, and Svelte in one project.
4 features Islands architecture — zero JS shipped by default. Show all
  • Islands architecture — zero JS shipped by default.
  • Use React, Vue, Svelte, or Solid components together.
  • Static output by default, SSR via adapters.
  • Built-in content collections with typed frontmatter.

It shines for content but fights you for app-like UI — heavily interactive dashboards with shared client state cut against the islands grain. Watch the hydration directives (client:load vs client:visible): over-hydrating quietly throws away Astro’s zero-JS advantage.

 TypeScript Astro Technology Company + OSS MIT
Gatsby The React static-site generator that defined the JAMstack era.
▼ legacy▦▤
▦ Full-stack▤ Frontend
▼ legacy moderate 2015

A React static-site generator built around a GraphQL data layer that pulls content from CMSes, Markdown, and APIs at build time. It popularized the JAMstack but has lost momentum to Next.js and Astro since the Netlify acquisition, and is best treated as a legacy choice for new projects.
3 use cases Maintaining existing Gatsby sites and their plugin ecosys... Show all
  • Maintaining existing Gatsby sites and their plugin ecosystem.
  • Content sites sourcing from many CMSes via one GraphQL layer.
  • Static marketing and documentation sites (legacy stacks).
4 features Unified GraphQL data layer over many sources. Show all
  • Unified GraphQL data layer over many sources.
  • Large plugin ecosystem for CMSes and transforms.
  • Image optimization and progressive loading built in.
  • Static output with optional SSR / DSG modes.

Momentum has clearly shifted away — issues and plugins go stale, and the GraphQL-everything data layer is a lot of ceremony for a simple site. Reach for Astro or Next.js on greenfield work; keep Gatsby for sites already built on it.

 JavaScript Netlify MIT
Qwik Resumability instead of hydration — instant-loading apps.
▲ rising▦▤
▦ Full-stack▤ Frontend
▲ rising steep 2022

A framework built around resumability: instead of replaying app setup on the client (hydration), it serializes execution state into the HTML and resumes exactly where the server left off, downloading JavaScript only as the user interacts. The goal is constant startup time regardless of app size.
3 use cases Large apps where hydration cost dominates startup time. Show all
  • Large apps where hydration cost dominates startup time.
  • Content + commerce sites needing fast interactivity at scale.
  • Teams willing to adopt a newer model for time-to-interactive.
4 features Resumability — no hydration replay on load. Show all
  • Resumability — no hydration replay on load.
  • Fine-grained lazy loading of JS per interaction.
  • JSX syntax familiar to React developers.
  • Qwik City meta-framework for routing and SSR.

Resumability changes how you write code — the $ boundaries that mark lazy-loadable, serializable code are unfamiliar and easy to get wrong, and not every value can be serialized across the server/client gap. The ecosystem is also much smaller than React’s or Vue’s.

 TypeScript Builder.io + OSS community MIT
Remix Web-standards full-stack framework — now charting its own course.
● mainstream▦▤
▦ Full-stack▤ Frontend
● mainstream moderate 2021

A full-stack framework built on web fundamentals — fetch, Request / Response, forms, and progressive enhancement — with nested routes, loaders, and actions. Its framework features merged into React Router v7, and the Remix name is now being reframed as a standalone, model-agnostic full-stack framework (the v3 direction).
3 use cases Apps that lean on web standards and progressive enhancement. Show all
  • Apps that lean on web standards and progressive enhancement.
  • Form-heavy UIs where loaders/actions map cleanly to routes.
  • Following the framework’s v3 standalone direction.
4 features Loaders and actions colocated with nested routes. Show all
  • Loaders and actions colocated with nested routes.
  • Built on Web Fetch API Request/Response primitives.
  • Progressive enhancement — forms work without JS.
  • Framework features now live inside React Router v7.

Remix’s identity is in flux — its React framework features became React Router v7, while the Remix name is being repositioned as a separate v3 project. Check carefully which “Remix” a tutorial or package means before starting new work.

 TypeScript Remix team (Shopify) + OSS MIT
Eleventy A simpler, zero-config JavaScript static site generator.
● mainstream▦🔧
▦ Full-stack🔧 Tooling
● mainstream gentle 2018

A flexible JavaScript static site generator (often called 11ty) that takes templates in many languages — Markdown, Nunjucks, Liquid, HTML, JS — and outputs plain HTML with no client-side JavaScript by default. It is prized for shipping zero-JS, fast-loading sites and for being far lighter than React-based generators.
3 use cases Blogs, docs, and marketing sites that want zero shipped JS. Show all
  • Blogs, docs, and marketing sites that want zero shipped JS.
  • Migrating off heavier generators for build speed.
  • JAMstack sites with content in Markdown and a CDN host.
4 features Mix many template languages in one project. Show all
  • Mix many template languages in one project.
  • Zero client-side JavaScript by default.
  • Data cascade for layering global, directory, and page data.
  • Fast incremental builds and a small dependency tree.

The same flexibility that makes 11ty powerful makes it easy to sprawl — it has no built-in component model or asset pipeline, so you wire up CSS/JS bundling yourself, and the many supported template languages mean project conventions vary widely between codebases.

 JavaScript Zach Leatherman + OSS MIT
Hugo The world’s fastest static site generator, written in Go.
● mainstream▦🔧
▦ Full-stack🔧 Tooling
● mainstream moderate 2013

A static site generator written in Go that is renowned for building thousands of pages in milliseconds. It uses Go’s templating, has a powerful content/taxonomy model, and ships as a single self-contained binary with no Node or runtime dependency.
3 use cases Large content sites and documentation with thousands of p... Show all
  • Large content sites and documentation with thousands of pages.
  • Blogs and portfolios where build speed and simplicity matter.
  • Teams that prefer a single binary over a Node toolchain.
4 features Extremely fast builds — pages per millisecond. Show all
  • Extremely fast builds — pages per millisecond.
  • Single self-contained binary, no runtime dependencies.
  • Rich taxonomies, sections, and content organization.
  • Built-in asset pipeline (Hugo Pipes) and image processing.

Go’s templating syntax ({{ }} with pipelines and contexts) is idiosyncratic and a real learning curve for those used to JSX or Liquid, and Hugo has no JavaScript component model, so dynamic interactivity must be added by hand outside the generator.

 Go Hugo team + OSS Apache-2.0
Jekyll Ruby’s blog-aware static site generator, native to GitHub Pages.
● mainstream▦🔧
▦ Full-stack🔧 Tooling
● mainstream gentle 2008

A Ruby static site generator that turns Markdown, Liquid templates, and front-matter into a static site. As the engine baked into GitHub Pages, it is one of the easiest ways to publish a free, version-controlled blog or docs site with zero hosting setup.
3 use cases Blogs and personal sites hosted free on GitHub Pages. Show all
  • Blogs and personal sites hosted free on GitHub Pages.
  • Documentation and project sites kept in a Git repo.
  • Content-driven sites where Markdown + front-matter is enough.
4 features Liquid templating with layouts, includes, and front-matter. Show all
  • Liquid templating with layouts, includes, and front-matter.
  • Blog-aware: posts, categories, tags, and pagination built in.
  • Native GitHub Pages integration — push to publish.
  • Data files and collections for structured content.

Builds are slow on large sites compared with Hugo or Eleventy, and the Ruby/Bundler toolchain plus the specific Liquid dialect GitHub Pages pins can make local setup and plugin support fiddly — GitHub Pages only allows a whitelist of plugins unless you build the site yourself.

 Ruby Jekyll core team + OSS MIT
SolidStart The official full-stack meta-framework for SolidJS.
▲ rising▦▤
▦ Full-stack▤ Frontend
▲ rising moderate 2024

The official meta-framework for SolidJS, providing file-based routing, server functions, and a choice of rendering modes (SSR, SSG, CSR, streaming). Built on Vite and the Nitro server engine, it deploys to almost any host — serverless, edge, or Node.
3 use cases Full-stack Solid apps needing SSR plus server functions. Show all
  • Full-stack Solid apps needing SSR plus server functions.
  • Performance-sensitive apps wanting fine-grained reactivity end to end.
  • Deploying one codebase across Node, serverless, and edge targets.
4 features File-based routing built on the Solid Router. Show all
  • File-based routing built on the Solid Router.
  • Server functions (‘use server’) with isomorphic data fetching.
  • Selectable SSR / SSG / CSR / streaming render modes.
  • Vite + Nitro deploys to many hosts and the edge.

It is young — APIs stabilized only recently, the ecosystem of Solid-native libraries is far smaller than React’s, and some patterns (server functions, caching) are still settling, so expect more rough edges than mature meta-frameworks like Next.js.

 TypeScript SolidJS team MIT
Vite The default frontend build tool — instant dev, optimized builds.
★ standard🔧▤
🔧 Tooling▤ Frontend
★ standard gentle 2020

A frontend build tool that serves source over native ES modules in development — no bundling, so the dev server starts instantly and HMR stays fast as the app grows — and produces an optimized bundle for production (currently via Rollup, migrating to the Rust-based Rolldown). It’s framework-agnostic, with official plugins for React, Vue, Svelte, and more.
3 use cases Default build tool for new React, Vue, or Svelte projects. Show all
  • Default build tool for new React, Vue, or Svelte projects.
  • Fast local dev with instant startup and HMR.
  • Library builds via its library mode.
4 features No-bundle native-ESM dev server — instant startup. Show all
  • No-bundle native-ESM dev server — instant startup.
  • Fast HMR that stays flat as the app grows.
  • Rollup-based production builds (moving to Rolldown).
  • Rich plugin API, compatible with many Rollup plugins.

Dev runs on native ESM while production is bundled by Rollup, so the two pipelines can differ — a bug that only shows up in the production build usually traces to that gap or to a dependency that isn’t valid ESM. VoidZero, Vite’s maintainer, was acquired by Cloudflare in June 2026, but Vite stays MIT-licensed, open source, and vendor-neutral.

 TypeScript VoidZero (Cloudflare) + OSS community MIT
webpack The long-reigning bundler that powered the SPA era.
● mainstream🔧▤
🔧 Tooling▤ Frontend
● mainstream steep 2012

The bundler that defined frontend builds for a decade. Its loader and plugin model can transform virtually any asset, and code-splitting plus tree-shaking made large SPAs shippable. Still everywhere in established codebases, but new projects increasingly pick Vite for speed and simpler config.
3 use cases Maintaining and extending existing webpack codebases. Show all
  • Maintaining and extending existing webpack codebases.
  • Complex builds needing fine-grained loader/plugin control.
  • Apps with non-standard asset pipelines.
4 features Loader system transforms any asset type. Show all
  • Loader system transforms any asset type.
  • Code splitting and tree-shaking.
  • Huge plugin ecosystem built over a decade.
  • Module Federation for micro-frontends.

The config is famously sprawling — loaders, plugins, and resolve rules pile up, and builds get slow on large apps. It’s mature rather than cutting-edge; greenfield projects usually start with Vite instead unless they need a webpack-specific feature like Module Federation.

 JavaScript webpack team + OSS community MIT
esbuild An extremely fast bundler and minifier written in Go.
● mainstream🔧▤
🔧 Tooling▤ Frontend
● mainstream gentle 2020

A bundler, transpiler, and minifier written in Go that’s one to two orders of magnitude faster than JavaScript-based tools. It powers dependency pre-bundling inside Vite and many other toolchains, and works standalone for fast library or server builds.
3 use cases Blazing-fast transpilation and bundling in larger toolcha... Show all
  • Blazing-fast transpilation and bundling in larger toolchains.
  • Bundling Node.js / serverless backends and CLIs.
  • Library builds where build speed matters most.
4 features Go-based — 10–100× faster than JS bundlers. Show all
  • Go-based — 10–100× faster than JS bundlers.
  • Bundling, transpiling (TS/JSX), and minification in one tool.
  • Used under the hood by Vite and others.
  • Simple API and small, predictable output.

Speed comes from doing less — esbuild deliberately skips full type checking (it strips types, it doesn’t verify them) and has a smaller plugin ecosystem than Rollup or webpack. Run tsc --noEmit separately for type safety, and check plugin coverage before relying on it as your only bundler.

 Go Evan Wallace + OSS community MIT
Rollup The bundler of choice for JavaScript libraries.
★ standard🔧▤
🔧 Tooling▤ Frontend
★ standard moderate 2015

A bundler that pioneered ES module-based tree-shaking and produces clean, minimal output — which made it the default for publishing libraries. Vite uses Rollup for its production builds, so its plugin ecosystem reaches far beyond standalone use.
3 use cases Bundling JavaScript/TypeScript libraries for publishing. Show all
  • Bundling JavaScript/TypeScript libraries for publishing.
  • Producing clean ESM, CJS, and UMD outputs from one source.
  • The production-build engine inside Vite.
4 features Best-in-class tree-shaking and clean output. Show all
  • Best-in-class tree-shaking and clean output.
  • Multiple output formats (ESM, CJS, UMD) at once.
  • Mature, well-documented plugin API.
  • Powers Vite’s production bundling.

Rollup is tuned for libraries, not apps — it has no dev server, and app-style features (HMR, asset handling) come from Vite layered on top. It’s also JavaScript-based, so it’s slower than esbuild; the Rust-based Rolldown is being built as its faster successor.

 TypeScript Rollup team + OSS community MIT
Parcel The zero-config bundler that just works.
● mainstream🔧▤
🔧 Tooling▤ Frontend
● mainstream gentle 2017

A bundler built around zero configuration — point it at an HTML entry and it infers the rest, installing transforms as needed. It caches aggressively and uses Rust- and SWC-based internals for speed, making it a low-ceremony choice for small to medium projects.
3 use cases Quick prototypes and small apps with no config overhead. Show all
  • Quick prototypes and small apps with no config overhead.
  • Bundling static sites and multi-page apps from HTML entries.
  • Beginners who want a bundler that works without setup.
4 features Zero-config — infers transforms from the entry. Show all
  • Zero-config — infers transforms from the entry.
  • Aggressive multi-core caching for fast rebuilds.
  • Built-in dev server with HMR.
  • Rust/SWC-based internals for speed.

Zero-config is great until you need to customize — escaping the defaults is less documented than webpack’s or Vite’s explicit config. Its mindshare has also shrunk as Vite became the default low-config option, so community help is thinner.

 JavaScript Parcel team + OSS community MIT
Turbopack Vercel’s Rust-based successor to webpack.
▲ rising🔧▤
🔧 Tooling▤ Frontend
▲ rising gentle 2022

An incremental bundler written in Rust by Vercel, designed as webpack’s successor for large apps. It ships inside Next.js — powering its dev server and, increasingly, production builds — with function-level incremental computation so only what changed is recomputed.
3 use cases Fast dev and builds inside Next.js. Show all
  • Fast dev and builds inside Next.js.
  • Large React apps where webpack build times hurt.
  • Teams on the Vercel/Next.js stack adopting the default tooling.
4 features Rust-based with function-level incremental computation. Show all
  • Rust-based with function-level incremental computation.
  • Powers the Next.js dev server and builds.
  • Fast HMR that scales to large apps.
  • Designed as a drop-in webpack replacement in Next.js.

Turbopack is tightly coupled to Next.js — it isn’t a general-purpose, standalone bundler you drop into any project the way Vite is. It’s also newer than its rivals, so feature parity with webpack loaders and the surrounding ecosystem is still filling in.

 Rust Vercel MIT
SWC A Rust-based platform for fast JS/TS transpilation.
● mainstream🔧
🔧 Tooling
● mainstream moderate 2019

The “Speedy Web Compiler” — a Rust-based platform that transpiles and minifies JavaScript and TypeScript far faster than Babel. Next.js uses it to replace Babel and Terser, and many test runners and bundlers plug it in for fast TS/JSX compilation.
3 use cases Drop-in faster replacement for Babel in build pipelines. Show all
  • Drop-in faster replacement for Babel in build pipelines.
  • Fast TypeScript/JSX transforms inside Next.js and test runners.
  • Custom transforms via SWC plugins (Wasm).
4 features Rust-based — far faster than Babel. Show all
  • Rust-based — far faster than Babel.
  • Transpiles TS/JSX and minifies JS.
  • Powers Next.js’s compilation and minification.
  • Wasm plugin system for custom transforms.

Like esbuild, SWC transpiles without full type checking — types are stripped, not verified — so keep tsc in your pipeline. Its plugin ecosystem is smaller than Babel’s, and authoring SWC (Wasm) plugins is far more involved than a Babel plugin.

 Rust SWC project + OSS community Apache-2.0
Babel The JavaScript compiler that brought modern syntax everywhere.
● mainstream🔧
🔧 Tooling
● mainstream moderate 2014

The classic JavaScript transpiler — it lets you write modern JS (and JSX, TypeScript) and compiles it down to syntax older browsers understand. Its preset and plugin system shaped a generation of build tooling; newer projects often swap it for SWC or esbuild on speed, but it remains ubiquitous for its plugin ecosystem.
3 use cases Transpiling modern JS/JSX/TS for broad browser support. Show all
  • Transpiling modern JS/JSX/TS for broad browser support.
  • Custom AST transforms via Babel plugins.
  • Maintaining toolchains and codebases built around Babel.
4 features Presets (@babel/preset-env, -react, -typescript). Show all
  • Presets (@babel/preset-env, -react, -typescript).
  • Vast plugin ecosystem for syntax and AST transforms.
  • Targets specific browsers via browserslist.
  • The reference implementation for new JS proposals.

Babel is JavaScript-based and slow on large codebases — the main reason SWC and esbuild displaced it for raw transpilation. It still wins on plugin breadth, so the common pattern is fast tools for builds and Babel only where a specific plugin is required.

 JavaScript Babel team + OSS community MIT
Rolldown Rust-based, Rollup-compatible bundler — Vite’s future engine.
▲ rising🔧▤
🔧 Tooling▤ Frontend
▲ rising gentle 2024

A bundler written in Rust that aims to be a drop-in, Rollup-compatible replacement at a fraction of the build time. It’s being adopted as Vite’s production bundler (shipped as “rolldown-vite”), unifying the dev and build paths and replacing the current esbuild + Rollup split.
3 use cases Faster production builds inside Vite (rolldown-vite). Show all
  • Faster production builds inside Vite (rolldown-vite).
  • Dropping into Rollup-based pipelines for a speed boost.
  • Bundling large apps and libraries where build time matters.
4 features Rust-based — far faster than Rollup. Show all
  • Rust-based — far faster than Rollup.
  • Rollup-compatible API and plugin interface.
  • Becoming Vite’s production bundler (rolldown-vite).
  • Built by the VoidZero team alongside Vite and Oxc.

It’s still maturing — Rollup compatibility is high but not perfect, so exotic plugins or edge-case config may not port cleanly yet. Maintained by VoidZero (acquired by Cloudflare in June 2026) and MIT-licensed, it stays open source and vendor-neutral alongside Vite.

 Rust VoidZero (Cloudflare) + OSS community MIT
Rspack A Rust-based, webpack-compatible bundler.
▲ rising🔧
🔧 Tooling
▲ rising moderate 2023

A high-performance bundler written in Rust by ByteDance that is deliberately API- and config-compatible with webpack. It aims to be a near drop-in replacement — keep most of your webpack.config.js and loaders/plugins, but get builds that are often five to ten times faster.
3 use cases Speeding up large existing webpack projects with minimal ... Show all
  • Speeding up large existing webpack projects with minimal config changes.
  • Monorepos where webpack build times have become a bottleneck.
  • Apps relying on the webpack loader/plugin ecosystem but wanting Rust speed.
4 features Webpack-compatible config, loaders, and plugin API. Show all
  • Webpack-compatible config, loaders, and plugin API.
  • Rust-powered parallel builds — much faster than webpack.
  • Built-in SWC transforms and Lightning CSS.
  • Powers the Rsbuild and Rsdoctor higher-level toolchain.

“Webpack-compatible” is high but not total — plugins that reach into webpack internals or rely on undocumented hooks may not work, so verify your critical loaders and plugins before migrating a production build.

 Rust ByteDance + OSS MIT
tsup Zero-config TypeScript library bundling, powered by esbuild.
● mainstream🔧
🔧 Tooling
● mainstream gentle 2020

A zero-config bundler built on esbuild and designed specifically for shipping TypeScript libraries. Point it at an entry file and it emits both ESM and CJS output plus .d.ts type declarations, handling the dual-package boilerplate for you.
3 use cases Publishing npm packages with both ESM and CJS builds. Show all
  • Publishing npm packages with both ESM and CJS builds.
  • Generating bundled .d.ts type declarations for a library.
  • Small TS tools and CLIs that want fast, config-free builds.
4 features Dual ESM + CJS output from a single command. Show all
  • Dual ESM + CJS output from a single command.
  • Bundled .d.ts type declaration generation.
  • esbuild-powered — extremely fast builds.
  • Code splitting, tree-shaking, and watch mode.

Because it leans on esbuild, its .d.ts generation uses a separate pass that can struggle with very complex type setups or some tsconfig options, and esbuild does no type-checking — run tsc --noEmit separately in CI to actually catch type errors.

 TypeScript egoist + OSS MIT
Tailwind CSS Utility-first CSS you compose in your markup.
★ standard◈▤
◈ Styling▤ Frontend
★ standard moderate 2017

A utility-first framework where you style by composing tiny classes (flex, pt-4, text-center) directly in markup instead of writing bespoke CSS files. The compiler scans your templates and emits only the utilities you actually use, keeping the shipped stylesheet small. v4 rewrote the engine in Rust (“Oxide”) with tree-shaking-style JIT generation and a CSS-first config (@theme) that drops the old tailwind.config.js for most projects.
3 use cases Rapidly styling component-based UIs without context-switc... Show all
  • Rapidly styling component-based UIs without context-switching to CSS files.
  • Design systems where spacing, color, and type scales are enforced by tokens.
  • Teams that want consistent, low-specificity CSS with tiny production bundles.
4 features Utility classes mapped to a configurable design-token scale. Show all
  • Utility classes mapped to a configurable design-token scale.
  • v4 Rust engine (‘Oxide’) with Lightning CSS built in — no PostCSS setup needed.
  • CSS-first config via the @theme directive (no JS config file required).
  • JIT compilation emits only the classes your templates reference.

Markup gets verbose — long class strings are the trade for never writing CSS, so lean on component extraction or @apply sparingly. v4’s CSS-first config and Rust engine are a real migration from v3’s tailwind.config.js; older tutorials and plugins may not match.

 Rust / TypeScript Tailwind Labs MIT
Sass The veteran CSS preprocessor — variables, nesting, mixins.
● mainstream◈
◈ Styling
● mainstream gentle 2006

The original CSS preprocessor. You write .scss (or indented .sass) with variables, nesting, mixins, functions, and partials, and Sass compiles it down to plain CSS. The modern reference implementation is Dart Sass. Native CSS custom properties and nesting now cover some of what Sass pioneered, but its modules, loops, and mixins still go beyond the platform.
3 use cases Large hand-written stylesheets that benefit from partials... Show all
  • Large hand-written stylesheets that benefit from partials and mixins.
  • Design systems built on Sass maps, functions, and loops.
  • Legacy and CMS-themed projects where Sass is already the standard.
4 features Variables, nesting, mixins, and functions for DRY stylesh... Show all
  • Variables, nesting, mixins, and functions for DRY stylesheets.
  • @use / @forward module system replacing the old global @import.
  • Partials and loops to generate repetitive CSS programmatically.
  • Dart Sass is the canonical, actively maintained compiler.

Native CSS caught up — nesting and custom properties are now built into browsers, so reach for Sass for its programmatic features (loops, maps, mixins), not just nesting. The legacy @import is deprecated; use @use/@forward, and the old JS-based LibSass is dead — use Dart Sass.

 Dart Sass core team + OSS community MIT
PostCSS Transform CSS with JavaScript plugins.
★ standard◈🔧
◈ Styling🔧 Tooling
★ standard moderate 2013

A tool that parses CSS into an abstract syntax tree and lets JavaScript plugins transform it — Autoprefixer adds vendor prefixes, postcss-preset-env polyfills future syntax, others minify or lint. PostCSS does almost nothing on its own; it’s the plugin pipeline that build tools and frameworks (including older Tailwind) run CSS through.
3 use cases Auto-adding vendor prefixes via Autoprefixer in a build p... Show all
  • Auto-adding vendor prefixes via Autoprefixer in a build pipeline.
  • Polyfilling modern CSS syntax for older browsers.
  • Powering a framework’s CSS transform step (e.g. Tailwind v3).
4 features Plugin architecture — compose transforms over a CSS AST. Show all
  • Plugin architecture — compose transforms over a CSS AST.
  • Autoprefixer and postcss-preset-env are the canonical plugins.
  • Integrates into Vite, webpack, and most bundlers out of the box.
  • Each plugin is small and single-purpose, Unix-style.

It’s infrastructure, not a feature — PostCSS alone changes nothing, so its value lives entirely in the plugins you enable. Don’t confuse it with a preprocessor like Sass: it transforms CSS rather than giving you a richer authoring language (though plugins can emulate parts of that).

 JavaScript Andrey Sitnik + OSS community MIT
CSS Modules Locally-scoped CSS class names, by default.
● mainstream◈▤
◈ Styling▤ Frontend
● mainstream gentle 2015

A bundler convention, not a library: you write plain CSS in a *.module.css file, import it into a component, and the build renames each class to a unique, locally-scoped identifier. This kills the global namespace collisions that plague large CSS codebases while keeping you in ordinary CSS. Supported natively by Vite, webpack, and Next.js.
3 use cases Component-scoped styles in React/Vue without a CSS-in-JS ... Show all
  • Component-scoped styles in React/Vue without a CSS-in-JS runtime.
  • Avoiding global class-name collisions in large codebases.
  • Teams that prefer real CSS files over utility classes or template literals.
4 features Class names auto-hashed to be locally scoped per file. Show all
  • Class names auto-hashed to be locally scoped per file.
  • Plain CSS authoring — no new syntax to learn.
  • Built into Vite, webpack, Parcel, and Next.js.
  • composes keyword to share rules between local classes.

Dynamic, prop-driven styling is awkward — you compose static classes rather than interpolate values, so runtime-themed styles need CSS variables or a different tool. Class names are strings on the imported object, so typos fail silently unless you add TypeScript typing.

 CSS OSS community (bundler-implemented) MIT
styled-components CSS-in-JS — styled React components via tagged templates.
▼ legacy◈▤
◈ Styling▤ Frontend
▼ legacy moderate 2016

The library that popularized CSS-in-JS for React: you write real CSS inside tagged template literals to produce styled components, with props driving dynamic styles and automatic scoping. It’s runtime-based — styles are generated as the app renders — which is now seen as a cost versus zero-runtime alternatives. Active development has slowed and the maintainers have flagged it as in maintenance mode.
3 use cases Existing React codebases already built on styled-components. Show all
  • Existing React codebases already built on styled-components.
  • Highly dynamic, prop-driven component styling.
  • Co-locating styles with components in a single file.
4 features Tagged-template CSS that produces scoped styled components. Show all
  • Tagged-template CSS that produces scoped styled components.
  • Props and theme context drive dynamic styles at runtime.
  • Automatic critical-CSS extraction during SSR.
  • ThemeProvider for app-wide design tokens.

The runtime cost is the headline knock — generating styles during render hurts performance and clashes with React Server Components, which is why the ecosystem is drifting to zero-runtime options. The project is now in maintenance mode, so prefer Emotion or a zero-runtime tool for greenfield apps.

 JavaScript Max Stoiber + OSS (maintenance mode) MIT
Emotion Performant, framework-flexible CSS-in-JS.
● mainstream◈▤
◈ Styling▤ Frontend
● mainstream moderate 2017

A CSS-in-JS library offering both a styled-components-style API and a css prop for inline styles. It’s known for being faster and lighter than its predecessors and is framework-flexible — widely used standalone and as the styling engine under component libraries like MUI. Like all runtime CSS-in-JS, it carries a render-time cost that newer zero-runtime tools avoid.
3 use cases React apps wanting CSS-in-JS with strong performance. Show all
  • React apps wanting CSS-in-JS with strong performance.
  • Component libraries needing a flexible styling primitive (e.g. MUI).
  • Dynamic, theme-driven styles co-located with components.
4 features Two APIs — the css prop and a styled() factory. Show all
  • Two APIs — the css prop and a styled() factory.
  • Source maps and labels for debuggable generated classes.
  • Powers popular component libraries such as MUI.
  • Smaller, faster runtime than older CSS-in-JS libraries.

It’s still runtime CSS-in-JS — styles are computed during render, which adds overhead and complicates React Server Components, so SSR streaming needs care. For new apps prioritizing performance, a zero-runtime option like vanilla-extract or utility CSS may be a better fit.

 TypeScript Emotion team + OSS community MIT
UnoCSS The instant, on-demand atomic CSS engine.
▲ rising◈▤
◈ Styling▤ Frontend
▲ rising moderate 2021

An atomic-CSS engine by Anthony Fu that generates utility classes on demand from your source, with no fixed set of rules — everything is defined through presets you compose, including a Tailwind/Windi-compatible preset. It’s built for speed (no parsing of a huge CSS file) and is highly extensible via custom rules, shortcuts, and variants.
3 use cases Utility-first styling with faster builds and full customi... Show all
  • Utility-first styling with faster builds and full customization.
  • Projects wanting Tailwind-like utilities but a pluggable engine.
  • Defining bespoke design-system utilities via presets and rules.
4 features On-demand generation — only classes you use are produced. Show all
  • On-demand generation — only classes you use are produced.
  • Preset-driven; Tailwind-compatible preset included.
  • Custom rules, shortcuts, and variants for bespoke utilities.
  • First-class Vite integration and a fast core engine.

The flexibility is also the cost — without a chosen preset you get no utilities at all, and config differs enough from Tailwind that copy-pasted Tailwind snippets may need preset tweaks. A smaller ecosystem and documentation surface than Tailwind means more self-service.

 TypeScript Anthony Fu + OSS community MIT
vanilla-extract Zero-runtime, type-safe CSS-in-TypeScript.
▲ rising◈▤
◈ Styling▤ Frontend
▲ rising moderate 2021

A CSS-in-TS library where you author styles in .css.ts files using TypeScript, and the build compiles them to static CSS at build time — so there’s zero styling runtime in the browser. You get type-checked class names, theme contracts, and variables with the safety of TypeScript and none of the render-time cost of styled-components/Emotion.
3 use cases Type-safe styling with no client-side CSS-in-JS runtime. Show all
  • Type-safe styling with no client-side CSS-in-JS runtime.
  • Design systems wanting compile-time-checked theme contracts.
  • Performance-sensitive React/SSR apps avoiding runtime style generation.
4 features Styles compiled to static CSS — zero runtime cost. Show all
  • Styles compiled to static CSS — zero runtime cost.
  • Type-safe class names, themes, and variables.
  • createTheme / theme contracts for design tokens.
  • Build-plugin integrations for Vite, webpack, and esbuild.

Styles are static by design — there’s no per-render dynamic interpolation like runtime CSS-in-JS, so prop-driven variation uses recipes, variants, or CSS variables instead. It needs a build-tool plugin and a TypeScript setup, so it isn’t a drop-in for plain-JS or no-build projects.

 TypeScript Seek (vanilla-extract team) + OSS MIT
Less The other classic CSS preprocessor — variables and mixins in JS.
▼ legacy◈
◈ Styling
▼ legacy gentle 2009

A CSS preprocessor in the same family as Sass, adding variables, mixins, nesting, and functions to stylesheets. It once powered Bootstrap 3 and was ubiquitous, but the ecosystem has largely consolidated on Sass and, more recently, on native CSS custom properties and nesting.
3 use cases Maintaining older codebases (Bootstrap 3, legacy Ant Desi... Show all
  • Maintaining older codebases (Bootstrap 3, legacy Ant Design themes).
  • Theming via runtime variable overrides in the browser build.
  • Teams already invested in .less files who don’t want to migrate.
3 features Variables, mixins, nesting, and operations over CSS. Show all
  • Variables, mixins, nesting, and operations over CSS.
  • JavaScript implementation that can compile in the browser at runtime.
  • Function library plus the ability to call JS for custom logic.

The ecosystem has moved on — most tooling, tutorials, and component libraries now assume Sass or native CSS, so Less is effectively maintenance-mode. Browser-side runtime compilation is convenient but slow and should never ship to production.

 JavaScript Less.js team + OSS Apache-2.0
Open Props Supercharged CSS variables — design tokens with no build step.
▲ rising◈
◈ Styling
▲ rising gentle 2021

A library of ready-made CSS custom properties — colors, sizes, fonts, easings, shadows, gradients, and animations — that you consume as plain var(--…) tokens. It’s just CSS variables, so it works with any framework or none and needs no runtime or build step beyond optionally tree-shaking unused props with PostCSS.
3 use cases Adding a consistent design-token system to a vanilla-CSS ... Show all
  • Adding a consistent design-token system to a vanilla-CSS project.
  • Prototyping with sensible defaults for spacing, color, and motion.
  • Pairing tokens with any framework without committing to a CSS engine.
3 features Hundreds of design tokens exposed as standard CSS custom ... Show all
  • Hundreds of design tokens exposed as standard CSS custom properties.
  • Framework-agnostic — consumed via plain var(), no runtime.
  • Optional PostCSS plugin tree-shakes to only the props you use.

It’s a token set, not a methodology — Open Props gives you values but no utility classes, components, or opinions on how to structure CSS, so you still bring your own architecture. Importing the full set without the tree-shaking PostCSS plugin ships a lot of unused custom properties.

 CSS Adam Argyle + OSS MIT
Panda CSS Zero-runtime CSS-in-JS with type-safe styles and design tokens.
▲ rising◈🔧
◈ Styling🔧 Tooling
▲ rising moderate 2023

A build-time styling engine from the Chakra team that gives you the authoring ergonomics of CSS-in-JS — css() calls, style props, and recipes — but extracts everything to static CSS at build with zero runtime. It generates fully typed APIs from your design tokens, so styles are autocompleted and type-checked.
3 use cases React/Solid/Vue apps wanting type-safe styles without run... Show all
  • React/Solid/Vue apps wanting type-safe styles without runtime cost.
  • Design systems built on tokens, recipes, and variants.
  • Teams replacing runtime CSS-in-JS (Emotion, styled-components) for speed.
3 features Zero-runtime — styles extracted to static CSS at build time. Show all
  • Zero-runtime — styles extracted to static CSS at build time.
  • Fully typed css(), style props, and cva-style recipes from tokens.
  • Framework-agnostic with first-class React, Solid, and Vue support.

The codegen step is load-bearing — Panda generates a styled-system directory you import from, so a stale or missing codegen run breaks autocomplete and types. Like other static extractors, truly dynamic runtime values must go through CSS variables rather than computed style objects.

 TypeScript Chakra team MIT
Redux Toolkit The official, opinionated, batteries-included Redux.
★ standard▤
▤ Frontend
★ standard moderate 2019

The modern, recommended way to write Redux. Plain Redux (2015) demanded heavy boilerplate; Redux Toolkit (“RTK”) wraps it with createSlice, Immer-powered “mutating” reducers, the Thunk middleware, and configured stores — cutting the ceremony dramatically. RTK Query adds a built-in data-fetching/caching layer for talking to an API.
3 use cases Large apps wanting a single predictable, debuggable globa... Show all
  • Large apps wanting a single predictable, debuggable global store.
  • Teams that value Redux DevTools time-travel and strict conventions.
  • Codebases standardizing on RTK Query for server-state caching.
4 features createSlice generates actions + reducers with Immer's mut... Show all
  • createSlice generates actions + reducers with Immer’s mutating syntax.
  • configureStore wires DevTools and sensible middleware by default.
  • RTK Query for data fetching, caching, and invalidation.
  • Strong TypeScript inference throughout.

It’s still Redux underneath — actions, reducers, selectors, and a single store are more architecture than small apps need. The “mutating” reducer syntax only works because Immer is inside createSlice; mutating state anywhere else still breaks things.

 TypeScript Redux team + OSS community MIT
Zustand A tiny, hooks-based store with almost no boilerplate.
● mainstream▤
▤ Frontend
● mainstream gentle 2019

A minimal state-management library from the Poimandres collective. You create a store with a single hook and read or update state from any component — no providers, reducers, or action types required. It’s tiny, unopinionated, works outside React, and has become the go-to lightweight alternative to Redux.
3 use cases Apps wanting global state without Redux's ceremony. Show all
  • Apps wanting global state without Redux’s ceremony.
  • Sharing state across components with a single hook.
  • Lightweight stores in libraries or non-React contexts.
4 features Single create() hook — no context provider needed. Show all
  • Single create() hook — no context provider needed.
  • Selector subscriptions to minimize re-renders.
  • Middleware for persistence, Immer, and Redux DevTools.
  • Tiny bundle; usable outside React.

The freedom is a double edge — no enforced structure means large apps can drift into ad-hoc stores and tangled updates. Naive selectors that return new objects can over-render, so reach for useShallow or fine-grained selectors as the store grows.

 TypeScript Poimandres (pmndrs) + OSS MIT
Jotai Bottom-up atomic state for React.
● mainstream▤
▤ Frontend
● mainstream gentle 2020

An atomic state-management library from Daishi Kato (Poimandres). State is built from small, composable atoms that you read and write with a useAtom hook, and derived atoms recompute automatically when their dependencies change. The bottom-up, primitive-first model avoids a single monolithic store and the re-render pitfalls of context.
3 use cases Fine-grained shared state without a single global store. Show all
  • Fine-grained shared state without a single global store.
  • Derived/computed state that recomputes from dependencies.
  • React apps wanting Recoil-style atoms with a smaller footprint.
4 features Composable atoms as the unit of state. Show all
  • Composable atoms as the unit of state.
  • Derived atoms recompute from their dependencies.
  • No provider required for the default store.
  • Integrations for persistence, Query, and async atoms.

Atomic thinking is a different mental model — many tiny atoms can sprawl, and tracking which derived atom depends on what gets harder at scale. Async atoms integrate with Suspense, which is powerful but adds its own learning curve.

 TypeScript Daishi Kato / Poimandres + OSS MIT
MobX Transparent reactive state via observables.
● mainstream▤
▤ Frontend
● mainstream moderate 2015

A state library built on transparent functional-reactive programming: you mark state as observable, derive values with computed, and components wrapped in observer re-render automatically when the data they read changes. You mutate state directly — MobX tracks the dependency graph and updates only what’s affected, an OOP-friendly contrast to Redux’s immutable flow.
3 use cases Apps preferring mutable, object-oriented state over reduc... Show all
  • Apps preferring mutable, object-oriented state over reducers.
  • Complex derived/computed values that must stay in sync.
  • Teams wanting automatic, fine-grained re-render tracking.
4 features Observable state with automatic dependency tracking. Show all
  • Observable state with automatic dependency tracking.
  • Computed values cached and recomputed only when needed.
  • observer components re-render on exactly the reads that change.
  • Direct mutation — no immutable-update boilerplate.

The “magic” reactivity can surprise you — forget the observer wrapper and a component silently won’t update, and reading observables outside a tracked context misses changes. The mutable, decorator-heavy style is a sharp philosophical break from the immutable Redux ecosystem.

 TypeScript Michel Weststrate + OSS community MIT
TanStack Query Async server-state — fetching, caching, revalidation done right.
★ standard▤
▤ Frontend
★ standard moderate 2019

The de-facto standard for managing server state in the browser (formerly React Query). It handles fetching, caching, background revalidation, deduping, pagination, and mutations behind a useQuery/useMutation hook — so you stop hand-rolling loading flags and stale-data bugs around your API calls. It’s transport- agnostic (works with REST, GraphQL, or anything that returns a promise) and ships adapters for React, Vue, Svelte, and Solid.
3 use cases Caching and revalidating REST/GraphQL data without a glob... Show all
  • Caching and revalidating REST/GraphQL data without a global store.
  • Pagination, infinite scroll, and optimistic mutations.
  • Eliminating manual loading/error/stale state boilerplate.
4 features useQuery / useMutation hooks with smart caching by key. Show all
  • useQuery / useMutation hooks with smart caching by key.
  • Background refetching, deduping, and stale-while-revalidate.
  • Infinite queries, pagination, and optimistic updates.
  • Framework adapters for React, Vue, Svelte, and Solid.

It manages server state, not client state — don’t reach for it to hold UI state like modal toggles (use a store for that). Cache keys and staleTime/gcTime tuning matter: a wrong key shares or splits caches in surprising ways, and defaults that feel “too eager” to refetch trip people up.

 TypeScript Tanner Linsley / TanStack + OSS MIT
SWR Lightweight data fetching with stale-while-revalidate.
● mainstream▤
▤ Frontend
● mainstream gentle 2019

A small React data-fetching library from Vercel, named after the HTTP stale-while-revalidate strategy: return cached data first, then refetch in the background and update. A single useSWR(key, fetcher) hook gives you caching, revalidation on focus/reconnect, and deduping with minimal setup — a lighter-touch alternative to TanStack Query.
3 use cases Simple, fast data fetching in React (especially Next.js) ... Show all
  • Simple, fast data fetching in React (especially Next.js) apps.
  • Auto-revalidating reads on window focus and network reconnect.
  • Lightweight caching without configuring a full query client.
4 features useSWR hook: cache-first, revalidate-in-background. Show all
  • useSWR hook: cache-first, revalidate-in-background.
  • Revalidation on focus, reconnect, and interval.
  • Request deduping and optimistic mutate().
  • Tiny footprint; first-class Next.js integration.

It’s intentionally lean — for heavy needs like infinite pagination, complex mutations, or fine-grained cache control, TanStack Query offers more out of the box. Aggressive default revalidation (refetch on focus) can surprise you; disable it per-call when it isn’t wanted.

 TypeScript Vercel + OSS community MIT
Apollo Client The full-featured GraphQL client with a normalized cache.
● mainstream▤
▤ Frontend
● mainstream steep 2016

A comprehensive client for talking to a GraphQL API. Its headline feature is a normalized in-memory cache that stores entities by ID and keeps queries across the app consistent, plus useQuery/useMutation hooks, optimistic UI, subscriptions, and local-state management. Powerful, but heavier than transport-agnostic fetch libraries.
3 use cases Apps with a substantial GraphQL API needing entity-level ... Show all
  • Apps with a substantial GraphQL API needing entity-level caching.
  • Consistent shared data across many components via a normalized cache.
  • GraphQL subscriptions, optimistic UI, and pagination.
4 features Normalized cache keyed by entity ID for cross-query consi... Show all
  • Normalized cache keyed by entity ID for cross-query consistency.
  • useQuery / useMutation hooks plus subscriptions.
  • Optimistic responses and cache updates.
  • Local state can live alongside server data in the cache.

The normalized cache is the power and the complexity — cache normalization, type policies, and manual cache updates after mutations are a real learning curve. It’s GraphQL-only and comparatively heavy; for REST or simple needs a fetch-based library is lighter. urql is a leaner GraphQL alternative.

 TypeScript Apollo (apollographql) + OSS MIT
XState State machines and statecharts for predictable logic.
● mainstream▤
▤ Frontend
● mainstream steep 2017

A library for modeling application logic as finite state machines and statecharts. Instead of scattered booleans, you declare explicit states and the transitions between them, so impossible states become unrepresentable. It’s framework-agnostic — usable in React, Vue, Node, or vanilla JS — and pairs with visual tooling from Stately to design and inspect machines.
3 use cases Complex multi-step flows (wizards, checkout, auth) with c... Show all
  • Complex multi-step flows (wizards, checkout, auth) with clear states.
  • Eliminating impossible/invalid UI states via explicit transitions.
  • Logic you want to visualize, document, and test as a diagram.
4 features Finite state machines and hierarchical/parallel statecharts. Show all
  • Finite state machines and hierarchical/parallel statecharts.
  • Guards, actions, and invoked actors/services.
  • Framework-agnostic core with React/Vue/Svelte bindings.
  • Visual editor and inspector from Stately.

Statecharts are a paradigm shift — the upfront modeling and dense API (actors, guards, context, services) are overkill for simple state and have a steep curve. Reach for it when flows are genuinely complex; a boolean or a small store is fine for the rest.

 TypeScript Stately (David Khourshid) + OSS MIT
Pinia The official Vue store — intuitive, typed, and devtools-friendly.
★ standard▤
▤ Frontend
★ standard gentle 2019

The official state-management library for Vue, succeeding Vuex. Stores are defined with a simple function or options object, are fully typed in TypeScript without extra ceremony, and integrate with Vue’s reactivity and devtools (including time-travel) out of the box.
3 use cases Shared global state across components in a Vue or Nuxt app. Show all
  • Shared global state across components in a Vue or Nuxt app.
  • Replacing Vuex in modern Vue 3 projects.
  • Typed stores with SSR support under Nuxt.
4 features Tiny API — define stores with state, getters, and actions. Show all
  • Tiny API — define stores with state, getters, and actions.
  • Full TypeScript inference with no manual typing boilerplate.
  • Vue Devtools integration with time-travel and hot module replacement.
  • First-class SSR support in Nuxt.

Pinia is Vue-specific — it leans on Vue’s reactivity, so it isn’t a portable store you can reuse in React or vanilla apps. Destructuring a store breaks reactivity; use storeToRefs() to pull out reactive references.

 TypeScript Vue core team MIT
Valtio Proxy-based state — mutate a plain object, components react.
● mainstream▤
▤ Frontend
● mainstream gentle 2020

A small proxy-based state library from Poimandres. You create a mutable proxy object and change it imperatively; components read a reactive snapshot with useSnapshot() and re-render only when the parts they touched change. It feels like MobX’s mutability with a far smaller surface.
3 use cases Apps that prefer mutable, imperative state updates over r... Show all
  • Apps that prefer mutable, imperative state updates over reducers.
  • Sharing state outside React (the proxy works anywhere).
  • Fine-grained re-renders without manual selectors.
3 features Mutate a plain proxy object — no actions or reducers requ... Show all
  • Mutate a plain proxy object — no actions or reducers required.
  • useSnapshot() tracks reads for automatic fine-grained re-renders.
  • Works outside React; derive, subscribe, and proxy nested state.

The mutable-proxy model is convenient but leaky — mutate the proxy to write, but always render from the useSnapshot() result, never the proxy itself, or you lose reactivity. Snapshots are frozen, so accidentally mutating one throws in strict mode.

 TypeScript Poimandres MIT
Zod TypeScript-first schema validation with static type inference.
★ standard🔧▦
🔧 Tooling▦ Full-stack
★ standard gentle 2020

A schema declaration and validation library where the schema is the single source of truth — you write a Zod schema once and infer the static TypeScript type from it, so runtime validation and compile-time types never drift. It’s the de-facto validator for forms, API boundaries, and env parsing across the TS ecosystem.
3 use cases Validating and parsing untrusted input at API and form bo... Show all
  • Validating and parsing untrusted input at API and form boundaries.
  • Deriving TypeScript types from a runtime schema (single source of truth).
  • Parsing and validating environment variables at startup.
4 features Infer static TS types directly from a schema with z.infer. Show all
  • Infer static TS types directly from a schema with z.infer.
  • Composable schemas — objects, unions, refinements, transforms.
  • Rich, structured error objects suited to form feedback.
  • Huge ecosystem integration (tRPC, React Hook Form, OpenAPI tools).

Validation runs at runtime, so large schemas on hot paths cost CPU — and .parse() throws while .safeParse() returns a result, so mixing them up means unhandled exceptions. The v4 rewrite changed several APIs, so older tutorials may not match current syntax.

 TypeScript Colin McDonnell + OSS MIT
Nano Stores Tiny (<1 KB) framework-agnostic atomic state stores.
▲ rising▤
▤ Frontend
▲ rising gentle 2021

A minimalist state manager (often under 1 KB) built around atoms and computed values, with adapters for React, Vue, Svelte, Solid, and vanilla JS. Its tree-shakable, framework-agnostic design makes it a favorite for sharing state across islands in Astro and other multi-framework setups.
3 use cases Sharing state between framework islands in Astro. Show all
  • Sharing state between framework islands in Astro.
  • Bundle-size-critical apps and embeddable widgets.
  • Reusing one store across React, Vue, and Svelte components.
3 features Atoms and computed (derived) stores with a tiny footprint. Show all
  • Atoms and computed (derived) stores with a tiny footprint.
  • Framework adapters for React, Vue, Svelte, Solid, and vanilla JS.
  • Tree-shakable — you ship only the helpers you import.

The minimalism is the trade-off — there’s no devtools time-travel, no built-in middleware, and patterns for complex nested state are largely DIY. It shines for cross-island and shared state, less so as the single store of a large SPA.

 TypeScript Andrey Sitnik + OSS MIT
Express The minimal, ubiquitous Node web framework.
★ standard⚙
⚙ Backend
★ standard gentle 2010

The de-facto standard web API framework for Node.js — a thin, unopinionated layer over the HTTP server giving you routing and a middleware pipeline, and almost nothing else. You assemble validation, auth, and an ORM yourself. Express 5 finally shipped after years on 4.x, modernizing async error handling.
3 use cases Lightweight REST APIs and microservices in Node. Show all
  • Lightweight REST APIs and microservices in Node.
  • Prototypes and glue services where you want minimal ceremony.
  • Teaching the fundamentals of HTTP routing and middleware.
4 features Minimal core: routing plus a middleware chain. Show all
  • Minimal core: routing plus a middleware chain.
  • Enormous ecosystem of compatible middleware packages.
  • Express 5 awaits rejected promises in route handlers.
  • Runs almost anywhere Node does.

Unopinionated means you own every decision — validation, structure, and error handling are bolt-ons, so large Express codebases drift in style. Most middleware is community-maintained and varies in quality; vet what you depend on.

 JavaScript OpenJS Foundation + OSS community MIT
Fastify Fast, low-overhead Node framework built around JSON schemas.
● mainstream⚙
⚙ Backend
● mainstream moderate 2016

A Node.js web framework focused on throughput and developer experience. Its headline feature is schema-based validation and serialization — you declare a JSON Schema per route and Fastify validates input and compiles a fast serializer for the response, which also feeds automatic OpenAPI docs.
3 use cases High-throughput REST APIs where Express overhead matters. Show all
  • High-throughput REST APIs where Express overhead matters.
  • Services that benefit from schema validation and typed routes.
  • Plugin-structured apps using Fastify’s encapsulation model.
4 features JSON Schema validation and compiled fast serialization. Show all
  • JSON Schema validation and compiled fast serialization.
  • Encapsulated plugin architecture for modular apps.
  • Strong TypeScript support and route type inference.
  • Lifecycle hooks and built-in structured logging (Pino).

The schema-first model is the win and the friction — skipping schemas throws away most of Fastify’s speed and type safety. Its plugin encapsulation (decorators, register scope) is powerful but trips up newcomers expecting Express-style global middleware.

 JavaScript Fastify team (OpenJS Foundation) + OSS MIT
NestJS Opinionated, Angular-inspired TypeScript backend framework.
● mainstream⚙
⚙ Backend
● mainstream steep 2017

A structured, opinionated Node.js framework written in TypeScript whose architecture borrows heavily from Angular — modules, providers, and dependency injection. It runs on top of Express or Fastify and adds a consistent project structure plus first-class support for REST, GraphQL, WebSockets, and microservices.
3 use cases Large, long-lived backends where structure and convention... Show all
  • Large, long-lived backends where structure and conventions matter.
  • Enterprise teams wanting DI, modules, and testability out of the box.
  • APIs spanning REST, GraphQL, and microservice transports.
4 features Dependency injection and modular architecture (Angular-st... Show all
  • Dependency injection and modular architecture (Angular-style).
  • Decorators for controllers, routes, guards, and pipes.
  • Runs on Express or Fastify adapters interchangeably.
  • First-class REST, GraphQL, WebSocket, and microservice support.

The heaviest learning curve of the Node frameworks — DI, modules, providers, decorators, and metadata reflection are a lot before you write real logic. Overkill for a small service, and the abstraction layers can obscure what plain Express would make obvious.

 TypeScript Kamil Myśliwiec + OSS community MIT
Hono Ultrafast web framework that runs on any JS runtime.
▲ rising⚙
⚙ Backend
▲ rising gentle 2021

A tiny, ultrafast web framework with an Express-like API that runs on virtually any JavaScript runtime — Cloudflare Workers, Deno, Bun, Node, and other edge platforms — from a single codebase. It leans on Web Standard Request/Response objects, which is what makes it portable to edge runtimes that lack Node APIs.
3 use cases Edge APIs on Cloudflare Workers, Deno Deploy, or Bun. Show all
  • Edge APIs on Cloudflare Workers, Deno Deploy, or Bun.
  • Portable services you want to run on multiple runtimes.
  • Latency-sensitive endpoints close to the user.
4 features Runs on Workers, Deno, Bun, Node — one codebase. Show all
  • Runs on Workers, Deno, Bun, Node — one codebase.
  • Built on Web Standard Request/Response, not Node-only APIs.
  • Tiny footprint and a very fast router (RegExpRouter).
  • Typed middleware, RPC mode, and validators built in.

Being runtime-agnostic means you must avoid Node-only APIs (fs, process) if you want the edge targets, and each platform has its own bindings and deploy story. The ecosystem is younger than Express’s, so some integrations you’d take for granted aren’t there yet.

 TypeScript Yusuke Wada + OSS community MIT
Laravel PHP’s batteries-included, developer-happiness framework.
★ standard⚙
⚙ Backend
★ standard moderate 2011

The dominant full-stack PHP framework — opinionated and batteries-included, with the Eloquent ORM, Blade templating, routing, queues, auth scaffolding, and a deep first-party ecosystem (Breeze, Sanctum, Livewire, Forge). It aims to make common web tasks elegant rather than make you wire libraries together.
3 use cases Full-stack web apps and server-rendered sites in PHP. Show all
  • Full-stack web apps and server-rendered sites in PHP.
  • SaaS products needing auth, billing, queues, and admin fast.
  • Teams that value convention and a cohesive first-party ecosystem.
4 features Eloquent ORM with expressive Active Record models. Show all
  • Eloquent ORM with expressive Active Record models.
  • Blade templating and Artisan CLI scaffolding.
  • Built-in queues, scheduling, events, and broadcasting.
  • Cohesive first-party stack: Breeze, Sanctum, Livewire, Forge.

The convenience comes with “magic” — facades, service-container auto-resolution, and Eloquent’s Active Record hide a lot, which is productive until you need to debug or optimize it. Eloquent’s lazy loading makes N+1 query problems easy to write accidentally.

 PHP Taylor Otwell / Laravel LLC + OSS MIT
Django Python’s batteries-included framework with a killer admin.
★ standard⚙
⚙ Backend
★ standard moderate 2005

A mature, batteries-included Python web framework following a “model–template–view” pattern. It ships an ORM, an auto-generated admin interface, auth, migrations, forms, and security defaults out of the box — famous for letting you build a data-driven site fast without choosing a stack of libraries.
3 use cases Content- and data-heavy sites needing a real admin interf... Show all
  • Content- and data-heavy sites needing a real admin interface.
  • Full-stack Python web apps and server-rendered pages.
  • REST APIs via Django REST Framework on top of the ORM.
4 features Powerful ORM with migrations baked in. Show all
  • Powerful ORM with migrations baked in.
  • Auto-generated admin site from your models.
  • Built-in auth, forms, sessions, and security middleware.
  • Async views and a huge package ecosystem (DRF, Channels).

It’s opinionated and monolithic — great when your app fits the model-template-view mold, heavier than you want for a tiny JSON API (where FastAPI fits better). The synchronous ORM is the historical core; async support exists but isn’t as seamless as a from-scratch async framework.

 Python Django Software Foundation + OSS BSD-3-Clause
FastAPI Async Python APIs driven by type hints, with free OpenAPI docs.
▲ rising⚙
⚙ Backend
▲ rising gentle 2018

A modern, high-performance Python framework for building APIs, built on Starlette and Pydantic. You annotate function parameters with Python type hints and FastAPI uses them to validate requests, serialize responses, and generate interactive OpenAPI docs automatically — all async-first.
3 use cases Async JSON APIs and microservices in Python. Show all
  • Async JSON APIs and microservices in Python.
  • ML/data-science model serving with typed request bodies.
  • Any API where auto-generated OpenAPI docs save time.
4 features Type-hint-driven request validation via Pydantic. Show all
  • Type-hint-driven request validation via Pydantic.
  • Automatic interactive OpenAPI/Swagger documentation.
  • Async-first on the ASGI standard (Starlette under the hood).
  • Dependency-injection system for shared logic and auth.

“Fast to write” doesn’t include the data layer — FastAPI has no built-in ORM, so you bring SQLAlchemy/SQLModel and wire migrations yourself. Mixing sync and async code, or doing blocking I/O in an async route, quietly stalls the event loop.

 Python Sebastián Ramírez + OSS community MIT
tRPC End-to-end typesafe APIs for TypeScript — no schema, no codegen.
● mainstream⚙▦
⚙ Backend▦ Full-stack
● mainstream moderate 2020

A library for building end-to-end typesafe APIs in a TypeScript codebase. Unlike REST or GraphQL, there’s no schema language or code generation — the server’s procedure types flow directly to the client through TypeScript inference, so a backend change becomes a client-side type error instantly.
3 use cases Full-stack TypeScript monorepos sharing one type system. Show all
  • Full-stack TypeScript monorepos sharing one type system.
  • Next.js apps wanting typed server calls without REST boilerplate.
  • Teams that own both ends and want refactors to stay type-safe.
4 features No schema, no codegen — types inferred from the server. Show all
  • No schema, no codegen — types inferred from the server.
  • Autocomplete and compile-time errors across the client/server boundary.
  • Adapters for Next.js, Express, Fastify, and more.
  • Pairs with TanStack Query for client-side caching.

It’s TypeScript-to-TypeScript only — there’s no public, language-agnostic contract, so it’s a poor fit for third-party consumers, mobile teams on other stacks, or public APIs (reach for REST/GraphQL there). The magic also tightly couples client and server, which only works in a shared codebase.

 TypeScript Alex Johansson + OSS community MIT
GraphQL Yoga A batteries-included, spec-compliant GraphQL server.
● mainstream⚙
⚙ Backend
● mainstream moderate 2018

A fully-featured GraphQL server from The Guild, built on the GraphQL.js reference implementation. It is runtime-agnostic (Node, Bun, Deno, Workers) thanks to Web Standard Request/Response, ships sensible defaults — subscriptions, file uploads, and a built-in GraphiQL explorer — and plugs into the Envelop plugin ecosystem.
3 use cases Standing up a GraphQL API server with minimal config. Show all
  • Standing up a GraphQL API server with minimal config.
  • Graphs that need subscriptions, uploads, or the Envelop plugin system.
  • GraphQL endpoints on edge runtimes alongside Node.
4 features Spec-compliant on the GraphQL.js reference implementation. Show all
  • Spec-compliant on the GraphQL.js reference implementation.
  • Runtime-agnostic: Node, Bun, Deno, Cloudflare Workers.
  • Subscriptions, file uploads, and GraphiQL built in.
  • Extensible via the Envelop plugin ecosystem.

Yoga is the server — you still design the schema and write resolvers, and GraphQL’s own footguns (N+1 resolver queries needing DataLoader, query-depth and complexity limits to prevent abuse) are on you. For simple typed internal APIs, tRPC is often less ceremony.

 TypeScript The Guild + OSS community MIT
Ruby on Rails The original convention-over-configuration fullstack framework.
★ standard⚙▦
⚙ Backend▦ Full-stack
★ standard moderate 2004

The opinionated, batteries-included Ruby framework that popularized convention over configuration and MVC for the web. It bundles an ORM (Active Record), routing, mailers, jobs, and asset handling, and recent versions lean into Hotwire (Turbo + Stimulus) to ship rich, mostly server-rendered UIs with minimal JavaScript.
3 use cases Rapidly building CRUD-heavy web apps and MVPs. Show all
  • Rapidly building CRUD-heavy web apps and MVPs.
  • Monolithic SaaS products where developer velocity matters.
  • Server-rendered apps with Hotwire instead of a heavy SPA.
4 features Active Record ORM with migrations and associations. Show all
  • Active Record ORM with migrations and associations.
  • Convention over configuration — sane defaults, less wiring.
  • Hotwire (Turbo + Stimulus) for SPA-like UX, server-rendered.
  • Generators, mailers, background jobs, and a mature ecosystem of gems.

The conventions are productive until you fight them — Active Record makes N+1 queries and runaway callbacks easy, and the heavy reliance on magic and metaprogramming can make large apps hard to reason about. Boot time and memory use are also high relative to leaner stacks.

 Ruby Rails core team + OSS MIT
Flask Python’s minimal, unopinionated micro-framework.
● mainstream⚙
⚙ Backend
● mainstream gentle 2010

A lightweight Python micro-framework that gives you routing, request handling, and templating (Jinja2) and stays out of your way for everything else. You add an ORM, validation, and auth as extensions, making it ideal for small services where you want to choose your own components.
3 use cases Small to medium web apps and internal tools. Show all
  • Small to medium web apps and internal tools.
  • Lightweight REST APIs and microservices.
  • Prototypes where you want minimal structure imposed.
3 features Minimal core — routing plus Jinja2 templating, little else. Show all
  • Minimal core — routing plus Jinja2 templating, little else.
  • Extension ecosystem (SQLAlchemy, Migrate, Login) for the rest.
  • Werkzeug WSGI foundation with a simple, readable API.

Flask is synchronous and WSGI-based, so high-concurrency async workloads fit FastAPI better. Being unopinionated means every project wires up the ORM, validation, and structure differently, which can hurt consistency across teams.

 Python Pallets + OSS BSD-3-Clause
Spring Boot Convention-driven Spring for production-ready Java services.
★ standard⚙
⚙ Backend
★ standard steep 2014

The opinionated layer over the Spring framework that makes Java backends production-ready with minimal configuration — auto-configuration, embedded servers, and starter dependencies replace mountains of XML. It’s the default for enterprise JVM services, with deep support for data access, security, messaging, and observability.
3 use cases Large enterprise REST and microservice backends on the JVM. Show all
  • Large enterprise REST and microservice backends on the JVM.
  • Systems needing robust transactions, security, and messaging.
  • Teams standardized on Java/Kotlin with strong tooling needs.
4 features Auto-configuration and starter dependencies — little boil... Show all
  • Auto-configuration and starter dependencies — little boilerplate.
  • Embedded Tomcat/Netty so apps run as a self-contained jar.
  • Spring Data, Security, and Actuator for data, auth, and metrics.
  • GraalVM native-image support for fast startup and low memory.

Power comes with weight — the dependency-injection container, annotation magic, and layered abstractions are a lot to learn, and the framework’s depth means subtle auto-configuration surprises. Startup time and memory are heavy unless you adopt GraalVM native images.

 Java VMware/Broadcom + OSS Apache-2.0
ASP.NET Core Microsoft’s fast, cross-platform fullstack web framework.
★ standard⚙▦
⚙ Backend▦ Full-stack
★ standard moderate 2016

A high-performance, cross-platform framework for building APIs and web apps on .NET, running on Linux, macOS, and Windows. It spans minimal APIs, MVC, Razor Pages, and the Blazor component model (including server and WebAssembly), backed by strong tooling and consistently top-tier benchmarks.
3 use cases High-throughput REST and gRPC APIs on .NET. Show all
  • High-throughput REST and gRPC APIs on .NET.
  • Enterprise web apps with MVC or Razor Pages.
  • Interactive UIs in C# via Blazor instead of JavaScript.
4 features Minimal APIs and MVC on one cross-platform runtime. Show all
  • Minimal APIs and MVC on one cross-platform runtime.
  • Blazor for C# component UIs (server + WebAssembly).
  • Built-in DI, configuration, logging, and middleware pipeline.
  • Top-tier performance with Kestrel and AOT compilation.

The framework spans several UI models — minimal APIs, MVC, Razor Pages, Blazor Server, Blazor WASM — and picking the wrong one for your use case is a costly detour. Blazor WebAssembly in particular ships a sizable .NET runtime, so first-load size needs attention.

 C# Microsoft + .NET Foundation MIT
Koa Express’s successor — tiny, middleware-first, async/await native.
● mainstream⚙
⚙ Backend
● mainstream gentle 2013

A minimal Node web framework from the Express creators, built around async/await and a clean middleware-cascade model. Its core ships almost nothing — no router or body parser — so you compose exactly the middleware you need, with a ctx object wrapping request and response.
3 use cases Lightweight APIs where you want full control over middlew... Show all
  • Lightweight APIs where you want full control over middleware.
  • Modern async/await codebases avoiding Express callback patterns.
  • A minimal base to compose your own framework on top of.
3 features Async/await-native middleware with an elegant downstream/... Show all
  • Async/await-native middleware with an elegant downstream/upstream cascade.
  • Tiny core — bring your own router, body parser, and helpers.
  • Single ctx object encapsulating request and response.

The minimal core is a double-edged sword — you assemble routing, body parsing, and validation from separate packages, and the ecosystem is far smaller than Express’s. Momentum has also slowed as Fastify and Hono draw attention.

 JavaScript Koa team (Express creators) MIT
Elysia Bun-first, end-to-end type-safe framework with blazing throughput.
▲ rising⚙
⚙ Backend
▲ rising gentle 2022

A TypeScript web framework built for Bun that pairs extreme performance with end-to-end type safety. Its schema-driven design validates and types requests automatically, and the Eden client gives the frontend fully typed calls to the backend — a tRPC-like experience over plain HTTP.
3 use cases High-throughput APIs running on the Bun runtime. Show all
  • High-throughput APIs running on the Bun runtime.
  • End-to-end typed fullstack apps via the Eden client.
  • Greenfield TypeScript services wanting modern ergonomics.
3 features Schema-first validation that also infers request/response... Show all
  • Schema-first validation that also infers request/response types.
  • Eden client for end-to-end type-safe API calls.
  • Very high throughput on Bun; plugin system for auth, CORS, swagger.

Elysia is Bun-first — running it on Node loses some performance and features, so it ties you to that runtime. It’s young and fast-moving, so APIs still shift between versions and the plugin ecosystem is smaller than Express’s or Fastify’s.

 TypeScript SaltyAom + OSS MIT
PostgreSQL The world’s most advanced open-source relational database.
★ standard▣
▣ Database
★ standard moderate 1996

The default open-source relational database for new projects — a mature, standards-compliant SQL engine known for correctness, extensibility, and a deep feature set: rich types (JSONB, arrays, ranges), full-text search, window functions, and an extension ecosystem (PostGIS, pgvector). Most modern ORMs and serverless platforms target it first.
3 use cases The default relational store for new web and SaaS backends. Show all
  • The default relational store for new web and SaaS backends.
  • Workloads mixing relational data with JSON or vector/geo queries.
  • Anything needing strong ACID guarantees and complex queries.
4 features Full ACID compliance and rich SQL (window functions, CTEs). Show all
  • Full ACID compliance and rich SQL (window functions, CTEs).
  • JSONB for schemaless data alongside relational tables.
  • Extensions: PostGIS (geo), pgvector (embeddings), and more.
  • MVCC concurrency and robust replication.

Connection-heavy: each connection is a process, so serverless functions that open connections per-invocation exhaust the server — you need a pooler (PgBouncer, or a platform like Neon/Supabase that bundles one). Tuning VACUUM and autovacuum on write-heavy tables is a real operational concern.

 C PostgreSQL Global Development Group PostgreSQL License
MySQL The ubiquitous open-source relational database.
★ standard▣
▣ Database
★ standard moderate 1995

One of the most widely deployed relational databases, the “M” in the classic LAMP stack and the default behind much of the PHP web. Owned by Oracle and dual-licensed (GPL plus a commercial license), with the community-driven fork MariaDB as a drop-in alternative. Reliable, fast on read-heavy workloads, and supported by every host and ORM.
3 use cases Classic LAMP / PHP web apps and WordPress sites. Show all
  • Classic LAMP / PHP web apps and WordPress sites.
  • Read-heavy applications with well-understood schemas.
  • Projects on hosts where MySQL is the default offering.
4 features ACID transactions via the InnoDB storage engine. Show all
  • ACID transactions via the InnoDB storage engine.
  • Mature replication and broad hosting support everywhere.
  • Pluggable storage engines (InnoDB, MyISAM).
  • MariaDB fork as a drop-in, fully open alternative.

Feature parity with Postgres lags in places — historically weaker support for advanced SQL, stricter SQL-mode quirks, and gotchas around default character sets (use utf8mb4, not the legacy utf8, for full Unicode). The dual GPL/commercial license matters if you embed or redistribute it.

 C++ Oracle Corporation GPL-2.0
SQLite A zero-config, embedded SQL database in a single file.
★ standard▣
▣ Database
★ standard gentle 2000

A self-contained, serverless, zero-configuration SQL database engine — the entire database is a single file on disk and the engine is a library linked into your app, with no separate process to run. It is the most widely deployed database in the world (every phone, browser, and OS ships it) and is increasingly used for production web apps at the edge.
3 use cases Embedded storage in mobile, desktop, and CLI apps. Show all
  • Embedded storage in mobile, desktop, and CLI apps.
  • Local development, tests, and prototypes — no server to run.
  • Edge / low-traffic web apps (often via Turso/libSQL or LiteFS).
4 features Entire database is one portable file; no server process. Show all
  • Entire database is one portable file; no server process.
  • Zero configuration — link the library and open a file.
  • Full transactional ACID even across crashes.
  • Tiny, public-domain, and embedded almost everywhere.

Single-writer by design — concurrent writes serialize, so it’s a poor fit for write-heavy, high-concurrency multi-user backends without a layer like libSQL/Turso. It’s also loosely typed by default (type affinity, not strict types) unless you opt into STRICT tables.

 C D. Richard Hipp / SQLite Consortium Public Domain
MongoDB The popular document database for flexible, JSON-like data.
● mainstream▣
▣ Database
● mainstream moderate 2009

A document-oriented NoSQL database that stores records as flexible, JSON-like BSON documents instead of rows in tables — so the schema can vary per document and nested data lives together. Popular for its developer-friendly model and horizontal scaling; its managed Atlas service is the common way to run it. Licensed under the source-available SSPL, not an OSI-approved open-source license.
3 use cases Apps with flexible or rapidly-evolving schemas. Show all
  • Apps with flexible or rapidly-evolving schemas.
  • Content, catalogs, and event data that fit a document shape.
  • Horizontally-scaled workloads via sharding (often on Atlas).
4 features Flexible JSON-like (BSON) documents, no fixed schema. Show all
  • Flexible JSON-like (BSON) documents, no fixed schema.
  • Aggregation pipeline for complex transformations.
  • Built-in sharding for horizontal scale and replica sets.
  • Managed Atlas service with search and vector search.

Schema flexibility is a double-edged sword — without discipline (or an ODM like Mongoose) data drifts into inconsistent shapes. Multi-document transactions exist but cost more than in a relational DB, and modeling relationships you’d join in SQL often means denormalizing. The SSPL license blocks offering MongoDB itself as a managed service.

 C++ MongoDB, Inc. SSPL
Redis Blazing-fast in-memory key-value store, cache, and message broker.
★ standard▣
▣ Database
★ standard moderate 2009

An in-memory data-structure store used as a cache, key-value database, and message broker. It keeps data in RAM (with optional persistence to disk) for sub-millisecond access, and offers rich types — strings, hashes, lists, sets, sorted sets, streams, and pub/sub. After a 2024 move to source-available terms, Redis 8 (2025) re-added the OSI-approved AGPLv3 as a license option.
3 use cases Caching layer in front of a slower primary database. Show all
  • Caching layer in front of a slower primary database.
  • Sessions, rate limiting, and ephemeral counters.
  • Job queues, pub/sub, leaderboards (sorted sets), and streams.
 —
4 features Sub-millisecond in-memory reads and writes. Show all
  • Sub-millisecond in-memory reads and writes.
  • Rich data types: hashes, lists, sets, sorted sets, streams.
  • Pub/sub and stream messaging primitives.
  • Optional persistence (RDB snapshots, AOF) and replication.

It’s memory-bound — your dataset must fit in RAM, and eviction policies decide what gets dropped when it’s full, so it’s usually a cache or secondary store, not your system of record. The 2024–2025 license churn (SSPL/RSALv2, then AGPLv3 re-added in Redis 8) spawned the Valkey fork; check which license your distro/cloud ships.

 C Redis Ltd. + OSS community AGPLv3 / RSALv2 / SSPL
Firebase Firestore Google’s serverless document database with realtime sync.
● mainstream▣
▣ Database
● mainstream gentle 2017

A fully-managed, serverless NoSQL document database from Google’s Firebase platform. Clients subscribe to documents and queries and receive realtime updates as data changes, with offline caching on mobile and web. Access control lives in declarative security rules rather than a server, making it popular for client-driven apps without a backend.
3 use cases Realtime apps — chat, collaboration, live dashboards. Show all
  • Realtime apps — chat, collaboration, live dashboards.
  • Mobile/web apps wanting offline sync with no server to run.
  • MVPs that lean on Firebase Auth, Storage, and Functions together.
4 features Realtime listeners push changes to clients instantly. Show all
  • Realtime listeners push changes to clients instantly.
  • Offline persistence and automatic sync on reconnect.
  • Declarative security rules instead of server-side authz.
  • Tight integration with Firebase Auth, Storage, and Functions.

It’s proprietary lock-in and the data model bends queries — no joins, no arbitrary WHERE/aggregation, every multi-field query needs a composite index, and you denormalize heavily. Billing is per document read/write, so naive realtime listeners or fan-out writes can run up a surprising bill.

 proprietary (Go/C++ internally) Google (Firebase / Google Cloud) proprietary
Supabase The open-source Firebase alternative, built on Postgres.
▲ rising▣⚙
▣ Database⚙ Backend
▲ rising gentle 2020

An open-source backend-as-a-service that bundles a full PostgreSQL database with auth, file storage, edge functions, and realtime subscriptions — positioned as a Firebase alternative, but on a real relational engine you can query with SQL and take with you. It auto-generates a REST and GraphQL API from your schema and enforces access with Postgres row-level security.
3 use cases Full app backends wanting Postgres plus auth, storage, an... Show all
  • Full app backends wanting Postgres plus auth, storage, and realtime.
  • Teams that want a Firebase-like DX without leaving SQL.
  • Projects that may later self-host the open-source stack.
4 features A real Postgres database, queryable in plain SQL. Show all
  • A real Postgres database, queryable in plain SQL.
  • Built-in auth, storage, edge functions, and realtime.
  • Auto-generated REST and GraphQL APIs from your schema.
  • Row-level security policies for client-direct access.

The client-direct model lives or dies by row-level security — forget to enable RLS on a table and it’s world-readable/writable. “Open-source” is true of the stack, but self-hosting the whole platform is non-trivial; most teams use the managed cloud and inherit its pricing.

 TypeScript / Elixir / Go Supabase, Inc. + OSS community Apache-2.0
PlanetScale Serverless MySQL on Vitess with database branching.
● mainstream▣
▣ Database
● mainstream moderate 2021

A managed, serverless MySQL-compatible database platform built on Vitess (the sharding layer that scaled YouTube). Its signature feature is Git-style database branching: spin off a branch, change the schema, and merge it back as a non-blocking, online deploy request. PlanetScale removed its free tier in April 2024, so it now starts around $39/month.
3 use cases MySQL apps that need horizontal scale via Vitess sharding. Show all
  • MySQL apps that need horizontal scale via Vitess sharding.
  • Teams wanting schema changes as reviewable, non-blocking deploys.
  • Production MySQL workloads with serverless connection handling.
4 features Git-style branching with online, non-blocking schema depl... Show all
  • Git-style branching with online, non-blocking schema deploys.
  • Built on Vitess for transparent horizontal sharding.
  • Serverless connection pooling friendly to edge/functions.
  • Insights and query analysis built in.

The free tier is gone (since April 2024), so it’s a paid service from the start — factor that against free-tier rivals. Because it’s Vitess, some MySQL features are constrained: foreign-key enforcement is limited and cross-shard transactions/joins don’t behave like single-node MySQL.

 Go (Vitess) PlanetScale, Inc. proprietary
Neon Serverless Postgres with instant database branching.
▲ rising▣
▣ Database
▲ rising gentle 2021

A serverless PostgreSQL platform that separates storage from compute, so databases scale to zero when idle and spin up on demand, and you can branch the entire database (data and schema) instantly like Git for development or preview environments. The core is Apache-2.0 licensed. Neon was acquired by Databricks in May 2025 (~$1B), which kept the free tier and lowered prices.
3 use cases Serverless and edge apps wanting Postgres that scales to ... Show all
  • Serverless and edge apps wanting Postgres that scales to zero.
  • Per-pull-request preview databases via instant branching.
  • Cost-sensitive projects with spiky or intermittent traffic.
4 features Separated storage/compute — scales to zero when idle. Show all
  • Separated storage/compute — scales to zero when idle.
  • Instant copy-on-write branching of the whole database.
  • Serverless driver works over HTTP/WebSocket from the edge.
  • Apache-2.0 core; standard Postgres wire protocol.

Scale-to-zero means a cold start — the first query after idle pays a wake-up latency, which matters for user-facing requests (keep a paid compute warm if it does). Long-lived pooled connections and very write-heavy steady workloads fit the serverless billing model less well than spiky ones.

 Rust Neon (Databricks) + OSS community Apache-2.0
MariaDB The community-driven, drop-in MySQL fork.
● mainstream▣
▣ Database
● mainstream moderate 2009

A relational database forked from MySQL by its original authors after the Oracle acquisition, designed as a (mostly) drop-in replacement. It keeps wire and SQL compatibility with MySQL while adding its own storage engines (Aria, ColumnStore), features, and a community governance model under the MariaDB Foundation.
3 use cases Drop-in MySQL replacement to stay on a fully open-source ... Show all
  • Drop-in MySQL replacement to stay on a fully open-source license.
  • General-purpose relational workloads for web apps and CMSes.
  • Analytics via the ColumnStore engine alongside transactional tables.
3 features High wire/SQL compatibility with MySQL — usually a drop-i... Show all
  • High wire/SQL compatibility with MySQL — usually a drop-in swap.
  • Pluggable storage engines (InnoDB, Aria, ColumnStore).
  • Community-governed under the MariaDB Foundation, fully GPL.

“Drop-in” is no longer 100% — MariaDB and MySQL have diverged on JSON handling, replication, and newer SQL features, so migrating a large app needs testing. Pin compatibility to the specific versions you target rather than assuming parity.

 C/C++ MariaDB Foundation GPL-2.0
CockroachDB Distributed SQL — Postgres wire compatibility, horizontal scale.
● mainstream▣
▣ Database
● mainstream steep 2017

A distributed SQL database that speaks the PostgreSQL wire protocol while scaling horizontally and surviving node, zone, and region failures. It gives you serializable transactions and strong consistency across a cluster via the Raft consensus protocol — a relational feel with NoSQL-style resilience and geo-distribution.
3 use cases Globally distributed apps needing strong consistency acro... Show all
  • Globally distributed apps needing strong consistency across regions.
  • Workloads that must survive node/region failures with no data loss.
  • Scaling out a relational schema beyond a single primary.
4 features Horizontal scale with automatic sharding and rebalancing. Show all
  • Horizontal scale with automatic sharding and rebalancing.
  • PostgreSQL wire compatibility — reuse Postgres drivers and tools.
  • Serializable transactions and survivability via Raft consensus.
  • Geo-partitioning to pin data to regions for latency and compliance.

Distribution has a tax — cross-range transactions and contended hotspots add latency, and SQL features differ subtly from real PostgreSQL, so Postgres compatibility isn’t total. The core moved to the BSL source-available license, so check terms before commercial self-hosting.

 Go Cockroach Labs BSL 1.1
DynamoDB AWS’s fully managed, serverless key-value & document store.
● mainstream▣☁
▣ Database☁ Infra
● mainstream moderate 2012

A fully managed, serverless NoSQL database from AWS offering single-digit millisecond latency at any scale with no servers to manage. You provision or auto-scale throughput, and it handles partitioning, replication, and durability — but performance hinges on designing your tables and keys around access patterns up front.
3 use cases High-scale, low-latency key-value and document workloads ... Show all
  • High-scale, low-latency key-value and document workloads on AWS.
  • Serverless backends (Lambda) needing a managed, auto-scaling store.
  • Event sourcing and session/cart stores with predictable access patterns.
4 features Fully managed and serverless — no capacity planning for n... Show all
  • Fully managed and serverless — no capacity planning for nodes.
  • Single-digit-millisecond latency with on-demand or provisioned capacity.
  • Global tables for multi-region replication; streams for change capture.
  • Strong AWS Lambda and IAM integration.

You model for access patterns, not entities — get the partition-key and single-table design wrong and queries become impossible or trigger costly full scans, with little room to refactor later. Cross-item transactions and ad-hoc queries are far weaker than in a relational engine.

 — AWS proprietary
Elasticsearch Distributed full-text search and analytics engine.
● mainstream▣
▣ Database
● mainstream steep 2010

A distributed search and analytics engine built on Apache Lucene, storing JSON documents and making them searchable in near real time. It powers full-text search, log and metrics analytics, and is the heart of the ELK/Elastic stack alongside Kibana and Logstash/Beats.
3 use cases Full-text and faceted search over large document sets. Show all
  • Full-text and faceted search over large document sets.
  • Centralized log and observability analytics (the ELK stack).
  • Near-real-time aggregations and dashboards over event data.
4 features Inverted-index full-text search with relevance scoring (B... Show all
  • Inverted-index full-text search with relevance scoring (BM25).
  • Distributed sharding and replication for scale and resilience.
  • Powerful aggregations for analytics; vector search for semantic queries.
  • Kibana, Logstash, and Beats for the broader Elastic stack.

It’s a search engine, not a system of record — replication has had consistency caveats, so keep authoritative data elsewhere and treat Elasticsearch as a derived index. Mapping mistakes and unbounded aggregations are also notorious memory hogs, and the SSPL/Elastic license shift spawned the OpenSearch fork.

 Java Elastic Elastic/SSPL
ClickHouse Blazing-fast columnar database for real-time analytics (OLAP).
▲ rising▣
▣ Database
▲ rising steep 2016

An open-source columnar database built for online analytical processing, capable of scanning billions of rows per second. Its column-oriented storage, vectorized execution, and aggressive compression make it extraordinarily fast for aggregations over huge datasets — analytics, not transactional, workloads.
3 use cases Real-time analytics dashboards over billions of events. Show all
  • Real-time analytics dashboards over billions of events.
  • Log, metrics, and observability data warehousing.
  • Ad-hoc aggregations where a row store would be too slow.
4 features Columnar storage with vectorized query execution. Show all
  • Columnar storage with vectorized query execution.
  • High compression ratios that shrink storage and speed scans.
  • Sub-second aggregations over billions of rows.
  • SQL dialect with rich analytical functions and materialized views.

It’s OLAP, not OLTP — single-row updates and deletes are expensive and eventually-applied (mutations), and there are no real foreign keys or multi-row transactions, so it’s a poor fit as a primary transactional store. Schema and partitioning choices heavily dictate performance.

 C++ ClickHouse Inc. Apache-2.0
Turso libSQL/SQLite at the edge — a database per tenant, anywhere.
▲ rising▣
▣ Database
▲ rising gentle 2023

An edge-hosted database platform built on libSQL, an open-source fork of SQLite. It replicates lightweight SQLite databases close to users for low read latency and makes spinning up many databases cheap — ideal for multi-tenant apps that want a separate database per customer.
3 use cases Low-latency reads from edge locations near users. Show all
  • Low-latency reads from edge locations near users.
  • Multi-tenant apps with a cheap database-per-tenant model.
  • SQLite-friendly apps that need hosted, replicated storage.
4 features Built on libSQL, an open fork of SQLite with extra features. Show all
  • Built on libSQL, an open fork of SQLite with extra features.
  • Edge replicas (embedded + sync) for fast local reads.
  • Cheap to create thousands of per-tenant databases.
  • Works with SQLite drivers and ORMs like Drizzle and Prisma.

It inherits SQLite’s model — a single writer, so write-heavy or high- concurrency-write workloads don’t scale the way Postgres does, and embedded replicas are read-only. It’s a young platform, so weigh maturity for mission-critical primary storage.

 Rust Turso/ChiselStrike MIT (libSQL)
Convex Reactive backend-as-a-database with TypeScript functions.
▲ rising▣⚙▦
▣ Database⚙ Backend▦ Full-stack
▲ rising moderate 2023

A reactive backend platform that merges a document database with a serverless function layer, all written in TypeScript. Queries are live by default — the client re-renders automatically when underlying data changes — and transactions, scheduling, file storage, and a typed schema come built in, blurring the line between database and backend.
3 use cases Realtime apps (collaboration, dashboards, chat) without w... Show all
  • Realtime apps (collaboration, dashboards, chat) without wiring sockets.
  • Fullstack TypeScript apps wanting one typed backend abstraction.
  • Replacing a hand-built API + database + websocket layer.
4 features Live, reactive queries that push updates to clients autom... Show all
  • Live, reactive queries that push updates to clients automatically.
  • Backend logic as typed TypeScript query/mutation functions.
  • ACID transactions, scheduled functions, and file storage built in.
  • End-to-end types from the schema through to the React hooks.

The reactive, function-centric model is a different mental model from a plain SQL/REST stack, and you write data access in Convex’s API rather than portable SQL — so it’s a real platform commitment with vendor lock-in to weigh. Self-hosting exists but the managed service is the primary path.

 Rust/TypeScript Convex Inc. FSL/Apache-2.0
Prisma The schema-first TypeScript ORM with end-to-end type safety.
★ standard⚙
⚙ Backend
★ standard gentle 2019

A schema-first ORM for Node.js and TypeScript: you describe your models in a schema.prisma file and Prisma generates a fully typed client plus SQL migrations. Prisma 7 (Nov 2025) removed the Rust query engine — the client is now pure TypeScript/WebAssembly, cutting bundle size ~85–90%, working on the edge, and starting cold far faster.
3 use cases TypeScript backends that want autocompleted, type-safe qu... Show all
  • TypeScript backends that want autocompleted, type-safe queries.
  • Teams who want declarative migrations from a single schema file.
  • Serverless and edge functions (post-v7, with no native binary).
4 features Single schema.prisma source of truth for models + migrati... Show all
  • Single schema.prisma source of truth for models + migrations.
  • Generated, fully typed client — autocomplete on every query.
  • Prisma Migrate for versioned schema changes; Prisma Studio GUI.
  • v7: pure TS/WASM engine — edge-compatible, smaller, faster cold starts.

Before v7 the Rust query engine shipped as a native binary that bloated bundles and broke on some edge/serverless runtimes — pin to v7+ if you target the edge. Long-running connection pools in serverless still need Prisma Accelerate or a pooler like PgBouncer to avoid exhausting connections.

 TypeScript Prisma Data, Inc. + OSS community Apache-2.0
Drizzle A lightweight, SQL-like TypeScript ORM built for the edge.
▲ rising⚙
⚙ Backend
▲ rising moderate 2022

A code-first, headless TypeScript ORM whose query API mirrors SQL — if you know SQL, you already know Drizzle. You declare your schema in TypeScript, ship a tiny zero-dependency runtime, and get full type inference, making it a favourite for serverless and edge deployments.
3 use cases Serverless and edge runtimes where bundle size and cold s... Show all
  • Serverless and edge runtimes where bundle size and cold starts matter.
  • Developers who want SQL-shaped queries with full type inference.
  • Projects that prefer schema-in-TypeScript over a separate DSL file.
4 features SQL-like query builder — thin abstraction, no hidden magic. Show all
  • SQL-like query builder — thin abstraction, no hidden magic.
  • Tiny, zero-dependency runtime; serverless/edge-friendly.
  • Schema declared in TypeScript with full inference.
  • drizzle-kit for migrations; Drizzle Studio for browsing data.

The SQL-like surface means less hand-holding than Prisma — you write more explicit joins and relational queries yourself. The relational query API and migration tooling have matured fast but still churn between minor versions, so read the changelog before upgrading.

 TypeScript Drizzle Team + OSS community Apache-2.0
TypeORM Decorator-based ORM with Active Record and Data Mapper patterns.
● mainstream⚙
⚙ Backend
● mainstream moderate 2016

A mature TypeScript/JavaScript ORM that maps classes to tables using decorators (@Entity, @Column). It supports both the Active Record and Data Mapper patterns and many SQL databases, and is the default ORM in the NestJS ecosystem — though its maintenance cadence has been uneven.
3 use cases NestJS apps, where TypeORM is the conventional data layer. Show all
  • NestJS apps, where TypeORM is the conventional data layer.
  • Teams who prefer class + decorator entity definitions.
  • Projects wanting a choice of Active Record or Data Mapper style.
4 features Decorator-driven entities (@Entity, @Column, @ManyToOne). Show all
  • Decorator-driven entities (@Entity, @Column, @ManyToOne).
  • Both Active Record and Data Mapper patterns supported.
  • Migrations, query builder, and broad SQL database support.
  • First-class integration with NestJS.

Maintenance has been famously stop-start, with long gaps between releases and a backlog of open issues. Decorators require reflect-metadata and specific tsconfig flags (experimentalDecorators, emitDecoratorMetadata), and the type safety is weaker than Prisma or Drizzle — many queries fall back to any.

 TypeScript TypeORM contributors (OSS) MIT
Sequelize The long-standing promise-based ORM for SQL databases.
● mainstream⚙
⚙ Backend
● mainstream moderate 2010

One of the oldest Node.js ORMs — a promise-based, model-driven library for Postgres, MySQL, MariaDB, SQLite, and SQL Server. Battle-tested and widely deployed, it predates the TypeScript-first wave and its typings, while improved, still feel bolted on rather than native.
3 use cases Established JavaScript codebases already standardized on ... Show all
  • Established JavaScript codebases already standardized on Sequelize.
  • Apps targeting multiple SQL dialects from one model layer.
  • Maintaining legacy Express services with existing models.
4 features Model definitions, associations, validations, and hooks. Show all
  • Model definitions, associations, validations, and hooks.
  • Supports Postgres, MySQL, MariaDB, SQLite, and SQL Server.
  • Migrations and seeders via the Sequelize CLI.
  • Transactions, eager/lazy loading, and raw query escape hatch.

TypeScript support is the weak spot — types are community-maintained and verbose, and many setups still type query results loosely. For greenfield TypeScript projects, Prisma or Drizzle give far stronger inference; reach for Sequelize mainly when a codebase already depends on it.

 JavaScript Sequelize contributors (OSS) MIT
Knex.js A SQL query builder, not a full ORM — you stay close to SQL.
● mainstream⚙
⚙ Backend
● mainstream gentle 2013

A SQL query builder (not an ORM) for Node.js: it builds and runs SQL across Postgres, MySQL, SQLite, and more via a fluent, chainable API, plus connection pooling and migrations. There’s no model or identity map — you get composable SQL without raw string concatenation.
3 use cases Apps that want SQL control without an ORM's abstraction. Show all
  • Apps that want SQL control without an ORM’s abstraction.
  • As the query layer underneath higher-level libraries (e.g. Objection.js).
  • Database migrations and seeds in plain Node scripts.
4 features Fluent, chainable query builder over many SQL dialects. Show all
  • Fluent, chainable query builder over many SQL dialects.
  • Built-in migrations, seeds, and connection pooling.
  • Raw SQL escape hatch when the builder isn’t enough.
  • No model layer — a thin abstraction close to the database.

It’s a query builder, so there’s no identity map, relations, or lazy loading — you manage those yourself. Result rows are largely untyped (any) unless you layer types manually, which is why type-conscious teams increasingly reach for Kysely or Drizzle instead.

 JavaScript Knex.js contributors (OSS) MIT
Mongoose The de-facto standard ODM for MongoDB and Node.js.
★ standard⚙
⚙ Backend
★ standard gentle 2010

The standard Object Document Mapper (ODM) for MongoDB — the document-store analogue of an ORM. It adds schemas, validation, middleware, and population (referenced-document joins) on top of MongoDB’s otherwise schemaless documents, giving structure to an unstructured store.
3 use cases Node.js apps using MongoDB that want schema validation an... Show all
  • Node.js apps using MongoDB that want schema validation and structure.
  • Modeling relationships between documents via population.
  • MERN/MEAN-stack backends needing middleware hooks on save/update.
4 features Schemas with type casting, validation, and defaults. Show all
  • Schemas with type casting, validation, and defaults.
  • Middleware (pre/post hooks) on document lifecycle events.
  • Population to resolve references across documents.
  • Plugins, virtuals, and a fluent query API.

Mongoose adds a schema layer over a schemaless database, which can fight MongoDB’s flexible-document strengths and adds overhead on hot paths. TypeScript typing of schemas is improving but historically clunky, and populate joins are easy to overuse, hurting performance.

 JavaScript Automattic + OSS community MIT
Kysely Type-safe SQL query builder — write SQL, get full inference.
▲ rising🔧⚙
🔧 Tooling⚙ Backend
▲ rising gentle 2022

A type-safe SQL query builder for TypeScript — not a full ORM. You define your database’s types once and Kysely gives you autocompleted, statically checked queries that read almost exactly like SQL, with no hidden runtime magic. It stays close to the database while catching column and join mistakes at compile time.
3 use cases Type-safe SQL without the abstraction of a full ORM. Show all
  • Type-safe SQL without the abstraction of a full ORM.
  • Edge/serverless backends needing a tiny, dependency-light query layer.
  • Replacing raw string SQL with checked, autocompleted builders.
3 features Fully typed queries inferred from a database interface. Show all
  • Fully typed queries inferred from a database interface.
  • Reads like SQL — selects, joins, CTEs, subqueries — no DSL surprises.
  • Lightweight with dialects for Postgres, MySQL, SQLite, and more.

It’s a query builder, not an ORM — there’s no entity tracking, lazy relations, or built-in migration runner, so you bring your own (the companion kysely-migrations or a tool like Atlas). You also hand-write the database types or generate them with kysely-codegen, and stale types drift from the real schema.

 TypeScript Sami Koskimäki + OSS MIT
MikroORM TypeScript ORM built on the Unit of Work + Data Mapper patterns.
● mainstream🔧⚙
🔧 Tooling⚙ Backend
● mainstream moderate 2018

A TypeScript ORM based on the Data Mapper, Unit of Work, and Identity Map patterns — it tracks entity changes in memory and flushes them in a single transaction. It supports Postgres, MySQL, SQLite, and MongoDB with one API, decorator or schema-defined entities, and strong type safety.
3 use cases Apps wanting Unit-of-Work change tracking and automatic f... Show all
  • Apps wanting Unit-of-Work change tracking and automatic flushing.
  • Sharing one ORM API across SQL databases and MongoDB.
  • NestJS backends needing a typed, feature-rich data layer.
4 features Unit of Work + Identity Map — batched, transactional flus... Show all
  • Unit of Work + Identity Map — batched, transactional flushes.
  • Data Mapper entities via decorators or schema definitions.
  • Supports Postgres, MySQL, MariaDB, SQLite, and MongoDB.
  • Migrations, seeders, and a query builder built in.

The Unit of Work is powerful but surprising — entities are managed by an Identity Map and only persisted on flush(), so forgetting to flush (or forking the EntityManager per request) causes lost or leaked changes. Managed vs detached entity state trips up newcomers.

 TypeScript Martin Adámek + OSS MIT
SQLAlchemy Python’s definitive SQL toolkit and ORM.
★ standard🔧⚙
🔧 Tooling⚙ Backend
★ standard steep 2006

The most established data-access library in Python, offering two layers: a lower-level SQL Expression Language (Core) and a full-featured ORM on top. The 2.0 series unified the API around explicit, typed sessions and queries, and it remains the backbone of most serious Python database work.
3 use cases Production Python apps needing a mature, flexible ORM. Show all
  • Production Python apps needing a mature, flexible ORM.
  • Complex queries where you want to drop down to SQL Core.
  • FastAPI/Flask backends pairing with Alembic migrations.
4 features Two layers — SQL Expression Language (Core) plus a full ORM. Show all
  • Two layers — SQL Expression Language (Core) plus a full ORM.
  • Unit-of-Work session with identity map and change tracking.
  • Dialects for Postgres, MySQL, SQLite, and many more.
  • Alembic for schema migrations; typed 2.0 query API.

The power and two-layer design make for a steep curve, and the 1.x to 2.0 transition changed core idioms, so much online material is out of date. Lazy-loaded relationships outside an active session raise DetachedInstanceError and cause N+1 query storms if you’re not careful.

 Python Mike Bayer + OSS MIT
Vercel The frontend cloud — git-push deploys and the home of Next.js.
★ standard☁▦
☁ Infra▦ Full-stack
★ standard gentle 2015

A frontend-focused PaaS and the company behind Next.js. Connect a git repo and every push deploys to a global edge network with serverless and edge functions; every branch and pull request gets its own preview URL. Optimized for SSR and SSG frontends.
3 use cases Deploying Next.js, SvelteKit, Astro, or any modern fronte... Show all
  • Deploying Next.js, SvelteKit, Astro, or any modern frontend in seconds.
  • Per-branch preview deployments for reviewing changes.
  • Serverless and edge functions colocated with the frontend.
4 features Git-push deploys with automatic preview URLs per branch/PR. Show all
  • Git-push deploys with automatic preview URLs per branch/PR.
  • Global edge network plus serverless and edge functions.
  • First-class Next.js support (ISR, image optimization, RSC).
  • Built-in analytics, environment variables, and instant rollbacks.

The free Hobby tier is non-commercial — production apps need a paid plan. Bandwidth and serverless-function usage are metered, so high-traffic or heavy edge workloads can get expensive, and you’re somewhat locked into Vercel’s build conventions for the best Next.js features.

 — Vercel Inc. proprietary
Netlify The platform that popularized JAMstack git-push deploys.
★ standard☁▦
☁ Infra▦ Full-stack
★ standard gentle 2014

A frontend deployment platform that pioneered the JAMstack workflow: connect a git repo and each push builds and deploys to a global CDN. It bundles edge functions, serverless functions, form handling, identity, and deploy previews for static sites and SPAs.
3 use cases Static sites and SPAs deployed straight from a git push. Show all
  • Static sites and SPAs deployed straight from a git push.
  • JAMstack apps wanting forms, identity, and functions out of the box.
  • Deploy previews on every pull request.
4 features Git-push builds with deploy previews per branch/PR. Show all
  • Git-push builds with deploy previews per branch/PR.
  • Global CDN with instant cache invalidation and rollbacks.
  • Edge and serverless functions; built-in forms and identity.
  • Netlify CLI and a generous static-hosting free tier.

Build-minute and bandwidth quotas on lower tiers can bite busy sites, and serverless-function cold starts and execution limits apply. Its SSR framework support has historically trailed Vercel’s tight Next.js integration, though adapters close most of the gap.

 — Netlify, Inc. proprietary
Cloudflare Pages Static sites and functions on Cloudflare’s global edge.
● mainstream☁▦
☁ Infra▦ Full-stack
● mainstream gentle 2021

A JAMstack hosting platform that serves static sites and full-stack apps from Cloudflare’s global edge, with dynamic logic running on Cloudflare Workers. It git-deploys like Vercel and Netlify but runs everything on the same vast CDN and edge runtime that fronts a large share of the web.
3 use cases Static sites and SPAs served from a huge global edge netw... Show all
  • Static sites and SPAs served from a huge global edge network.
  • Full-stack apps whose backend runs on Cloudflare Workers.
  • Projects already using Cloudflare DNS, R2, D1, or KV.
4 features Git-push deploys with unlimited preview deployments. Show all
  • Git-push deploys with unlimited preview deployments.
  • Functions powered by Cloudflare Workers at the edge.
  • Tight integration with R2, D1, KV, and Durable Objects.
  • Generous free tier with unmetered static bandwidth.

Functions run on the Workers runtime, not full Node.js — some Node APIs and packages don’t work without the nodejs_compat flag, and there are bundle-size and CPU-time limits per request. Cloudflare also acquired VoidZero (the Vite team) in 2026, tightening its build-tooling story.

 — Cloudflare, Inc. proprietary
GitHub Pages Free static hosting served straight from a GitHub repo.
★ standard☁
☁ Infra
★ standard gentle 2008

Free static-site hosting from GitHub: point it at a repository or branch and it serves the files over a CDN with HTTPS and optional custom domains. It can build Jekyll sites automatically, or you can deploy any prebuilt SSG output via GitHub Actions — this very site runs on it.
3 use cases Project docs, personal blogs, and portfolios with zero ho... Show all
  • Project docs, personal blogs, and portfolios with zero hosting cost.
  • Jekyll sites built automatically from a repo.
  • Any static-site-generator output deployed via GitHub Actions.
4 features Free static hosting with HTTPS and custom-domain support. Show all
  • Free static hosting with HTTPS and custom-domain support.
  • Built-in Jekyll build, or deploy any SSG via Actions.
  • Served over a global CDN straight from a branch or artifact.
  • No servers, no config beyond a repo setting or workflow.

It’s static-only — no server-side code, databases, or serverless functions, so dynamic features need a separate backend. Soft usage limits apply (~1 GB site, ~100 GB/month bandwidth, ~10 builds/hour), and the built-in Jekyll runs a pinned, restricted plugin set — custom plugins need a Actions build instead.

 — GitHub (Microsoft) proprietary
AWS The hyperscale cloud — every infrastructure primitive, à la carte.
★ standard☁▦
☁ Infra▦ Full-stack
★ standard steep 2006

Amazon Web Services — the largest IaaS/PaaS cloud, offering hundreds of building-block services: S3 for storage, EC2 for VMs, Lambda for serverless, CloudFront as a CDN, RDS for databases, and Amplify for frontend hosting. Unmatched breadth and scale, at the cost of real complexity.
3 use cases Large-scale production systems needing fine-grained control. Show all
  • Large-scale production systems needing fine-grained control.
  • Serverless backends (Lambda + API Gateway + DynamoDB).
  • Hosting anything from a static S3 site to a Kubernetes cluster.
4 features Hundreds of services: S3, EC2, Lambda, CloudFront, RDS, D... Show all
  • Hundreds of services: S3, EC2, Lambda, CloudFront, RDS, DynamoDB.
  • Global regions and availability zones for scale and redundancy.
  • Fine-grained IAM permissions and VPC networking.
  • Amplify for git-push frontend + serverless backend hosting.

The breadth is the curse — IAM, VPCs, regions, and the sheer service count make the learning curve the steepest here. Per-second metered billing can surprise you (egress fees, idle resources), so set budgets and alerts. Most teams reach for a higher-level PaaS unless they truly need AWS’s reach.

 — Amazon proprietary
Render A modern Heroku — simple PaaS for web services and databases.
● mainstream☁▦
☁ Infra▦ Full-stack
● mainstream gentle 2019

A developer-friendly PaaS pitched as a modern Heroku: connect a repo and Render builds and runs web services, background workers, cron jobs, static sites, and managed Postgres or Redis. It handles TLS, deploys, and autoscaling so you don’t touch IaaS plumbing.
3 use cases Deploying a backend API + managed Postgres without DevOps... Show all
  • Deploying a backend API + managed Postgres without DevOps overhead.
  • Teams migrating off Heroku wanting a similar git-push workflow.
  • Background workers, cron jobs, and static sites in one place.
4 features Git-push deploys for web services, workers, and static si... Show all
  • Git-push deploys for web services, workers, and static sites.
  • Managed PostgreSQL and Redis with automatic backups.
  • Free TLS, autoscaling, and zero-downtime deploys.
  • Infrastructure-as-code via a render.yaml blueprint.

The free tier spins services down after inactivity, so the first request after an idle period suffers a cold-start delay. It’s simpler but less configurable than raw AWS, and pricing can climb once you scale instances or add managed databases.

 — Render proprietary
Fly.io Run containers and VMs close to your users, worldwide.
● mainstream☁▦
☁ Infra▦ Full-stack
● mainstream moderate 2020

A platform for running full applications — packaged as containers and booted as lightweight Firecracker VMs (Fly Machines) — in regions around the globe, so compute sits close to users. Unlike a static CDN, it runs your actual server processes and databases at the edge.
3 use cases Latency-sensitive apps deployed near users in multiple re... Show all
  • Latency-sensitive apps deployed near users in multiple regions.
  • Running any Dockerized app or stateful service globally.
  • Edge-deployed Postgres or full backend processes (not just functions).
4 features Deploy Docker containers as fast-booting micro-VMs (Fly M... Show all
  • Deploy Docker containers as fast-booting micro-VMs (Fly Machines).
  • Run app instances in many regions for low latency.
  • Persistent volumes and managed Postgres at the edge.
  • Anycast networking and a fly.toml config + flyctl CLI.

Multi-region brings real distributed-systems complexity — data replication, region routing, and consistency are on you. It’s more hands-on than a git-push PaaS, occasional platform reliability hiccups have been reported, and stateful volumes are pinned to a single region per volume.

 — Fly.io, Inc. proprietary
Railway Developer-friendly PaaS with usage-based pricing and instant deploys.
● mainstream☁▦
☁ Infra▦ Full-stack
● mainstream gentle 2020

A polished PaaS built for a smooth developer experience: connect a repo and Railway autodetects the stack, provisions databases, wires up environment variables, and deploys — all billed by actual usage rather than fixed instance tiers. Strong on visual service graphs and one-click templates.
3 use cases Quickly standing up a full app + database for side projec... Show all
  • Quickly standing up a full app + database for side projects or MVPs.
  • Teams wanting usage-based billing instead of fixed dyno tiers.
  • Spinning up Postgres, Redis, or MySQL alongside an app in clicks.
4 features Auto-detected builds (Nixpacks) or your own Dockerfile. Show all
  • Auto-detected builds (Nixpacks) or your own Dockerfile.
  • One-click managed Postgres, MySQL, Redis, and MongoDB.
  • Usage-based pricing metered to actual compute and bandwidth.
  • Visual service graph, env-var sharing, and PR environments.

Usage-based billing is flexible but can make costs hard to predict for always-on services; watch the metered meter on long-running workloads. Railway removed its perpetual free tier (now a trial credit), and as a smaller platform it has less regional reach than the hyperscalers.

 — Railway Corp. proprietary
Firebase Hosting Fast static & SPA hosting in Google’s Firebase suite.
★ standard☁
☁ Infra
★ standard gentle 2014

Google’s static and single-page-app hosting within the Firebase platform: it serves your build over a global CDN with automatic HTTPS and integrates with Cloud Functions or Cloud Run for dynamic routes. It slots naturally beside Firebase Auth, Firestore, and Storage for a batteries-included app backend.
3 use cases Hosting SPAs (React, Angular, Vue) alongside Firebase Aut... Show all
  • Hosting SPAs (React, Angular, Vue) alongside Firebase Auth + Firestore.
  • Static sites needing a CDN, HTTPS, and easy custom domains.
  • Dynamic routes proxied to Cloud Functions or Cloud Run.
4 features Global CDN with automatic HTTPS and atomic deploys/rollba... Show all
  • Global CDN with automatic HTTPS and atomic deploys/rollbacks.
  • Rewrites to Cloud Functions and Cloud Run for dynamic content.
  • Preview channels for sharing pre-release builds.
  • Tight integration with Firebase Auth, Firestore, and Storage.

Hosting itself is static — dynamic logic means wiring up Cloud Functions or Cloud Run, which adds cost and cold starts. You’re tied into Google’s ecosystem, and Spark (free) plan quotas on storage and bandwidth are modest, so busy sites move to the metered Blaze plan.

 — Google proprietary
Heroku The platform that popularized git-push-to-deploy PaaS.
▼ legacy☁
☁ Infra
▼ legacy gentle 2007

The original developer-friendly PaaS — you git push an app and Heroku detects the language via buildpacks, builds a container (“slug”), and runs it on managed “dynos” with add-on databases and queues one click away. It defined the modern deploy workflow but lost ground after Salesforce removed its free tier in 2022.
3 use cases Quickly hosting a small-to-medium web app or API without ... Show all
  • Quickly hosting a small-to-medium web app or API without managing servers.
  • Prototypes and MVPs that need a database and background workers fast.
  • Teams that value a simple deploy story over fine-grained infra control.
4 features Git-push deploys with automatic buildpack detection. Show all
  • Git-push deploys with automatic buildpack detection.
  • Dyno-based process model with one-click add-ons (Postgres, Redis).
  • Review apps and pipelines for staging-to-production promotion.
  • Heroku Postgres and Redis as managed data add-ons.

The free tier is gone (since November 2022), and the cheapest paid dynos sleep or cost real money — it is no longer the budget option it once was. Dynos also have an ephemeral filesystem, so anything written to disk vanishes on restart; use add-ons or external storage for persistence.

 — Salesforce proprietary
DigitalOcean Developer-friendly cloud — simple VMs plus a managed PaaS layer.
● mainstream☁
☁ Infra
● mainstream moderate 2011

A cloud provider that made raw VMs (“Droplets”) cheap and approachable, then layered on managed databases, Kubernetes, object storage (Spaces), and an App Platform PaaS for git-push deploys. It sits between bare IaaS and a fully managed platform, with simpler pricing than the hyperscalers.
3 use cases Spinning up an affordable Linux VM for a side project or ... Show all
  • Spinning up an affordable Linux VM for a side project or small service.
  • Managed Postgres, Kubernetes, or object storage without AWS complexity.
  • App Platform git-push deploys for teams wanting a middle ground.
4 features Droplets — predictable flat-rate Linux VMs. Show all
  • Droplets — predictable flat-rate Linux VMs.
  • Managed Postgres/MySQL/Redis, Kubernetes (DOKS), and Spaces storage.
  • App Platform PaaS for git-push container/static deploys.
  • Flat, transparent pricing and strong tutorial documentation.

A plain Droplet is an unmanaged Linux box — you own OS updates, firewalls, backups, and security hardening yourself. It is cheaper and simpler than AWS but has far fewer managed services, so complex architectures may outgrow it.

 — DigitalOcean proprietary
Deno Deploy Globally distributed edge runtime for Deno apps.
▲ rising☁
☁ Infra
▲ rising gentle 2021

A serverless edge platform from the Deno team that runs JavaScript and TypeScript on V8 isolates in data centres worldwide, with no servers to manage and near-zero cold starts. It deploys straight from a GitHub repo and exposes web-standard APIs plus a built-in KV store.
3 use cases Low-latency edge APIs and functions served close to every... Show all
  • Low-latency edge APIs and functions served close to every user.
  • Deploying Deno or Fresh apps without container or server setup.
  • Lightweight backends that lean on web-standard Request/Response APIs.
4 features V8-isolate edge execution with fast cold starts. Show all
  • V8-isolate edge execution with fast cold starts.
  • Git-integrated deploys straight from GitHub.
  • Built-in Deno KV global database.
  • Web-standard fetch/Request/Response handler model.

Isolates are not full Node servers — long-running processes, raw TCP, and many native Node modules are unavailable, and CPU time per request is capped. Code written for a traditional Node host often needs reworking to fit the edge model.

 — Deno Land proprietary
Microsoft Azure Microsoft’s enterprise cloud — IaaS, PaaS, and everything between.
★ standard☁
☁ Infra
★ standard steep 2010

Microsoft’s hyperscale cloud, offering hundreds of services across compute (VMs, App Service, Functions, AKS), data, AI, and networking. It is the default choice for enterprises invested in the Microsoft stack (Active Directory, .NET, Windows Server), with deep hybrid-cloud and compliance tooling.
3 use cases Enterprises standardized on Microsoft identity, .NET, and... Show all
  • Enterprises standardized on Microsoft identity, .NET, and Windows.
  • Hybrid-cloud setups bridging on-prem data centres to the cloud.
  • Regulated industries needing broad compliance certifications.
4 features Compute spanning VMs, App Service PaaS, Functions, and AK... Show all
  • Compute spanning VMs, App Service PaaS, Functions, and AKS (Kubernetes).
  • Deep Entra ID (Active Directory) and .NET integration.
  • Managed databases (SQL, Cosmos DB) and a large AI/ML catalogue.
  • Strong hybrid-cloud (Azure Arc) and enterprise compliance.

The breadth is overwhelming and the portal/service naming shifts often, so discoverability is poor for newcomers. Cost management is a discipline of its own — idle resources and egress charges add up fast, and the pricing calculator is essential before committing.

 — Microsoft proprietary
Google Cloud Google’s cloud — strong on containers, data, and serverless.
★ standard☁
☁ Infra
★ standard steep 2011

Google Cloud Platform (GCP) is Google’s hyperscale cloud, known for Kubernetes (which it created), the serverless Cloud Run container platform, and best-in-class data and analytics tooling (BigQuery). It runs on the same global network that serves Google Search, with strong AI/ML services on top.
3 use cases Container-first workloads on GKE (Kubernetes) or serverle... Show all
  • Container-first workloads on GKE (Kubernetes) or serverless Cloud Run.
  • Large-scale analytics and data warehousing with BigQuery.
  • AI/ML pipelines leveraging Vertex AI and TPUs.
4 features GKE — the original managed Kubernetes — plus serverless C... Show all
  • GKE — the original managed Kubernetes — plus serverless Cloud Run.
  • BigQuery for petabyte-scale analytics.
  • Global network and per-second billing on many resources.
  • Vertex AI and a deep ML/TPU catalogue.

GCP has fewer services than AWS and a smaller third-party ecosystem, and Google’s habit of deprecating products worries some teams. IAM and project organization are powerful but confusing early on, and egress/data-transfer costs surprise the unprepared.

 — Google proprietary
Docker Package an app and its dependencies into a portable container.
★ standard🔧☁
🔧 Tooling☁ Infra
★ standard moderate 2013

The tool that made Linux containers mainstream — bundle your app, runtime, and dependencies into an image that runs identically on a laptop, CI/CD runner, or production server. A Dockerfile describes the build, the image is the artifact, and a container is a running instance. Docker Compose orchestrates multi-container local stacks.
3 use cases Reproducible dev environments — "works on my machine" bec... Show all
  • Reproducible dev environments — “works on my machine” becomes “works in the image”.
  • Packaging an app for deployment to any container host or orchestrator.
  • Spinning up databases and services locally via Compose.
4 features Dockerfile build → immutable, layered images. Show all
  • Dockerfile build → immutable, layered images.
  • Compose for multi-container local stacks.
  • OCI image format runs on any compliant runtime.
  • Huge public registry (Docker Hub) of base images.

Layer ordering makes or breaks build caching — copy package.json and install before copying source, or every code change reinstalls everything. Also note the licensing split: the Docker Engine/CLI are Apache-2.0, but Docker Desktop is proprietary and requires a paid subscription for larger companies (the daemon itself stays free).

 Go Docker, Inc. + OSS community Apache-2.0
Kubernetes Orchestrate containers across a cluster, declaratively.
★ standard☁
☁ Infra
★ standard steep 2014

The de-facto container orchestrator — you declare the desired state ("run 3 replicas of this image, expose it on this port") in YAML and the control loop continuously reconciles reality toward it: scheduling pods, restarting crashed ones, rolling out updates, and load-balancing. Born at Google, now stewarded by the CNCF.
3 use cases Running microservices at scale with self-healing and auto... Show all
  • Running microservices at scale with self-healing and autoscaling.
  • Multi-environment deploys with declarative, version-controlled config.
  • Workloads that outgrow a single host or a simple PaaS.
4 features Declarative desired-state reconciliation. Show all
  • Declarative desired-state reconciliation.
  • Self-healing, rolling updates, and horizontal autoscaling.
  • Service discovery and built-in load balancing.
  • Extensible via CRDs, operators, and Helm charts.

The steepest curve in this batch — pods, services, ingress, RBAC, and YAML sprawl are a lot before you ship anything. Don’t reach for it too early: a single container on a PaaS or VM is far simpler until you genuinely need multi-node scaling and self-healing.

 Go CNCF (originally Google) + OSS community Apache-2.0
GitHub Actions CI/CD baked into your GitHub repo, triggered by events.
★ standard🔧☁
🔧 Tooling☁ Infra
★ standard moderate 2019

GitHub’s native CI/CD — define workflows as YAML files in .github/workflows/ that run on repo events (push, pull request, release, schedule, manual dispatch). Jobs run on GitHub-hosted or self-hosted runners, and a large marketplace of reusable actions covers most build/test/deploy steps. This very site deploys through it.
3 use cases Building, testing, and linting on every pull request. Show all
  • Building, testing, and linting on every pull request.
  • Deploying to GitHub Pages, cloud hosts, or a registry on merge.
  • Scheduled jobs (cron) and manual workflow_dispatch runs.
4 features YAML workflows triggered by repo events. Show all
  • YAML workflows triggered by repo events.
  • Marketplace of reusable, versioned actions.
  • GitHub-hosted and self-hosted runners.
  • Matrix builds, secrets, environments, and concurrency groups.

It’s a proprietary platform locked to GitHub — workflows aren’t portable to other hosts. Pin third-party actions to a full commit SHA (not a mutable tag) as a supply-chain safeguard, and watch minute-based billing on private repos with heavy matrix builds.

 YAML (workflows); runners in Go/TypeScript GitHub (Microsoft) proprietary
GitLab CI/CD Pipelines defined in .gitlab-ci.yml, built into the platform.
● mainstream🔧☁
🔧 Tooling☁ Infra
● mainstream moderate 2015

GitLab’s integrated CI/CD — a single .gitlab-ci.yml at the repo root defines stages and jobs that run on GitLab Runners. Tightly woven into the rest of the GitLab DevOps platform (issues, registry, environments, review apps), so the pipeline, the code, and the deploy all live in one place.
3 use cases End-to-end DevOps on a single self-hostable platform. Show all
  • End-to-end DevOps on a single self-hostable platform.
  • Pipelines with stages, manual gates, and environment deploys.
  • Teams wanting CI, registry, and issue tracking in one tool.
4 features Single .gitlab-ci.yml with stages and jobs. Show all
  • Single .gitlab-ci.yml with stages and jobs.
  • Self-hosted or GitLab-hosted runners.
  • Built-in container registry, environments, and review apps.
  • Includes, templates, and parent-child pipelines for reuse.

Open-core: the MIT-licensed Community Edition covers the basics, but a lot of CI/CD niceties (advanced security scanning, multiple approvers, some compliance controls) sit behind the proprietary paid tiers. Self-managed runners need real maintenance, and pipeline YAML grows complex fast on big monorepos.

 Ruby/Go (platform); YAML (pipelines) GitLab Inc. open-core (MIT CE + proprietary)
Terraform Provision cloud infrastructure as declarative, versioned code.
★ standard🔧☁
🔧 Tooling☁ Infra
★ standard moderate 2014

The dominant infrastructure-as-code tool — declare cloud resources (servers, networks, IaaS buckets, DNS, databases) in HCL, and Terraform computes a plan and applies it, tracking what exists in a state file. Provider plugins cover AWS, GCP, Azure, Cloudflare, and hundreds more.
3 use cases Reproducible, reviewable provisioning of cloud infrastruc... Show all
  • Reproducible, reviewable provisioning of cloud infrastructure.
  • Multi-environment (dev/staging/prod) parity from one codebase.
  • Managing DNS, networking, and managed services as code.
4 features Declarative HCL with plan/apply diffing. Show all
  • Declarative HCL with plan/apply diffing.
  • State file tracks managed resources.
  • Hundreds of providers via a plugin registry.
  • Modules for reusable, composable infrastructure.

No longer open source: HashiCorp relicensed Terraform from MPL-2.0 to the Business Source License (BSL 1.1, source-available) in August 2023, which spawned the community OpenTofu fork (still MPL-2.0) — choose deliberately. Operationally, the state file is sensitive and must be stored remotely with locking, or concurrent applies corrupt it. (HashiCorp was acquired by IBM in 2024.)

 Go HashiCorp (IBM) BSL 1.1
Ansible Agentless configuration management via YAML playbooks.
● mainstream🔧☁
🔧 Tooling☁ Infra
● mainstream moderate 2012

An agentless automation tool — describe the desired state of your servers in YAML "playbooks" and Ansible connects over plain SSH to apply them, no agent to install on targets. Idempotent modules mean re-running a playbook only changes what’s drifted, making it a staple for config management, app deployment, and orchestration.
3 use cases Configuring and patching fleets of servers consistently. Show all
  • Configuring and patching fleets of servers consistently.
  • App deployment and release orchestration over SSH.
  • One-off ad-hoc commands across many hosts.
4 features Agentless — runs over SSH, nothing to install on targets. Show all
  • Agentless — runs over SSH, nothing to install on targets.
  • Idempotent modules; re-runs only fix drift.
  • YAML playbooks and reusable roles.
  • Ansible Galaxy registry of community roles/collections.

Great for configuration, awkward for provisioning — pair it with Terraform rather than fighting to create cloud infrastructure from playbooks. Large playbooks run slowly (SSH per task, per host), and "idempotent" only holds if you use proper modules instead of raw shell/command tasks.

 Python Red Hat (IBM) + OSS community GPL-3.0
Nginx High-performance web server, reverse proxy, and load balancer.
★ standard☁
☁ Infra
★ standard moderate 2004

An event-driven web server renowned for serving static files and acting as a reverse proxy / load balancer in front of application servers. Its low memory footprint under high concurrency made it the standard front door for web apps — terminating TLS, routing requests, caching, and fronting upstreams (it also powers many a CDN edge).
3 use cases Serving static assets and SPA builds efficiently. Show all
  • Serving static assets and SPA builds efficiently.
  • Reverse-proxying and load-balancing app servers (Node, PHP-FPM, etc.).
  • TLS termination, caching, and rate limiting at the edge.
4 features Event-driven architecture — high concurrency, low memory. Show all
  • Event-driven architecture — high concurrency, low memory.
  • Reverse proxy, load balancer, and TLS terminator.
  • Static file serving and response caching.
  • Config-driven routing with server / location blocks.

The config language is its own DSL with sharp edges — location matching precedence, trailing-slash behavior on proxy_pass, and try_files ordering trip up newcomers. Reload (nginx -s reload) instead of restart to apply changes without dropping connections. F5 owns the project today.

 C F5, Inc. + OSS community BSD-2-Clause
Jenkins The veteran self-hosted CI server, extensible to a fault.
▼ legacy🔧☁
🔧 Tooling☁ Infra
▼ legacy steep 2011

The original open-source automation server — a self-hosted CI/CD engine driven by a vast plugin ecosystem and "Pipeline as code" via a Jenkinsfile (Groovy). Predates the cloud-native runners and remains entrenched in enterprises, though newer teams usually reach for GitHub Actions or GitLab CI instead.
3 use cases Self-hosted CI/CD where data must stay on-prem. Show all
  • Self-hosted CI/CD where data must stay on-prem.
  • Legacy enterprise pipelines already built on Jenkins.
  • Highly customized builds needing a specific plugin.
4 features Pipeline as code via a Groovy Jenkinsfile. Show all
  • Pipeline as code via a Groovy Jenkinsfile.
  • Thousands of plugins for almost any integration.
  • Distributed builds across controller + agents.
  • Fully self-hosted — no vendor lock-in.

Powerful but high-maintenance — you own the server, the agents, the upgrades, and a sprawling plugin set whose interdependencies and CVEs need constant tending. The plugin-heavy model that was once its strength now reads as legacy next to managed cloud CI; pick it deliberately, usually for on-prem constraints.

 Java Jenkins community (CDF) MIT
Podman Daemonless, rootless drop-in replacement for the Docker CLI.
● mainstream☁🔧
☁ Infra🔧 Tooling
● mainstream moderate 2018

A container engine from Red Hat that runs and builds OCI containers without a central daemon and, by default, without root. Its CLI is command-compatible with Docker (alias docker=podman usually just works), and “pods” group containers the way Kubernetes does.
3 use cases Rootless, daemonless container workflows on Linux servers... Show all
  • Rootless, daemonless container workflows on Linux servers and CI.
  • Drop-in Docker CLI replacement where a root daemon is a security concern.
  • Generating Kubernetes manifests from local pods for a smooth handoff.
4 features Daemonless architecture — no long-running root service. Show all
  • Daemonless architecture — no long-running root service.
  • Rootless containers by default for better isolation.
  • Docker-compatible CLI and Dockerfile/OCI support.
  • Pods and podman generate kube for a Kubernetes-aligned model.

Docker Compose support is indirect — you need podman-compose or the Podman socket emulation, and some Compose features lag. Networking and volume defaults differ subtly from Docker, so a docker-compose.yml may not behave identically without tweaks.

 Go Red Hat + OSS community Apache-2.0
Helm The package manager for Kubernetes.
● mainstream☁🔧
☁ Infra🔧 Tooling
● mainstream moderate 2016

A package manager for Kubernetes that bundles a set of related manifests into a versioned, parameterized “chart” you can install, upgrade, and roll back as a unit. Charts use Go templates so one chart deploys to dev, staging, and prod with different values.yaml overrides.
3 use cases Installing off-the-shelf software (Prometheus, ingress, d... Show all
  • Installing off-the-shelf software (Prometheus, ingress, databases) onto a cluster.
  • Packaging your own app’s manifests as a reusable, versioned release.
  • Templating one manifest set across multiple environments via values files.
4 features Charts — versioned, parameterized bundles of Kubernetes m... Show all
  • Charts — versioned, parameterized bundles of Kubernetes manifests.
  • Go-template values for per-environment configuration.
  • Atomic install/upgrade/rollback of a whole release.
  • Public and private chart repositories (OCI registries supported).

Go templating over YAML is fiddly — whitespace and indentation bugs are common, and the templates obscure the final manifests until you run helm template. Debugging a broken release often means rendering the chart locally to see what Kubernetes actually receives.

 Go CNCF Apache-2.0
CircleCI Cloud-native CI/CD with fast, configurable pipelines.
● mainstream☁🔧
☁ Infra🔧 Tooling
● mainstream moderate 2011

A managed CI/CD platform that runs pipelines defined in a .circleci/config.yml, with reusable “orbs” packaging common steps and fine-grained control over Docker/VM executors, parallelism, and caching. It predates GitHub Actions and remains popular for its speed and flexible execution environments.
3 use cases Running test and deploy pipelines for repos on GitHub or ... Show all
  • Running test and deploy pipelines for repos on GitHub or Bitbucket.
  • Parallelized, matrix builds that need fast feedback at scale.
  • Teams wanting reusable orbs instead of hand-rolling every step.
4 features Config-as-code pipelines in .circleci/config.yml. Show all
  • Config-as-code pipelines in .circleci/config.yml.
  • Orbs — shareable, versioned packages of pipeline config.
  • Docker, machine, and macOS executors with test parallelism.
  • Dependency and layer caching to speed repeat builds.

For repos already on GitHub, GitHub Actions is now the default and CircleCI adds a second vendor to manage. The free tier’s monthly credit caps usage, and a 2023 security incident (rotate-all-secrets) made teams wary of storing sensitive credentials in any single CI provider.

 — CircleCI proprietary
Caddy The web server with automatic HTTPS out of the box.
● mainstream☁
☁ Infra
● mainstream gentle 2015

A modern HTTP server and reverse proxy written in Go whose headline feature is automatic, zero-config TLS — it obtains and renews Let’s Encrypt certificates by itself. Its Caddyfile config is far simpler than Nginx’s, making it a popular front door for small-to-medium services.
3 use cases Fronting an app with HTTPS without manually managing cert... Show all
  • Fronting an app with HTTPS without manually managing certificates.
  • Simple reverse proxying and static file serving with minimal config.
  • Quick self-hosted deployments where Nginx config feels heavy.
4 features Automatic HTTPS via Let's Encrypt — certs issued and rene... Show all
  • Automatic HTTPS via Let’s Encrypt — certs issued and renewed for you.
  • Concise Caddyfile config (often a few lines).
  • Built-in reverse proxy, static server, and HTTP/2 + HTTP/3.
  • Single static Go binary with no dependencies.

Automatic HTTPS needs the domain’s DNS pointed at the server and ports 80/443 reachable, or the ACME challenge fails — a common first-run surprise behind firewalls. At very high scale or for exotic tuning, Nginx still has more battle-tested knobs and third-party modules.

 Go Stack Holdings + OSS community Apache-2.0
Pulumi Infrastructure as code in real programming languages.
▲ rising☁🔧
☁ Infra🔧 Tooling
▲ rising moderate 2018

An infrastructure-as-code tool that lets you define cloud resources in TypeScript, Python, Go, or C# instead of a domain-specific language. It diffs desired state against real infrastructure and applies changes, with secrets, stacks, and a state backend built in — Terraform’s model with general-purpose languages.
3 use cases Defining cloud infra in a language your team already knows. Show all
  • Defining cloud infra in a language your team already knows.
  • Reusing loops, functions, and packages to DRY up infrastructure code.
  • Teams that want IaC unit-testable with normal test frameworks.
4 features IaC in TypeScript/Python/Go/C# — real loops, functions, a... Show all
  • IaC in TypeScript/Python/Go/C# — real loops, functions, and types.
  • Plan/preview then apply with state-diffing like Terraform.
  • Managed or self-hosted state backend with built-in secret encryption.
  • Reuses each cloud’s official provider SDKs.

Real languages cut both ways — you can write genuinely buggy infrastructure (loops, conditionals, side effects) in ways an HCL declaration cannot. The ecosystem and answer-on-Stack-Overflow base is smaller than Terraform’s, and the hosted state backend is a paid service unless you self-host.

 TypeScript/Go Pulumi Corp Apache-2.0
Git The distributed version control system everyone uses.
★ standard🔧
🔧 Tooling
★ standard moderate 2005

The distributed version-control standard — every clone is a full repository with complete history, so branching, committing, and diffing are local and fast. Created by Linus Torvalds to manage Linux kernel development, it’s now the substrate beneath essentially all modern code hosting and CI/CD.
3 use cases Tracking history and collaborating on virtually any codeb... Show all
  • Tracking history and collaborating on virtually any codebase.
  • Branch-per-feature workflows and pull/merge requests.
  • The foundation every hosting platform and CI pipeline builds on.
4 features Distributed — every clone has the full history. Show all
  • Distributed — every clone has the full history.
  • Cheap, fast local branching and merging.
  • Content-addressed, integrity-checked object store (SHA hashes).
  • Staging area for crafting precise commits.

The mental model — staging area, detached HEAD, the difference between merge, rebase, and reset — is genuinely hard, and the CLI’s terminology is famously inconsistent. Force-pushing a shared branch (push --force) rewrites history others depend on; prefer --force-with-lease and never rewrite main.

 C Git community (Junio Hamano, maintainer) GPL-2.0
GitHub The dominant code-hosting and collaboration platform.
★ standard🔧☁
🔧 Tooling☁ Infra
★ standard gentle 2008

The largest code-hosting platform — Git repositories plus the social and collaboration layer on top: pull requests, code review, issues, Actions CI/CD, Packages, Pages, and now Copilot. Its network effects make it the default home for open source and a huge share of private development. (Microsoft owns it.)
3 use cases Hosting public and private Git repos with code review. Show all
  • Hosting public and private Git repos with code review.
  • Open-source collaboration via forks and pull requests.
  • Issues, project boards, Actions CI/CD, and Pages hosting.
4 features Pull requests with inline review and required checks. Show all
  • Pull requests with inline review and required checks.
  • Issues, Discussions, and project boards.
  • Built-in CI/CD (Actions), Packages, and Pages.
  • The largest open-source community and network effect.

It’s a proprietary, centralized service — convenient, but it means trusting a single vendor with your code, CI, and issues. Free private repos are generous, yet advanced security and admin features sit in paid tiers, and the network effect creates real lock-in around issues, PRs, and Actions that aren’t portable.

 Ruby / Go (platform) GitHub (Microsoft) proprietary
GitLab An all-in-one DevOps platform with built-in CI/CD.
● mainstream🔧☁
🔧 Tooling☁ Infra
● mainstream moderate 2011

A single DevOps platform spanning the whole lifecycle — Git hosting, code review (merge requests), issues, a container registry, security scanning, and tightly integrated CI/CD. Its big differentiator is being self-hostable: the open-core Community Edition can run entirely on your own infrastructure.
3 use cases Self-hosted Git + CI/CD where data sovereignty matters. Show all
  • Self-hosted Git + CI/CD where data sovereignty matters.
  • End-to-end DevOps (plan → code → build → deploy) in one tool.
  • Teams wanting an integrated registry and security scanning.
4 features Merge requests with built-in review and CI gates. Show all
  • Merge requests with built-in review and CI gates.
  • Integrated CI/CD (.gitlab-ci.yml) and container registry.
  • Self-hostable open-core Community Edition.
  • Issues, epics, and DevOps lifecycle tooling in one place.

Open-core: the MIT Community Edition is real, but many enterprise features (advanced security, compliance, multiple MR approvers) require the paid tiers. Self-hosting GitLab is resource-hungry and operationally heavy — budget for the RAM and the upgrade cadence before committing.

 Ruby / Go GitLab Inc. + OSS community open-core (MIT CE + proprietary)
Bitbucket Atlassian’s Git hosting, tight with Jira.
● mainstream🔧☁
🔧 Tooling☁ Infra
● mainstream gentle 2008

Atlassian’s code-hosting platform — Git repositories with pull requests and Bitbucket Pipelines CI/CD, but its real draw is deep integration with the rest of the Atlassian suite (Jira, Confluence, Trello). Most common in organizations already standardized on Jira.
3 use cases Teams already on Jira/Confluence wanting native integration. Show all
  • Teams already on Jira/Confluence wanting native integration.
  • Private Git hosting with built-in Pipelines CI/CD.
  • Enterprise Atlassian shops standardizing their toolchain.
4 features Native Jira and Confluence integration. Show all
  • Native Jira and Confluence integration.
  • Pull requests with inline code review.
  • Bitbucket Pipelines for in-platform CI/CD.
  • Cloud and self-managed (Data Center) options.

It’s proprietary and most compelling only if you’re already in the Atlassian ecosystem — its open-source community is far smaller than GitHub’s. Atlassian also retired Mercurial support in 2020, so Bitbucket is Git-only now, and its market momentum has cooled relative to GitHub and GitLab.

 Java / proprietary Atlassian proprietary
GitHub CLI Drive GitHub — PRs, issues, repos — from the terminal.
● mainstream🔧
🔧 Tooling
● mainstream gentle 2020

The official command-line tool (gh) for GitHub — manage pull requests, issues, releases, repositories, and Actions runs without leaving the terminal. It wraps the GitHub API with ergonomic commands and supports scripting and an extension system, making it a staple in automation and CI scripts (this site’s deploy tooling uses it).
3 use cases Opening, reviewing, and merging PRs from the terminal. Show all
  • Opening, reviewing, and merging PRs from the terminal.
  • Scripting GitHub workflows in CI (creating PRs, releases).
  • Cloning, forking, and managing repos without the web UI.
4 features PR, issue, release, and repo management from the shell. Show all
  • PR, issue, release, and repo management from the shell.
  • Authenticated wrapper over the GitHub API (gh api).
  • Extension system for custom commands.
  • Scriptable — ideal inside Actions and automation.

It’s GitHub-only — gh doesn’t talk to GitLab or Bitbucket (use glab for GitLab). In CI it needs an authenticated token with the right scopes, and the default GITHUB_TOKEN sometimes lacks permissions (e.g. creating PRs that trigger further workflows), so reach for a PAT when automation gets ambitious.

 Go GitHub (Microsoft) MIT
Mercurial A distributed VCS that Git largely eclipsed.
▼ legacy🔧
🔧 Tooling
▼ legacy moderate 2005

A distributed version-control system born the same year as Git, with a reputation for a cleaner, more consistent command set (hg). It powered major projects (Mozilla, parts of Facebook) and still survives at some large shops, but Git’s network effect — especially via GitHub — left it a niche choice today.
3 use cases Maintaining legacy repositories already on Mercurial. Show all
  • Maintaining legacy repositories already on Mercurial.
  • Teams that prefer its simpler, more uniform CLI to Git’s.
  • Very large monorepos where its scaling extensions shine.
4 features Distributed model with full local history (like Git). Show all
  • Distributed model with full local history (like Git).
  • More consistent, approachable command set than Git.
  • Extensible via a Python plugin system.
  • Scales to very large repos with extensions (e.g. at Meta).

The ecosystem has shrunk dramatically — GitHub dropped Mercurial support and Bitbucket removed it entirely in 2020, so hosting and tooling options are thin. For new projects, Git is the pragmatic default; pick hg only for an existing Mercurial codebase or a deliberate preference.

 Python Mercurial community GPL-2.0
Jujutsu A Git-compatible VCS that rethinks the working copy and history.
▲ rising🔧
🔧 Tooling
▲ rising moderate 2023

A version-control system (jj) that uses Git repositories as a storage backend but replaces Git’s model: the working copy is itself a commit, there is no staging area, and conflicts are recorded in commits rather than blocking you. You keep your existing GitHub remotes while getting effortless history rewriting and an automatic operation log for undo.
3 use cases Power users who frequently rewrite, reorder, and split co... Show all
  • Power users who frequently rewrite, reorder, and split commits.
  • Working against existing Git/GitHub repos with a cleaner mental model.
  • Recovering from mistakes via the undo-everything operation log.
4 features Working copy is a commit — no separate staging area. Show all
  • Working copy is a commit — no separate staging area.
  • First-class conflicts that don’t halt your workflow.
  • Operation log makes virtually every action undoable.
  • Git-compatible backend — push/pull to existing Git remotes.

The mental model is genuinely different — “no staging area” and “the working copy is a commit” confuse people coming straight from Git muscle memory. It is also young and pre-1.0, so commands and behaviour can still shift between releases.

 Rust Google + OSS community Apache-2.0
Gitea Lightweight, self-hosted Git service — a GitHub you run yourself.
● mainstream☁🔧
☁ Infra🔧 Tooling
● mainstream moderate 2016

A self-hosted Git platform written in Go that ships as a single binary and provides repositories, pull requests, issues, a built-in CI/CD runner (Gitea Actions, GitHub-Actions-compatible), and a package registry. It is a lightweight, privacy-friendly alternative to hosting on GitHub or running a heavy GitLab instance.
3 use cases Self-hosting private repos for full control over code and... Show all
  • Self-hosting private repos for full control over code and data.
  • Small teams or homelabs wanting GitHub-like features on cheap hardware.
  • Air-gapped or compliance-restricted environments that can’t use SaaS.
4 features Single Go binary — trivial to install and update. Show all
  • Single Go binary — trivial to install and update.
  • Pull requests, issues, wikis, and a package registry.
  • Gitea Actions — GitHub-Actions-compatible built-in CI/CD.
  • Low resource footprint compared with GitLab.

Self-hosting means you own backups, upgrades, uptime, and security patching — there is no managed SLA. The ecosystem of integrations and third-party apps is far smaller than GitHub’s, and a 2022 governance dispute spawned the Forgejo fork, so weigh which project you want to follow.

 Go Gitea + OSS community MIT
Husky Modern, fast Git hooks for JavaScript projects.
● mainstream🔧
🔧 Tooling
● mainstream gentle 2014

A tiny tool that makes Git hooks easy to share across a team by storing them in the repo and installing them automatically. It is most often used to run linting, formatting, and tests on pre-commit or to validate messages on commit-msg, so bad code never reaches a commit.
3 use cases Running lint-staged + Prettier on staged files before eac... Show all
  • Running lint-staged + Prettier on staged files before each commit.
  • Enforcing Conventional Commit messages via a commit-msg hook.
  • Blocking pushes when tests or type-checks fail.
4 features Shareable hooks committed to the repo, auto-installed via... Show all
  • Shareable hooks committed to the repo, auto-installed via prepare script.
  • Works with any hook (pre-commit, commit-msg, pre-push).
  • Pairs with lint-staged to only check changed files.
  • Zero-dependency, fast shell hooks in v9+.

Hooks run only on machines where Husky actually installed them, and any contributor can bypass them with git commit --no-verify — so they are a convenience, not a security boundary. Real enforcement still belongs in CI. The v9 rewrite also changed the install command and hook format from older tutorials.

 JavaScript typicode + OSS community MIT
Changesets Versioning and changelogs built for monorepos.
● mainstream🔧
🔧 Tooling
● mainstream gentle 2019

A tool for managing versions and changelogs, especially in a monorepo of many packages. Contributors add a small “changeset” markdown file describing the change and its SemVer bump; on release it consumes them to version the right packages, write changelogs, and publish to npm.
3 use cases Coordinating SemVer bumps across many packages in a monor... Show all
  • Coordinating SemVer bumps across many packages in a monorepo.
  • Auto-generating changelogs from per-PR changeset files.
  • Automating npm publishes via the Changesets GitHub Action.
4 features Per-change markdown files capturing intent and bump type. Show all
  • Per-change markdown files capturing intent and bump type.
  • Resolves inter-package dependency bumps automatically.
  • Generates changelogs and a release PR.
  • GitHub Action that opens a ‘Version Packages’ PR and publishes on merge.

It relies on discipline — if contributors forget to add a changeset, a change ships with no version bump or changelog entry (enforce it with a CI check). It is also npm-publish-oriented, so non-JS or non-published packages get less out of it.

 TypeScript Atlassian + OSS community MIT
Vitest The Vite-native test runner — Jest’s API, a fraction of the wait.
● mainstream🔧
🔧 Tooling
● mainstream gentle 2021

A blazing-fast unit-test framework built on top of Vite, so it reuses your app’s existing config, transforms, and ESM handling instead of duplicating them. The API is intentionally Jest-compatible (describe, it, expect), so most Jest suites migrate with little more than a config swap — but you get instant HMR-style watch mode and native TypeScript out of the box.
3 use cases Unit and component tests in any Vite-based project (React... Show all
  • Unit and component tests in any Vite-based project (React, Vue, Svelte, Solid).
  • Fast watch-mode TDD with instant re-runs on save.
  • Migrating a slow Jest suite to a faster, ESM-native runner.
4 features Shares the project's Vite config — no separate transform ... Show all
  • Shares the project’s Vite config — no separate transform pipeline.
  • Jest-compatible API and assertions for easy migration.
  • Native ESM + TypeScript, no Babel transpile step required.
  • Watch mode with smart re-runs, plus a browser-mode for real-DOM tests.

It’s Jest-compatible, not Jest — globals are off by default (enable globals: true or import from vitest), and module mocking (vi.mock) hoists differently than Jest’s jest.mock. Suites leaning on Jest internals or exotic transforms can need real porting work.

 TypeScript Vitest team (VoidZero, now Cloudflare) MIT
Jest The long-reigning batteries-included JS test framework.
★ standard🔧
🔧 Tooling
★ standard gentle 2014

The framework that made testing JavaScript pleasant — a zero-config runner with built-in assertions, mocking, snapshot testing, and parallel execution all in one package. For years it was the default for React and most of the Node ecosystem; it now uses a Babel transpile step to run modern syntax, which is part of why ESM-native runners feel faster.
3 use cases Unit and integration tests for Node and React codebases. Show all
  • Unit and integration tests for Node and React codebases.
  • Snapshot testing of serialized output and component trees.
  • Mature projects already standardized on the Jest API.
4 features All-in-one: runner, assertions, mocks, and snapshots. Show all
  • All-in-one: runner, assertions, mocks, and snapshots.
  • Parallel test execution across worker processes.
  • Rich snapshot and inline-snapshot testing.
  • Huge ecosystem of presets and matchers.

ESM support is still a sore spot — Jest historically assumed CJS and needs Babel or experimental flags to run native modules, and its global JSDOM environment is slower to spin up than Vite-based runners. Many new Vite projects pick Vitest instead.

 JavaScript OpenJS Foundation (originally Meta) MIT
Playwright Cross-browser end-to-end testing that actually stays green.
● mainstream🔧
🔧 Tooling
● mainstream moderate 2020

Microsoft’s browser automation and end-to-end testing framework that drives Chromium, Firefox, and WebKit through one API. Auto-waiting on elements, network interception, and test isolation per browser context kill most of the flakiness that plagued older E2E tools, and a code generator + trace viewer make writing and debugging tests fast.
3 use cases End-to-end testing of web apps across all three browser e... Show all
  • End-to-end testing of web apps across all three browser engines.
  • Cross-browser regression and visual testing in CI.
  • Scripted browser automation and scraping.
4 features One API across Chromium, Firefox, and WebKit. Show all
  • One API across Chromium, Firefox, and WebKit.
  • Auto-waiting and web-first assertions reduce flaky tests.
  • Codegen recorder + trace viewer for debugging.
  • Parallel execution with isolated browser contexts.

The browser binaries are a heavyweight install (npx playwright install) and CI images balloon accordingly. And like all E2E testing it’s slower and more brittle than unit tests — keep the E2E layer thin and push logic coverage down into unit tests.

 TypeScript Microsoft + OSS community Apache-2.0
Cypress End-to-end testing with a developer experience people love.
● mainstream🔧
🔧 Tooling
● mainstream gentle 2017

A browser E2E testing tool famous for its developer experience — tests run inside a live browser with a time-travel UI that lets you step through every command and see the app at each point. It auto-waits and retries assertions, and bundles its own runner, assertion library, and dashboard.
3 use cases End-to-end and integration testing with interactive debug... Show all
  • End-to-end and integration testing with interactive debugging.
  • Component testing for React, Vue, and Angular in a real browser.
  • Teams that value a polished test-authoring experience.
4 features Time-travel debugging — snapshots of every command step. Show all
  • Time-travel debugging — snapshots of every command step.
  • Automatic waiting and retry-ability on assertions.
  • Built-in test runner, assertions, and mocking.
  • Component-testing mode alongside full E2E.

Historically single-browser (Chromium-family) and same-origin bound — its architecture runs inside the browser, which limits multi-tab and cross-origin flows that Playwright handles natively. Many teams that need true cross-browser coverage have shifted to Playwright.

 JavaScript Cypress.io + OSS community MIT
Testing Library Test your UI the way users actually use it.
★ standard🔧
🔧 Tooling
★ standard gentle 2018

A family of lightweight DOM-testing utilities (React Testing Library, Vue Testing Library, and friends) built on one guiding principle: query the DOM by what a user sees — roles, labels, text — not by implementation details like CSS classes or component internals. It’s not a runner; it plugs into Vitest or Jest.
3 use cases Accessible, user-centric component tests for React/Vue/Sv... Show all
  • Accessible, user-centric component tests for React/Vue/Svelte.
  • Avoiding brittle tests coupled to internal markup or class names.
  • Encouraging accessibility-friendly markup via role-based queries.
4 features Queries by role, label, and text — not by CSS selectors. Show all
  • Queries by role, label, and text — not by CSS selectors.
  • Encourages accessible markup as a side-effect.
  • Runner-agnostic — works with Vitest or Jest.
  • user-event companion library for realistic interactions.

It’s a query layer, not a test runner — you still need Vitest or Jest plus JSDOM underneath. The philosophy bites if you reach for container.querySelector or test internal state; the library deliberately makes implementation-detail testing awkward.

 JavaScript Testing Library team + OSS community MIT
ESLint The pluggable linter that keeps JS/TS honest.
★ standard🔧
🔧 Tooling
★ standard moderate 2013

The de-facto standard linter for JavaScript and TypeScript — it statically analyzes code to catch bugs (unused vars, unreachable code, bad API usage) and enforce style and best-practice rules. Everything is a plugin, so frameworks ship their own rule sets; the modern flat-config format (eslint.config.js) is now the default.
3 use cases Catching bugs and enforcing conventions across a JS/TS co... Show all
  • Catching bugs and enforcing conventions across a JS/TS codebase.
  • Framework-specific rules (React hooks, import order, a11y).
  • Pre-commit and CI gates that block bad patterns from merging.
4 features Pluggable rule architecture with thousands of community r... Show all
  • Pluggable rule architecture with thousands of community rules.
  • Flat config (eslint.config.js) is the modern default.
  • Autofix for many rules (--fix).
  • TypeScript support via typescript-eslint.

The flat-config migration (ESLint 9) broke a lot of older .eslintrc setups and plugins — config examples online are split between the two formats. Don’t make ESLint enforce formatting (indentation, quotes); hand that to Prettier and let ESLint focus on code-quality rules.

 JavaScript OpenJS Foundation + OSS community MIT
Prettier Opinionated formatting that ends the whitespace wars.
★ standard🔧
🔧 Tooling
★ standard gentle 2017

An opinionated code formatter that reprints your code from its AST to a single consistent style — it ignores how you typed it and enforces uniform quotes, spacing, and line-wrapping. By design it has very few options, so teams stop arguing about style and just run it on save and in CI.
3 use cases Auto-formatting JS/TS/CSS/HTML/Markdown to a single house... Show all
  • Auto-formatting JS/TS/CSS/HTML/Markdown to a single house style.
  • Eliminating style debates in code review entirely.
  • Format-on-save in the editor plus a CI format check.
4 features Opinionated — minimal config, one canonical output. Show all
  • Opinionated — minimal config, one canonical output.
  • Formats JS, TS, CSS, HTML, JSON, Markdown, YAML, and more.
  • Editor integrations for format-on-save.
  • Pairs with ESLint via eslint-config-prettier.

Its few-options philosophy is a feature, not a bug — if you fight it over trivial style preferences you’ll lose. Run eslint-config-prettier so ESLint’s stylistic rules don’t conflict with Prettier’s output, or the two will undo each other.

 JavaScript Prettier team + OSS community MIT
TypeScript (tsc) The type-checker as a quality gate — tsc --noEmit.
★ standard🔧{ }
🔧 Tooling{ } Language
★ standard moderate 2012

The TypeScript compiler isn’t just a transpiler — run as tsc --noEmit it becomes a powerful static-analysis gate that catches whole classes of bugs (null access, wrong argument types, typos in property names) before code runs, with no output files. In modern stacks a tool like Vite or esbuild handles the transpile, leaving tsc to do pure type-checking in CI.
3 use cases CI type-check gate (tsc --noEmit) separate from bundling. Show all
  • CI type-check gate (tsc --noEmit) separate from bundling.
  • Catching type errors before runtime across a whole codebase.
  • Generating .d.ts declaration files for published libraries.
4 features Whole-program type checking with --noEmit for a pure gate. Show all
  • Whole-program type checking with --noEmit for a pure gate.
  • Declaration-file (.d.ts) emission for libraries.
  • Incremental and project-references builds for monorepos.
  • TypeScript 7 (“Corsa”) is a native Go port targeting ~10x speed.

On large codebases the classic JS-based tsc is slow, which is why teams split bundling (fast, by esbuild/Vite) from type-checking (tsc --noEmit, in CI). The Go-native rewrite shipping as TypeScript 7 targets roughly a 10x speedup; the preview is the @typescript/native-preview (tsgo) package.

 TypeScript / Go Microsoft + OSS community Apache-2.0
Storybook A workshop for building and testing UI components in isolation.
● mainstream🔧
🔧 Tooling
● mainstream moderate 2016

A development environment that renders your UI components in isolation, outside the app, so you can build, document, and test each one across its states (“stories”). It doubles as living design-system documentation and a base for visual-regression and interaction testing, working with React, Vue, Svelte, Angular, and Web Components.
3 use cases Building and reviewing components in isolation from the app. Show all
  • Building and reviewing components in isolation from the app.
  • Living design-system and component documentation.
  • Visual-regression and interaction testing of UI states.
4 features Renders components in isolation across all their states. Show all
  • Renders components in isolation across all their states.
  • Auto-generated docs from stories and component types.
  • Interaction + visual-regression testing via addons.
  • Framework-agnostic — React, Vue, Svelte, Angular, Web Components.

It’s a second build to configure and maintain — addons, framework presets, and major-version upgrades all carry overhead, and large story sets get slow. Keep stories close to components and lean on the Vite builder to keep startup fast.

 TypeScript Storybook team + OSS community MIT
Mocha The flexible, BYO-assertions test framework that defined an era.
▼ legacy🔧
🔧 Tooling
▼ legacy gentle 2011

A long-standing JavaScript test framework that provides the describe/it structure, async support, and reporters, but deliberately leaves assertions and mocking to you (commonly Chai and Sinon). Its flexibility made it the default for years, though newer all-in-one runners have largely displaced it for new projects.
3 use cases Maintaining legacy Node test suites built on Mocha + Chai. Show all
  • Maintaining legacy Node test suites built on Mocha + Chai.
  • Projects that want to pick their own assertion and mock libraries.
  • Backend Node testing where a bundled UI runner isn’t needed.
4 features describe/it structure with rich async and hook support. Show all
  • describe/it structure with rich async and hook support.
  • Pluggable assertions (Chai) and mocking (Sinon).
  • Many built-in and third-party reporters.
  • Runs in Node and the browser.

Batteries are not included — you must wire up assertions, mocking, and coverage yourself, which is more setup than Jest or Vitest. For new projects an all-in-one runner is usually the simpler choice; Mocha mainly lives on in existing codebases.

 JavaScript OpenJS Foundation MIT
Puppeteer Headless Chrome automation via the DevTools Protocol.
● mainstream🔧
🔧 Tooling
● mainstream moderate 2017

A Node library from the Chrome team for driving headless (or headful) Chrome and Firefox through the DevTools Protocol. It is the go-to for browser automation tasks — generating PDFs, screenshots, scraping, and crawling — and underpins many higher-level testing tools.
3 use cases Generating PDFs or screenshots of rendered web pages. Show all
  • Generating PDFs or screenshots of rendered web pages.
  • Scraping and crawling JavaScript-heavy sites that need a real browser.
  • Automating browser interactions and basic end-to-end checks.
4 features Programmatic control of Chrome via the DevTools Protocol. Show all
  • Programmatic control of Chrome via the DevTools Protocol.
  • Page screenshots and PDF generation.
  • Network interception and request mocking.
  • Downloads a known-good Chrome build automatically.

It is Chrome-first — cross-browser testing is far weaker than Playwright, which the same team now positions for end-to-end work. For full E2E suites Playwright is usually the better pick; reach for Puppeteer when you specifically need Chrome automation or PDF/screenshot generation.

 JavaScript Google Chrome team Apache-2.0
k6 Developer-centric load and performance testing in JavaScript.
● mainstream🔧
🔧 Tooling
● mainstream moderate 2017

A load-testing tool from Grafana that lets you script performance and stress tests in JavaScript while the engine runs in Go for high concurrency. You define virtual users and stages, set pass/fail thresholds, and run it locally or in CI to catch regressions before they hit production.
3 use cases Load- and stress-testing APIs and websites before launch. Show all
  • Load- and stress-testing APIs and websites before launch.
  • Adding performance thresholds (p95 latency, error rate) as CI gates.
  • Soak and spike tests to find capacity limits.
4 features Tests scripted in JavaScript, executed by a fast Go engine. Show all
  • Tests scripted in JavaScript, executed by a fast Go engine.
  • Virtual users and staged ramp-up/ramp-down profiles.
  • Thresholds turn a load test into a pass/fail CI gate.
  • Outputs to Grafana, Prometheus, and other backends.

The k6 script runtime is not Node — it is a custom JavaScript VM, so npm packages and Node APIs are not available (you bundle compatible code or use its modules). It also measures the protocol layer, not a real browser, so it does not capture client-side rendering cost without the separate browser module.

 Go Grafana Labs AGPL-3.0
Biome One fast Rust toolchain for linting and formatting.
▲ rising🔧
🔧 Tooling
▲ rising gentle 2023

A single, Rust-based toolchain (the successor to Rome) that lints and formats JavaScript, TypeScript, JSX, JSON, and CSS at high speed. It aims to replace the ESLint + Prettier pair with one tool, one config, and near-zero setup — a Prettier-compatible formatter plus a growing lint rule set.
3 use cases Replacing the ESLint + Prettier combo with one fast tool. Show all
  • Replacing the ESLint + Prettier combo with one fast tool.
  • Speeding up lint/format on large codebases and in CI.
  • New projects wanting near-zero-config linting and formatting.
4 features Linter and formatter in one Rust binary — very fast. Show all
  • Linter and formatter in one Rust binary — very fast.
  • Prettier-compatible formatting output.
  • Single biome.json config, sensible defaults.
  • Editor integrations and a biome ci mode.

Its lint rule coverage and plugin ecosystem are still narrower than ESLint’s — projects that depend on niche ESLint plugins (framework-specific rules, custom rules) may not be able to fully switch yet. It also does not type-check; you still run tsc for that.

 Rust Biome team + OSS community MIT
MSW Mock Service Worker — API mocking at the network layer.
● mainstream🔧
🔧 Tooling
● mainstream gentle 2020

Mock Service Worker intercepts outgoing requests at the network level — via a Service Worker in the browser and request interception in Node — so your app code makes real fetch calls but gets mocked responses. The same handlers serve tests, Storybook, and local development without touching your application code.
3 use cases Mocking APIs in component and integration tests without s... Show all
  • Mocking APIs in component and integration tests without stubbing fetch.
  • Developing the frontend before the backend exists.
  • Driving Storybook stories with realistic mocked responses.
4 features Network-level interception — app code stays unmodified. Show all
  • Network-level interception — app code stays unmodified.
  • Shared request handlers across tests, Storybook, and dev.
  • Works in the browser (Service Worker) and in Node.
  • REST and GraphQL request matching.

The browser worker needs its generated mockServiceWorker.js served from the public root, and an out-of-date worker file after upgrades causes silent failures. The v2 API was a breaking rewrite (http/HttpResponse replaced rest/res(ctx…)), so older tutorials won’t match.

 TypeScript Artem Zakharchenko + OSS community MIT
Lighthouse Automated audits for performance, accessibility, and SEO.
● mainstream🔧
🔧 Tooling
● mainstream gentle 2016

An open-source auditing tool from the Chrome team that loads a page and scores it on performance, accessibility, best practices, and SEO, with concrete fixes for each finding. It runs in Chrome DevTools, as a CLI, and as Lighthouse CI to gate CI/CD on Core Web Vitals.
3 use cases Auditing a page's performance, a11y, and SEO with actiona... Show all
  • Auditing a page’s performance, a11y, and SEO with actionable advice.
  • Tracking Core Web Vitals over time as a CI gate (Lighthouse CI).
  • Catching accessibility and best-practice regressions before release.
4 features Scored audits for performance, a11y, best practices, and ... Show all
  • Scored audits for performance, a11y, best practices, and SEO.
  • Lab-based Core Web Vitals metrics (LCP, CLS, TBT).
  • Runs in DevTools, as a CLI, and as Lighthouse CI.
  • Specific, prioritized remediation suggestions.

Scores are lab measurements from one synthetic run — they vary with network, CPU throttling, and machine, and a single number is not the same as real-user (field) data. Treat it as directional guidance and median multiple runs rather than chasing a perfect 100.

 JavaScript Google Chrome team Apache-2.0
npm The default package manager that ships with Node.
★ standard🔧
🔧 Tooling
★ standard gentle 2010

Node.js’s built-in package manager and the original gateway to the JavaScript ecosystem. It reads package.json, resolves a dependency tree into a flat node_modules, writes a package-lock.json for reproducible installs, and runs your scripts (npm run …). It’s the baseline every other JS package manager is measured against.
3 use cases Default dependency management for any Node/JS project. Show all
  • Default dependency management for any Node/JS project.
  • Running project scripts and publishing packages to the registry.
  • Lowest-friction choice when no special speed/disk needs exist.
4 features Ships with Node — zero extra install. Show all
  • Ships with Node — zero extra install.
  • Flat node_modules with package-lock.json for reproducibility.
  • Workspaces for basic monorepo support.
  • npx for running package binaries without installing them.

The flat node_modules is non-deterministic in layout and permissive — it lets you import packages you never declared (phantom dependencies), which breaks when a manager like pnpm enforces strictness. It’s also the slowest and most disk-hungry of the major managers on large installs.

 JavaScript npm, Inc. (GitHub / Microsoft) Artistic-2.0
pnpm Fast, disk-efficient, and strict about your dependency tree.
● mainstream🔧
🔧 Tooling
● mainstream gentle 2017

A drop-in npm alternative that stores every package version once in a global content-addressed store and hard-links it into each project’s node_modules, so ten projects sharing a dependency cost the disk space of one. Its non-flat layout is strict — you can only import what you actually declared — which kills phantom-dependency bugs and makes it a favorite for the monorepo crowd.
3 use cases Monorepos and machines with many projects (huge disk savi... Show all
  • Monorepos and machines with many projects (huge disk savings).
  • Teams that want a strict, phantom-dependency-free node_modules.
  • Faster CI installs than npm or classic Yarn.
4 features Content-addressed global store + hard links — install onc... Show all
  • Content-addressed global store + hard links — install once, reuse everywhere.
  • Strict, symlinked node_modules — no phantom dependencies.
  • First-class workspaces for monorepos.
  • Compatible with the npm registry and package.json scripts.

The symlinked, non-flat layout occasionally trips tooling that assumes a flat node_modules or resolves modules by walking the real filesystem path — a few legacy packages need a node-linker=hoisted escape hatch. The strictness that catches phantom deps can also surface latent bugs the day you switch from npm.

 TypeScript pnpm team + OSS community MIT
Yarn The manager that pushed npm to get faster and deterministic.
● mainstream🔧
🔧 Tooling
● mainstream moderate 2016

A package manager born at Meta to fix early npm’s speed and determinism problems — it introduced lock files and parallel installs that npm later adopted. Yarn Classic (v1) behaves like npm; Yarn Berry (v2+) is a rewrite with Plug’n’Play, which skips node_modules entirely and resolves modules from a single zipped cache.
3 use cases Projects already standardized on Yarn workspaces. Show all
  • Projects already standardized on Yarn workspaces.
  • Plug’n’Play setups that want to eliminate node_modules.
  • Teams wanting plugin-extensible install behavior.
4 features Deterministic lock file and parallel installs. Show all
  • Deterministic lock file and parallel installs.
  • Workspaces for monorepos (Classic and Berry).
  • Yarn Berry’s Plug’n’Play removes node_modules.
  • Plugin architecture for extending the CLI.

Yarn Classic (v1) and Yarn Berry (v2+) are almost two different tools — Berry’s Plug’n’Play breaks packages that expect a real node_modules, so many Berry users fall back to the node-modules linker. Pick a major version deliberately; mixing advice from both eras causes confusion.

 TypeScript Yarn team + OSS community (originally Meta) BSD-2-Clause
Bun (package manager) bun install — an absurdly fast npm-compatible installer.
▲ rising🔧
🔧 Tooling
▲ rising gentle 2022

The package-manager half of the Bun runtime — bun install reads your existing package.json and installs from the npm registry, but does it many times faster than npm or Yarn thanks to a native (Zig) implementation and an aggressive global cache. It’s a drop-in installer you can adopt even if the rest of your stack still runs on Node.
3 use cases Drastically faster dependency installs in dev and CI. Show all
  • Drastically faster dependency installs in dev and CI.
  • Drop-in bun install replacement on existing Node projects.
  • Greenfield projects already using the Bun runtime end-to-end.
4 features Native (Zig) installer — dramatically faster than npm/Yarn. Show all
  • Native (Zig) installer — dramatically faster than npm/Yarn.
  • Reads package.json + works with the npm registry.
  • Global cache with hard links for fast, deduplicated installs.
  • Built into the Bun runtime alongside its bundler and test runner.

The installer is the most battle-tested part of Bun, but edge cases in lifecycle scripts, peer-dependency resolution, and lockfile interop with other managers still surface. Bun was acquired by Anthropic in December 2025 and stays MIT-licensed; the project remains young relative to npm and pnpm.

 Zig Bun team (Anthropic) MIT
npm registry The public warehouse — 3M+ packages every JS manager pulls from.
★ standard🔧☁
🔧 Tooling☁ Infra
★ standard gentle 2010

The public registry at registry.npmjs.org that hosts over three million JavaScript packages — the default source that npm, pnpm, Yarn, and Bun all download from. It’s a hosted service (not open-source software you self-host), exposing a simple HTTP API for fetching package tarballs and metadata, plus auth for publishing.
3 use cases The default install source for every major JS package man... Show all
  • The default install source for every major JS package manager.
  • Publishing and distributing open-source JS/TS libraries.
  • Scoped + private packages for org-internal distribution.
4 features 3M+ packages — the largest software registry in the world. Show all
  • 3M+ packages — the largest software registry in the world.
  • Simple HTTP API for tarballs and version metadata.
  • Scoped packages (@org/pkg) and private publishing.
  • Mirrorable behind a proxy/cache (Verdaccio, Artifactory).

It’s a single hosted service, so it’s a supply-chain and availability choke point — typosquatting, dependency-confusion, and the occasional unpublished package (the infamous left-pad incident) all stem from trusting a public registry. Pin versions, use a lock file, and consider a caching proxy for CI.

 Hosted service npm, Inc. (GitHub / Microsoft) proprietary
Composer The dependency manager that modernized PHP.
★ standard🔧
🔧 Tooling
★ standard gentle 2012

The standard dependency manager for PHP — it reads a composer.json, resolves a compatible set of packages from the Packagist registry, writes a composer.lock for reproducible installs, and generates a PSR-4 autoloader so you never write require statements by hand. It’s the tool that made the modern PHP framework ecosystem (Laravel, Symfony) possible.
3 use cases Dependency management for any modern PHP project. Show all
  • Dependency management for any modern PHP project.
  • Installing and updating frameworks like Laravel or Symfony.
  • Autoloading classes via the generated PSR-4 autoloader.
4 features composer.json manifest + composer.lock for reproducible i... Show all
  • composer.json manifest + composer.lock for reproducible installs.
  • Pulls from the Packagist registry by default.
  • Generates a PSR-4 / classmap autoloader automatically.
  • Per-project dependencies (no global install soup).

Resolving large dependency graphs can be slow and memory-hungry — bumping PHP’s memory_limit for Composer is a common ritual. And always commit composer.lock: without it, composer install resolves fresh versions and you lose reproducibility across environments.

 PHP Composer team + OSS community MIT
Turborepo High-performance build orchestration for JS/TS monorepos.
▲ rising🔧
🔧 Tooling
▲ rising moderate 2021

A monorepo build system from Vercel that sits on top of your package manager’s workspaces and makes big repos fast through aggressive caching — it builds a task dependency graph, runs tasks in parallel, and skips any work whose inputs haven’t changed (locally and via a shared remote cache). It’s a task runner, not a package manager: pair it with npm, pnpm, or Yarn workspaces.
3 use cases Speeding up build/test/lint tasks across a JS/TS monorepo. Show all
  • Speeding up build/test/lint tasks across a JS/TS monorepo.
  • Sharing a remote build cache across a team and CI.
  • Orchestrating task pipelines with explicit dependencies.
4 features Content-aware caching — never rebuild unchanged tasks. Show all
  • Content-aware caching — never rebuild unchanged tasks.
  • Remote cache shared across machines and CI.
  • Parallel task execution from a dependency graph (turbo.json).
  • Layers on top of npm/pnpm/Yarn workspaces.

The cache only helps if your task inputs/outputs in turbo.json are declared accurately — get them wrong and you’ll either cache stale results or never get a cache hit. It’s an orchestrator on top of workspaces, not a replacement for your package manager.

 Rust Vercel + OSS community MIT
Nx A smart, extensible build system for monorepos.
● mainstream🔧
🔧 Tooling
● mainstream moderate 2018

A build system and monorepo toolkit that understands your project graph to run only what changed, cache task results locally and remotely, and parallelize across packages. Plugins and generators scaffold apps and libraries for React, Node, and more, making it more batteries-included than a pure task runner.
3 use cases Large monorepos needing affected-only builds and tests. Show all
  • Large monorepos needing affected-only builds and tests.
  • Teams wanting code generators and enforced module boundaries.
  • Sharing computation caches across developers and CI for speed.
4 features Project-graph-aware task scheduling and affected commands. Show all
  • Project-graph-aware task scheduling and affected commands.
  • Local and remote computation caching (Nx Cloud).
  • Plugins and generators for common stacks.
  • Enforceable module-boundary lint rules.

Nx is more opinionated and heavier than Turborepo — plugins, generators, and its workspace conventions are powerful but can feel like a framework you must buy into. The remote-cache (Nx Cloud) is a paid service beyond generous free limits, and migrating an existing repo into Nx’s structure takes real effort.

 TypeScript Nrwl/Nx MIT
Volta Pin per-project JS toolchain versions, switch automatically.
● mainstream🔧
🔧 Tooling
● mainstream gentle 2019

A Rust-based toolchain manager that pins the exact Node, npm, pnpm, or Yarn version a project needs in its package.json and switches to it automatically when you cd into the directory. Everyone on the team — and CI — gets the same tool versions with no manual nvm use.
3 use cases Ensuring every developer and CI runs the same Node/packag... Show all
  • Ensuring every developer and CI runs the same Node/package-manager version.
  • Switching toolchains automatically per project without nvm commands.
  • Avoiding ‘works on my machine’ bugs caused by version drift.
4 features Pins Node/npm/pnpm/Yarn versions in package.json (volta f... Show all
  • Pins Node/npm/pnpm/Yarn versions in package.json (volta field).
  • Automatic, near-instant version switching on directory change.
  • Fast Rust implementation with shimmed binaries.
  • Cross-platform (macOS, Linux, Windows).

Volta works via shims on your PATH, which can clash with other version managers (nvm, asdf) if both are installed — pick one. Its package-manager handling also overlaps with Node’s built-in Corepack, so teams sometimes end up with two tools doing similar jobs.

 Rust Volta team + OSS community BSD-2-Clause
Corepack Node’s built-in shim for pnpm and Yarn versions.
● mainstream🔧
🔧 Tooling
● mainstream gentle 2021

A tool that ships with Node.js and acts as a shim for package managers other than npm — it reads the packageManager field in package.json and transparently runs the exact pinned pnpm or Yarn version, downloading it on first use. It means a repo can guarantee its package-manager version without a separate installer.
3 use cases Pinning the team's pnpm or Yarn version via packageManage... Show all
  • Pinning the team’s pnpm or Yarn version via packageManager in package.json.
  • Guaranteeing CI uses the same package-manager version as developers.
  • Avoiding a global pnpm/Yarn install — Node provides the shim.
4 features Bundled with Node — no separate install. Show all
  • Bundled with Node — no separate install.
  • Reads the packageManager field to select the exact version.
  • Auto-downloads the pinned pnpm/Yarn on first run.
  • Keeps package-manager version with the repo, not the machine.

Corepack is disabled by default and you must run corepack enable once per machine, which trips up CI that forgets the step. It also handles only pnpm and Yarn — not Node itself — and its first-run network download can fail in air-gapped or offline environments.

 JavaScript Node.js project MIT
uv An extremely fast Python package and project manager, in Rust.
▲ rising🔧
🔧 Tooling
▲ rising gentle 2024

A Rust-based tool from Astral that aims to replace pip, pip-tools, virtualenv, pipx, and parts of Poetry with one fast command. It resolves and installs Python dependencies dramatically faster than pip, manages virtual environments and Python versions, and reads the standard lockfile via pyproject.toml.
3 use cases Speeding up Python dependency installs in dev and CI. Show all
  • Speeding up Python dependency installs in dev and CI.
  • Managing a project’s venv, Python version, and lockfile in one tool.
  • Running CLI tools in isolated environments (the pipx replacement).
4 features 10–100× faster resolves/installs than pip, with a global ... Show all
  • 10–100× faster resolves/installs than pip, with a global cache.
  • Project management via pyproject.toml and a uv.lock lockfile.
  • Installs and pins Python interpreter versions itself.
  • uvx/uv tool for isolated CLI tools (pipx-style).

It moves fast and is still maturing — APIs and behaviour can change between releases, and a few corner-case packages or build backends may not resolve identically to pip. Mixing uv-managed venvs with manual pip install in the same environment can also cause drift, so commit to one workflow.

 Rust Astral Apache-2.0/MIT
pip The standard package installer for Python.
★ standard🔧
🔧 Tooling
★ standard gentle 2008

The default package manager for Python, used to install libraries from the Python Package Index (PyPI). It reads a requirements.txt or installs packages directly, and ships with every modern Python install, making it the universal baseline even as faster tools build on top of it.
3 use cases Installing Python packages from PyPI into a virtual envir... Show all
  • Installing Python packages from PyPI into a virtual environment.
  • Reproducing dependencies from a requirements.txt file.
  • Any Python project as the lowest-common-denominator installer.
4 features Installs from PyPI, Git, URLs, and local paths. Show all
  • Installs from PyPI, Git, URLs, and local paths.
  • requirements.txt for declaring dependency sets.
  • Bundled with Python — available everywhere.
  • Editable installs (pip install -e .) for local development.

Plain pip has no real lockfile — requirements.txt does not by itself pin transitive dependencies unless you generate it carefully (e.g. via pip-tools), so installs aren’t fully reproducible. It also installs into whatever environment is active, so forgetting to activate a virtualenv pollutes the system Python.

 Python PyPA MIT
Auth.js (NextAuth.js) Open-source authentication for the JavaScript ecosystem.
★ standard▦⚙
▦ Full-stack⚙ Backend
★ standard moderate 2020

The most widely used open-source auth library for JavaScript apps, originally NextAuth.js and now framework-agnostic across Next.js, SvelteKit, Express, and more. It bundles dozens of OAuth / OIDC providers, email and credentials flows, and a database-or-JWT session strategy you run entirely on your own infrastructure.
3 use cases Adding social and email login to a Next.js or SvelteKit app. Show all
  • Adding social and email login to a Next.js or SvelteKit app.
  • Self-hosted auth where you own the user table and sessions.
  • Apps needing many OAuth providers without integrating each by hand.
4 features Dozens of built-in OAuth/OIDC providers plus email and cr... Show all
  • Dozens of built-in OAuth/OIDC providers plus email and credentials.
  • Database session or stateless JWT session strategies.
  • Adapters for Prisma, Drizzle, and most databases.
  • Framework adapters: Next.js, SvelteKit, Express, and others.

It gives you the auth flow but not a full user-management UI — profile pages, organizations, and an admin console are still yours to build. The credentials (email/password) provider is deliberately bare-bones and the docs steer you toward OAuth, so rolling your own password auth on it takes care.

 TypeScript Auth.js team + OSS ISC
Clerk Drop-in auth and user management with prebuilt React components.
▲ rising▦▤
▦ Full-stack▤ Frontend
▲ rising gentle 2021

A managed authentication and user-management platform built frontend-first, shipping polished prebuilt React/Next.js components (<SignIn>, <UserButton>, organization switcher) so you get hosted login, profiles, and MFA in minutes. It handles OAuth, sessions, and multi-tenant organizations as a BaaS.
3 use cases Shipping login and signup UI fast without designing the f... Show all
  • Shipping login and signup UI fast without designing the flows.
  • B2B apps needing organizations, roles, and invitations out of the box.
  • Next.js/React products wanting hosted user management.
4 features Prebuilt, themeable React components for sign-in, profile... Show all
  • Prebuilt, themeable React components for sign-in, profile, and orgs.
  • Multi-tenant organizations with roles and invitations.
  • Built-in MFA, passkeys, and social/OAuth providers.
  • Hosted user management dashboard and admin APIs.

It’s a proprietary, usage-priced service — you trade ownership of your auth stack and user data for speed, and migrating off it later means re-exporting users and rebuilding flows. Pricing scales with monthly active users, which can surprise you as the app grows.

 — Clerk Inc. proprietary
Auth0 The veteran identity-as-a-service platform, now part of Okta.
★ standard⚙☁
⚙ Backend☁ Infra
★ standard moderate 2013

A long-established identity-as-a-service platform (acquired by Okta) that centralizes authentication and authorization behind hosted OAuth / OIDC endpoints. It supports a Universal Login page, enterprise SSO, MFA, and customizable Actions that run on the login pipeline.
3 use cases Enterprise apps needing SSO, SAML, and compliance-grade i... Show all
  • Enterprise apps needing SSO, SAML, and compliance-grade identity.
  • Centralizing auth across many apps behind one identity provider.
  • Customer-facing login (CIAM) with social, passwordless, and MFA.
4 features Hosted Universal Login with social, enterprise, and passw... Show all
  • Hosted Universal Login with social, enterprise, and passwordless.
  • Enterprise SSO (SAML, OIDC) and MFA built in.
  • Actions/Rules to run custom code in the login pipeline.
  • SDKs and quickstarts for most languages and frameworks.

Pricing climbs steeply past the free tier — monthly-active-user and enterprise-connection costs catch teams off guard at scale. Its breadth (tenants, Actions, Rules, flows) is powerful but the configuration surface is large, and post-Okta the product direction leans enterprise.

 — Okta proprietary
Lucia A lightweight, own-your-database auth library for TypeScript.
▲ rising⚙
⚙ Backend
▲ rising moderate 2022

A lightweight, framework-agnostic TypeScript auth library that gives you session management over your own database with no hosted service involved. It deliberately stays low-level — you control the user and session tables and write the OAuth and credentials logic — appealing to developers who want full ownership over magic.
3 use cases Apps wanting session auth fully owned in their own database. Show all
  • Apps wanting session auth fully owned in their own database.
  • Learning how sessions, cookies, and OAuth actually work.
  • Lightweight TypeScript backends avoiding a hosted auth vendor.
4 features Session-based auth stored in your own database. Show all
  • Session-based auth stored in your own database.
  • Framework- and runtime-agnostic core.
  • Adapters for Prisma, Drizzle, and raw drivers.
  • No vendor, no hosted dependency — you own all the data.

The Lucia v3 library is being wound down — the maintainer is deprecating it and reframing the project as a learning resource/guide for implementing auth yourself rather than a maintained dependency, so new projects should treat it as reference material and consider Better Auth or Auth.js for ongoing support.

 TypeScript pilcrowonpaper + OSS MIT
Better Auth The comprehensive, framework-agnostic TypeScript auth framework.
▲ rising▦⚙
▦ Full-stack⚙ Backend
▲ rising gentle 2024

A fast-rising open-source, framework-agnostic authentication and authorization framework for TypeScript that aims to be batteries-included where Lucia was minimal. It ships email/password, OAuth, 2FA, organizations, and a plugin system, all self-hosted against your own database with strong type inference.
3 use cases Self-hosted auth with 2FA, orgs, and passkeys without a v... Show all
  • Self-hosted auth with 2FA, orgs, and passkeys without a vendor.
  • TypeScript apps wanting a typed, plugin-extensible auth layer.
  • Migrating off a winding-down library like Lucia.
4 features Email/password, OAuth, magic links, and passkeys built in. Show all
  • Email/password, OAuth, magic links, and passkeys built in.
  • 2FA, organizations, and multi-session support.
  • Plugin architecture for extending core behaviour.
  • Database adapters (Prisma, Drizzle, Kysely) with full type inference.

It’s young and moving fast — APIs and plugins still evolve between minor releases, so pin versions and read changelogs before upgrading. As a self-hosted library you still own database schema, migrations, and production hardening that a managed service would handle.

 TypeScript Bereket Engida + OSS MIT
Keycloak Open-source identity and access management you self-host.
● mainstream⚙☁
⚙ Backend☁ Infra
● mainstream steep 2014

A mature, open-source identity and access management server (a CNCF project backed by Red Hat) that you self-host as your own identity provider. It speaks OIDC, OAuth 2.0, and SAML, and provides SSO, user federation, social login, and fine-grained RBAC out of the box.
3 use cases Self-hosted SSO across many internal and customer-facing ... Show all
  • Self-hosted SSO across many internal and customer-facing apps.
  • On-prem or sovereignty requirements that rule out a SaaS IdP.
  • Federating LDAP/Active Directory users into a modern OIDC layer.
4 features Standalone OIDC/OAuth 2.0/SAML identity provider. Show all
  • Standalone OIDC/OAuth 2.0/SAML identity provider.
  • Single sign-on, user federation (LDAP/AD), and social login.
  • Fine-grained roles, groups, and authorization policies.
  • Admin console plus full admin REST API and theming.

It’s a full server to operate, not a library — running it in production means managing the JVM, a database, clustering, upgrades, and realm config, which is real ops overhead. The admin model (realms, clients, scopes, mappers) is deep and the learning curve is steep before the first working login.

 Java Red Hat / CNCF Apache-2.0
Supabase Auth Postgres-native authentication built into the Supabase stack.
● mainstream⚙
⚙ Backend
● mainstream gentle 2020

The authentication service inside the Supabase platform (built on the open-source GoTrue server) that issues JWTs tied directly to your Postgres database. Because the JWT carries the user identity, it powers Postgres Row-Level Security, so auth and data authorization live in one place — and it supports email, OAuth, and magic links.
3 use cases Apps already on Supabase wanting auth wired to their data... Show all
  • Apps already on Supabase wanting auth wired to their database.
  • Enforcing per-user data access via Postgres Row-Level Security.
  • Quick email/social/magic-link login with a managed backend.
4 features JWT-based auth integrated with Postgres Row-Level Security. Show all
  • JWT-based auth integrated with Postgres Row-Level Security.
  • Email, OAuth providers, magic links, and phone OTP.
  • MFA and SSO (SAML) on higher tiers.
  • Open-source (GoTrue) and self-hostable alongside Supabase.

It’s most powerful when you embrace the Supabase model — its real leverage is the JWT-to-Row-Level-Security link, so using it as a generic standalone auth provider misses the point and adds a Postgres dependency. RLS policies are easy to get subtly wrong, and a too-loose policy silently exposes data.

 Go Supabase Apache-2.0
WorkOS Enterprise-readiness APIs — SSO, SCIM, and directory sync.
▲ rising⚙
⚙ Backend
▲ rising gentle 2020

A platform of APIs that make an app “enterprise-ready” without building the hard integrations yourself — primarily enterprise SSO (SAML/OIDC), SCIM-based directory sync, and audit logs. Its AuthKit layer adds hosted user authentication, so startups can sell to large customers by flipping on the identity features procurement demands.
3 use cases Adding enterprise SSO (SAML/OIDC) to sell to large custom... Show all
  • Adding enterprise SSO (SAML/OIDC) to sell to large customers.
  • SCIM directory sync to auto-provision and deprovision users.
  • Audit logs and admin portals that enterprise buyers require.
4 features Enterprise SSO across SAML and OIDC identity providers. Show all
  • Enterprise SSO across SAML and OIDC identity providers.
  • SCIM directory sync for user provisioning/deprovisioning.
  • AuthKit hosted authentication for everyday login.
  • Audit logs and a self-serve admin portal for IT admins.

It’s positioned around enterprise features, so for plain consumer email/social login a general auth library or Clerk is a simpler fit. SSO and SCIM pricing is typically per-connection, and each enterprise customer’s identity provider can have its own configuration quirks to support.

 — WorkOS proprietary
GraphQL A query language and runtime for APIs — ask for exactly what you need.
★ standard⚙▦
⚙ Backend▦ Full-stack
★ standard moderate 2015

A query language for APIs and a runtime for fulfilling those queries, originally from Meta and now a Linux Foundation project. Clients declare exactly which fields they want against a strongly-typed schema, which eliminates the over- and under-fetching common with REST and lets many resources be retrieved in a single request.
3 use cases Frontends that need flexible, precise data shapes per scr... Show all
  • Frontends that need flexible, precise data shapes per screen.
  • Aggregating multiple backends behind one typed graph.
  • Mobile apps minimizing round-trips over slow networks.
4 features Strongly-typed schema as the single source of truth. Show all
  • Strongly-typed schema as the single source of truth.
  • Clients request exactly the fields they need — no over-fetching.
  • One endpoint, many resources resolved per query.
  • Subscriptions for realtime updates over the same schema.

The flexibility shifts complexity to the server — naive resolvers cause N+1 database queries (you need DataLoader), and because a client can craft arbitrarily deep or expensive queries you must add depth/complexity limits and careful caching. HTTP caching is harder than with REST’s distinct URLs.

 — GraphQL Foundation MIT (spec)
Apollo Server A spec-compliant, production-grade GraphQL server for Node.
● mainstream⚙
⚙ Backend
● mainstream moderate 2016

A widely-used, spec-compliant GraphQL server for Node.js that turns a schema and resolvers into a running API. It integrates with Express, Fastify, and serverless runtimes, ships a built-in query explorer (Apollo Sandbox), and connects to Apollo’s broader tooling for federation, metrics, and schema management.
3 use cases Standing up a GraphQL API from a schema plus resolvers. Show all
  • Standing up a GraphQL API from a schema plus resolvers.
  • Federated graphs combining multiple subgraph services.
  • GraphQL backends wanting metrics and schema registry tooling.
4 features Schema-and-resolvers server with the Apollo Sandbox explo... Show all
  • Schema-and-resolvers server with the Apollo Sandbox explorer.
  • Integrations for Express, Fastify, and serverless handlers.
  • Apollo Federation for composing subgraphs into one graph.
  • Plugins for caching, tracing, and error handling.

It’s the transport and execution layer — schema design, resolver efficiency (DataLoader for N+1), and authorization are still yours. Apollo’s managed platform (GraphOS) and federation are powerful but pull you toward a commercial ecosystem; the open-source server alone is enough for most apps.

 TypeScript Apollo GraphQL MIT
Socket.IO Realtime, bidirectional event-based communication with fallbacks.
★ standard⚙▤
⚙ Backend▤ Frontend
★ standard gentle 2010

A realtime library that layers an event-based API on top of WebSockets with automatic reconnection, fallback to HTTP long-polling, rooms, and broadcasting. It pairs a Node.js server with a browser client speaking the same protocol, making it a fast path to chat, notifications, and live dashboards.
3 use cases Chat, presence, and live notifications in web apps. Show all
  • Chat, presence, and live notifications in web apps.
  • Collaborative or live-updating dashboards.
  • Realtime where you want reconnection and rooms handled for you.
4 features Event-based emit/on API over WebSockets. Show all
  • Event-based emit/on API over WebSockets.
  • Automatic reconnection and long-polling fallback.
  • Rooms and namespaces for targeted broadcasting.
  • Matched server (Node) and browser client libraries.

It speaks its own protocol, not raw WebSockets — a plain WebSocket client can’t talk to a Socket.IO server and vice versa, so both ends must use Socket.IO. Scaling beyond one process needs a sticky-session load balancer and an adapter (e.g. Redis) to fan out events across instances.

 JavaScript Socket.IO team + OSS MIT
gRPC High-performance RPC over HTTP/2 with Protocol Buffers.
★ standard⚙
⚙ Backend
★ standard steep 2016

A high-performance RPC framework from Google (now a CNCF project) that runs over HTTP/2 and serializes messages with Protocol Buffers. You define services and messages in a .proto file and generate typed client and server stubs in many languages, with first-class support for streaming in both directions.
3 use cases Low-latency, high-throughput service-to-service calls in ... Show all
  • Low-latency, high-throughput service-to-service calls in microservices.
  • Polyglot backends sharing one strongly-typed contract.
  • Bidirectional streaming RPCs (telemetry, live feeds).
  • Protocol Buffers
  • HTTP/2
4 features Contract-first .proto schema with generated stubs in many... Show all
  • Contract-first .proto schema with generated stubs in many languages.
  • Binary Protobuf serialization over HTTP/2 — compact and fast.
  • Unary, server-, client-, and bidirectional-streaming RPCs.
  • Built-in deadlines, cancellation, and pluggable auth.

Browsers can’t speak raw gRPC, so web clients need a gRPC-Web proxy (Envoy) or a codegen layer like Connect — it shines for server-to-server, not direct browser calls. The binary Protobuf wire format isn’t human-readable, so debugging needs reflection tooling (grpcurl) rather than curl.

 C/multi CNCF / Google Apache-2.0
OpenAPI / Swagger The standard, machine-readable contract for REST APIs.
★ standard🔧⚙
🔧 Tooling⚙ Backend
★ standard gentle 2011

A language-agnostic specification (formerly Swagger) for describing REST APIs in a machine-readable JSON or YAML document. From that single contract a rich tooling ecosystem generates interactive docs (Swagger UI), typed client SDKs, server stubs, and request validators — making the spec the source of truth for the API.
3 use cases Documenting a REST API with interactive, always-current d... Show all
  • Documenting a REST API with interactive, always-current docs.
  • Generating client SDKs and server stubs from one contract.
  • Contract-first design and request/response validation in CI.
  • REST
  • HTTP
4 features JSON/YAML contract describing endpoints, schemas, and auth. Show all
  • JSON/YAML contract describing endpoints, schemas, and auth.
  • Swagger UI renders interactive, try-it-out documentation.
  • Codegen for typed clients and server stubs in many languages.
  • Schema validation and mock servers from the spec.

A spec only helps if it stays accurate — a hand-written document drifts from the code, so generate it from the implementation (or generate code from it) and check it in CI. The full spec is large, and codegen output across languages varies in quality and often needs hand-tuning.

 — OpenAPI Initiative / SmartBear Apache-2.0
WebSockets The browser standard for full-duplex, persistent connections.
★ standard⚙▤
⚙ Backend▤ Frontend
★ standard moderate 2011

A protocol (RFC 6455) and browser API that upgrades a single HTTP connection into a persistent, full-duplex channel, letting client and server push messages to each other at any time without re-polling. Unlike Server-Sent Events, the WebSocket link is bidirectional, making it the native transport for chat, games, and live data.
3 use cases Bidirectional realtime: chat, multiplayer games, live tra... Show all
  • Bidirectional realtime: chat, multiplayer games, live trading.
  • Pushing server updates to the browser without polling.
  • Low-level realtime where you don’t want a library’s protocol.
4 features Full-duplex messaging over one persistent connection. Show all
  • Full-duplex messaging over one persistent connection.
  • Native WebSocket API in every modern browser.
  • Low overhead per message after the HTTP upgrade handshake.
  • Carries text or binary frames.

The raw API is bare — no reconnection, heartbeats, rooms, or message acknowledgements, so production use means building (or adopting, e.g. Socket.IO) that plumbing yourself. Persistent connections complicate horizontal scaling and load balancing, and corporate proxies sometimes block the upgrade.

 — IETF / WHATWG IETF/W3C standard
urql A small, highly customizable GraphQL client for the frontend.
● mainstream▤
▤ Frontend
● mainstream gentle 2019

A lightweight, highly extensible GraphQL client from The Guild for React, Vue, Svelte, and more. It positions itself as a simpler, smaller alternative to Apollo Client, with caching driven by a composable exchange pipeline — document caching by default and an opt-in normalized cache (Graphcache) when you need it.
3 use cases Frontends consuming a GraphQL API wanting a small client. Show all
  • Frontends consuming a GraphQL API wanting a small client.
  • Apps preferring exchanges/plugins over Apollo’s heavier runtime.
  • Choosing between document and normalized caching per project.
4 features Small core with a composable 'exchange' pipeline. Show all
  • Small core with a composable ‘exchange’ pipeline.
  • Document caching by default; opt-in normalized cache (Graphcache).
  • Bindings for React, Vue, Svelte, and Preact.
  • Subscriptions and SSR support.

The default document cache is coarse — it can return stale data after mutations until you adopt the normalized Graphcache exchange, which adds the configuration overhead urql tried to avoid. Its smaller ecosystem means fewer third-party integrations and examples than Apollo Client.

 TypeScript urql team MIT
React Native Write React, render real native iOS and Android UI.
★ standard▤
▤ Frontend
★ standard moderate 2015

A framework from Meta that maps React components to genuine native platform widgets rather than a WebView, so apps feel native while sharing one JavaScript codebase across iOS and Android. The New Architecture (Fabric renderer + JSI) replaced the old async bridge with synchronous native calls for smoother performance.
3 use cases Cross-platform mobile apps that need a genuinely native f... Show all
  • Cross-platform mobile apps that need a genuinely native feel.
  • Teams with React skills extending to iOS and Android without learning Swift/Kotlin.
  • Apps sharing logic between web and mobile codebases.
4 features Renders to real native UI components, not a WebView. Show all
  • Renders to real native UI components, not a WebView.
  • New Architecture (Fabric + JSI + TurboModules) for sync native calls.
  • Hot reload and a vast npm-based ecosystem.
  • Native modules in Swift/Kotlin for platform APIs.

You still hit the native layer for platform-specific work — build tooling (Xcode, Gradle), permissions, and third-party native modules can break across OS/SDK upgrades. Bare projects are far more maintenance than the managed Expo workflow.

 JavaScript Meta + OSS MIT
Expo The batteries-included toolchain for React Native.
★ standard▤🔧
▤ Frontend🔧 Tooling
★ standard gentle 2017

A framework and platform layered on React Native that removes most of the native-tooling pain — file-based routing (Expo Router), over-the-air updates, prebuilt native modules, and cloud builds (EAS) that compile iOS and Android binaries without a local Xcode/Android Studio setup. It is now the officially recommended way to start a React Native app.
3 use cases Starting any React Native project without wrangling nativ... Show all
  • Starting any React Native project without wrangling native build tools.
  • Shipping OTA JS updates without an app-store review cycle.
  • Building iOS apps from Linux/Windows via EAS cloud builds.
4 features Expo Router — file-based navigation across native and web. Show all
  • Expo Router — file-based navigation across native and web.
  • EAS cloud build + submit + over-the-air update pipeline.
  • Large library of vetted native modules (camera, notifications…).
  • Config plugins and prebuild for custom native code when needed.

The managed workflow hides the native layer until you need a module Expo doesn’t ship — then you reach for config plugins or prebuild, which adds complexity back. EAS cloud builds are a paid service beyond a modest free tier.

 TypeScript Expo MIT
Flutter Google’s toolkit that paints its own pixels everywhere.
★ standard▤
▤ Frontend
★ standard moderate 2018

A UI toolkit from Google that renders its own widgets onto a canvas (via the Impeller engine) rather than using platform controls, so an app looks and behaves identically across iOS, Android, web, Windows, macOS, and Linux. It uses the Dart language and a reactive, declarative widget tree with stateful hot reload.
3 use cases Pixel-perfect, brand-consistent UIs across mobile, web, a... Show all
  • Pixel-perfect, brand-consistent UIs across mobile, web, and desktop.
  • Animation-heavy or custom-design apps where native widgets constrain you.
  • Teams shipping one codebase to six platforms.
4 features Renders its own widgets via the Impeller engine — consist... Show all
  • Renders its own widgets via the Impeller engine — consistent UI.
  • Sub-second stateful hot reload during development.
  • One codebase targets mobile, web, and three desktop OSes.
  • Rich built-in Material and Cupertino widget catalogs.

You must learn Dart, and because Flutter paints its own widgets the app can feel subtly off from true platform conventions and ships a larger baseline binary. Its web target is heavy and best for app-like UIs, not content pages.

 Dart Google BSD-3-Clause
Ionic A web-standard UI kit for hybrid mobile apps.
● mainstream▤
▤ Frontend
● mainstream gentle 2013

A library of mobile-styled UI components (built as Web Components with Stencil) that adapt to iOS and Android design conventions and work with React, Angular, Vue, or plain JavaScript. The web UI runs inside a native shell — historically Cordova, now Capacitor — to reach app stores.
3 use cases Web teams shipping a mobile app with their existing frame... Show all
  • Web teams shipping a mobile app with their existing framework skills.
  • Apps that want one codebase for iOS, Android, and the web (PWA).
  • Forms-and-lists business apps where native rendering isn’t required.
4 features Platform-adaptive UI components as framework-agnostic Web... Show all
  • Platform-adaptive UI components as framework-agnostic Web Components.
  • Works with React, Angular, Vue, or vanilla JS.
  • Pairs with Capacitor for native shell and device APIs.
  • Same codebase ships to app stores and as a PWA.

Because the UI renders in a WebView, animation-heavy or graphics-intensive apps can feel less crisp than truly native ones, and you depend on Capacitor/Cordova plugins for device APIs. Best for content-and-forms apps, not games.

 TypeScript Ionic MIT
Capacitor Wrap any web app in a native iOS/Android shell.
● mainstream▤🔧
▤ Frontend🔧 Tooling
● mainstream gentle 2019

A native runtime from the Ionic team that packages any web app into an iOS, Android, or desktop binary and exposes device APIs (camera, geolocation, filesystem) to JavaScript through plugins. It is the modern successor to Cordova, treating the native projects as editable, committable source you own.
3 use cases Turning an existing web app or SPA into a store-ready nat... Show all
  • Turning an existing web app or SPA into a store-ready native app.
  • Adding device APIs (camera, push, filesystem) to a web codebase.
  • Framework-agnostic native wrapping (React, Vue, Angular, Svelte…).
4 features Wraps any web build into iOS/Android/desktop binaries. Show all
  • Wraps any web build into iOS/Android/desktop binaries.
  • Plugin API bridging JavaScript to native device features.
  • Native projects are real, editable Xcode/Gradle source.
  • Framework-agnostic — works with or without Ionic UI.

Your UI still runs in a WebView, so performance and platform feel match the browser, not native widgets. Device features beyond the core plugins may need a community plugin or hand-written native code.

 TypeScript Ionic MIT
Tauri Tiny, secure desktop & mobile apps with a Rust core.
▲ rising▤🔧
▤ Frontend🔧 Tooling
▲ rising moderate 2022

A toolkit for building desktop and mobile apps from a web frontend bundled with a Rust backend, using the operating system’s own WebView instead of shipping Chromium. The result is dramatically smaller and lighter than an Electron app, with a security-first model. Tauri 2 added iOS and Android targets alongside the desktop platforms.
3 use cases Lightweight desktop apps where Electron's bundle size is ... Show all
  • Lightweight desktop apps where Electron’s bundle size is unacceptable.
  • Apps that want a Rust backend for native performance or system access.
  • Cross-platform desktop plus mobile from one web UI (Tauri 2).
4 features Uses the OS WebView — binaries a fraction of Electron's s... Show all
  • Uses the OS WebView — binaries a fraction of Electron’s size.
  • Rust backend with a typed command bridge to the frontend.
  • Granular permission/capability security model.
  • Tauri 2 targets desktop and mobile (iOS/Android).

Relying on the OS WebView means rendering varies across platforms (WebKit on macOS/iOS vs WebView2 on Windows), so you test on each. Anything beyond simple backend logic means writing Rust, and the plugin ecosystem is younger than Electron’s.

 Rust Tauri / CrabNebula MIT/Apache-2.0
Electron Ship a web app as a cross-platform desktop binary.
★ standard▤
▤ Frontend
★ standard moderate 2013

A framework that bundles Chromium and Node.js so a web UI runs as a native desktop app on Windows, macOS, and Linux with full filesystem and OS access. It powers VS Code, Slack, Discord, and Figma desktop — proof of its reach despite its memory and bundle-size reputation.
3 use cases Cross-platform desktop apps built by web teams (editors, ... Show all
  • Cross-platform desktop apps built by web teams (editors, chat, tools).
  • Apps needing deep OS integration — menus, tray, native dialogs, files.
  • Porting an existing web app to the desktop quickly.
4 features Bundles Chromium + Node.js for consistent rendering every... Show all
  • Bundles Chromium + Node.js for consistent rendering everywhere.
  • Full Node.js and OS APIs (filesystem, tray, menus, dialogs).
  • Main/renderer process model with secure IPC and context isolation.
  • Mature tooling: Electron Forge, auto-updater, code signing.

Every app ships its own Chromium, so binaries are large (100 MB+) and idle memory is high. The main/renderer split and lax IPC are a real security surface — enable context isolation and disable node integration in renderers.

 JavaScript OpenJS Foundation MIT
PWA (Progressive Web App) Installable, offline-capable apps — no app store needed.
● mainstream▤
▤ Frontend
● mainstream moderate 2015

Not a framework but a set of web-platform capabilities — a Service Worker for offline caching and background tasks, a web app manifest for installation, and APIs for push and hardware — that let an ordinary website be installed to the home screen and run like a native app. One URL, no store review, automatic updates.
3 use cases Apps you want installable and offline without an app-stor... Show all
  • Apps you want installable and offline without an app-store presence.
  • Reaching users instantly from a link, with no download friction.
  • Adding offline caching and push to an existing website.
4 features Service Worker for offline caching and network interception. Show all
  • Service Worker for offline caching and network interception.
  • Web app manifest for home-screen install and standalone display.
  • Push notifications and background sync (where supported).
  • Single codebase served over HTTPS — instant, store-free updates.

Capability is uneven across platforms — iOS Safari supports installable PWAs but historically lags on push and background APIs, and some hardware and store-distribution features stay native-only. A buggy Service Worker can also serve stale cached content if versioning is wrong.

 — W3C / browser vendors web standard
NativeScript Direct native API access from JavaScript — no WebView.
▼ legacy▤
▤ Frontend
▼ legacy moderate 2014

An open-source framework that runs JavaScript/TypeScript against the real native iOS and Android UI and APIs directly — no WebView — with bindings to Angular, Vue, Svelte, or plain JS. It can call any native SDK from JS, but its ecosystem and mindshare have faded behind React Native and Flutter.
3 use cases Native-rendering apps using Angular or Vue skills. Show all
  • Native-rendering apps using Angular or Vue skills.
  • Apps needing direct, unwrapped access to platform native APIs from JS.
  • Maintaining existing NativeScript codebases.
4 features Renders real native UI — no WebView, no DOM. Show all
  • Renders real native UI — no WebView, no DOM.
  • Direct access to 100% of native platform APIs from JavaScript.
  • Integrations for Angular, Vue, Svelte, and plain JS.
  • Shared business logic with web codebases.

Momentum has shifted firmly to React Native and Flutter, so the plugin ecosystem, hiring pool, and community are comparatively thin. Many third-party plugins are stale, which makes greenfield adoption a hard sell.

 TypeScript OpenJS Foundation Apache-2.0
Sanity A real-time content platform with a code-defined studio.
● mainstream⚙▦
⚙ Backend▦ Full-stack
● mainstream moderate 2018

A headless CMS built around structured content and a hosted real-time datastore. Its editing studio is an open-source React app you configure in code, and content is queried with GROQ (or GraphQL), making it a favorite for highly customized editorial workflows.
3 use cases Custom editorial experiences where the studio is tailored... Show all
  • Custom editorial experiences where the studio is tailored in code.
  • Structured content reused across web, mobile, and other channels.
  • Real-time collaborative editing with live previews.
4 features Code-configured, open-source React editing studio. Show all
  • Code-configured, open-source React editing studio.
  • GROQ query language plus a GraphQL API.
  • Real-time collaboration and document history.
  • Generous free tier with hosted content lake and CDN.

GROQ is powerful but a Sanity-specific language you must learn, and the schema lives in code, so non-technical setup is limited. The hosted model is convenient until usage scales past the free tier, where pricing climbs.

 TypeScript Sanity.io MIT/proprietary
Contentful The enterprise API-first content platform.
● mainstream⚙
⚙ Backend
● mainstream gentle 2013

One of the original headless CMS platforms — a fully hosted, API-first service where editors model and author content in a polished web app and developers fetch it over REST or GraphQL. It targets large organizations with governance, localization, and multi-team needs.
3 use cases Enterprise content reused across many sites, apps, and ch... Show all
  • Enterprise content reused across many sites, apps, and channels.
  • Teams wanting a hosted CMS with strong roles, workflows, and localization.
  • Replacing a legacy CMS with an API-first content backend.
4 features Fully hosted — no infrastructure to run. Show all
  • Fully hosted — no infrastructure to run.
  • Content modeling UI with REST and GraphQL delivery APIs.
  • Localization, roles, and editorial workflows for big teams.
  • Global CDN for content delivery.

It is proprietary and SaaS-only, so you can’t self-host, and pricing scales steeply with API calls, records, and seats. The free/community tier caps content types and users, which smaller projects can outgrow quickly.

 — Contentful proprietary
Strapi The leading open-source, self-hosted headless CMS.
● mainstream⚙▦
⚙ Backend▦ Full-stack
● mainstream moderate 2015

A Node.js headless CMS you self-host, with an admin panel that builds content types and exposes them as REST and GraphQL APIs. It is fully customizable through plugins and code, giving teams full ownership of their data without vendor lock-in.
3 use cases Self-hosted headless CMS where you control data and infra... Show all
  • Self-hosted headless CMS where you control data and infrastructure.
  • Custom backends extended with plugins and JavaScript code.
  • Projects avoiding SaaS vendor lock-in or with data-residency needs.
4 features Admin UI generates content types and auto-builds REST/Gra... Show all
  • Admin UI generates content types and auto-builds REST/GraphQL APIs.
  • Self-hosted and fully open source — you own the data.
  • Plugin system and code-level customization.
  • Pluggable database: PostgreSQL, MySQL, SQLite.

Self-hosting means you own upgrades, scaling, and security, and major versions (v4 → v5) have been disruptive migrations. Some advanced features and cloud hosting sit behind the paid Enterprise/Cloud tiers.

 TypeScript Strapi MIT/EE
Payload A code-first, TypeScript-native headless CMS.
▲ rising⚙▦
⚙ Backend▦ Full-stack
▲ rising moderate 2021

A code-first headless CMS where the entire schema, access control, and admin UI are defined in TypeScript config. Payload 3 runs natively inside a Next.js app, installing into the App Router so the CMS and frontend share one codebase and deployment.
3 use cases Developer-owned CMS configured entirely in TypeScript. Show all
  • Developer-owned CMS configured entirely in TypeScript.
  • Embedding a CMS directly inside a Next.js app (Payload 3).
  • Apps wanting code-level control over access rules and admin UI.
4 features Schema, hooks, and access control defined in TypeScript. Show all
  • Schema, hooks, and access control defined in TypeScript.
  • Auto-generated admin UI and REST + GraphQL APIs.
  • Payload 3 installs natively into a Next.js App Router project.
  • Self-hosted; MongoDB or PostgreSQL via database adapters.

It is code-first, so non-developers can’t model content without an engineer, and the deep Next.js integration ties the CMS lifecycle to your app’s. As a younger project, the plugin ecosystem is smaller than Strapi’s or WordPress’s.

 TypeScript Payload CMS MIT
WordPress The CMS that still powers a huge share of the web.
★ standard⚙▦
⚙ Backend▦ Full-stack
★ standard gentle 2003

The most widely deployed CMS in the world — a PHP application with a vast theme and plugin ecosystem that runs everything from personal blogs to large publishers and shops (via WooCommerce). Its REST API and the headless WPGraphQL plugin also let it serve as a headless content backend for a modern JS frontend.
3 use cases Blogs, marketing sites, and shops editors maintain withou... Show all
  • Blogs, marketing sites, and shops editors maintain without developers.
  • Projects needing a plugin for nearly any feature out of the box.
  • Headless content backend (REST/WPGraphQL) feeding a JS frontend.
4 features Enormous theme and plugin ecosystem for any feature. Show all
  • Enormous theme and plugin ecosystem for any feature.
  • Block-based Gutenberg editor and full-site editing.
  • WooCommerce for e-commerce on the same platform.
  • REST API and WPGraphQL enable headless use.

The plugin ecosystem is both its strength and its weakness — plugins are the leading source of security holes, conflicts, and bloat, and out-of-date sites are a constant attack target. Self-hosted installs need ongoing updates, backups, and hardening.

 PHP WordPress Foundation + Automattic GPL-2.0
Directus An instant API and admin app over any SQL database.
● mainstream⚙
⚙ Backend
● mainstream moderate 2015

A data platform that wraps an existing or new SQL database with a REST and GraphQL API plus a no-code admin app, without dictating its own schema. It can layer onto a database you already have, making it equally a headless CMS and a backend-as-a-service.
3 use cases Exposing an existing SQL database via an instant API and ... Show all
  • Exposing an existing SQL database via an instant API and admin UI.
  • Headless CMS that works with your own database schema.
  • Internal tools and data dashboards over relational data.
4 features Wraps any SQL database — doesn't impose its own schema. Show all
  • Wraps any SQL database — doesn’t impose its own schema.
  • Auto-generated REST and GraphQL APIs.
  • No-code admin app for data, roles, and flows.
  • Self-hosted or cloud; PostgreSQL, MySQL, SQLite, and more.

Directus relicensed to the Business Source License (BSL 1.1) — free for smaller companies but a paid commercial license above a revenue threshold, so check terms before relying on it. Because it mirrors your raw database schema, content modeling is less editor-friendly than a purpose-built CMS.

 TypeScript Directus BSL 1.1
MDX Markdown that lets you import and render components.
● mainstream🔧▤
🔧 Tooling▤ Frontend
● mainstream gentle 2018

An authoring format that lets you use JSX — importing and rendering interactive components — directly inside Markdown content. It compiles each document to a component, making it ideal for documentation, blogs, and design systems where prose and live examples mix.
3 use cases Docs and blogs that embed interactive demos alongside prose. Show all
  • Docs and blogs that embed interactive demos alongside prose.
  • Design-system pages mixing copy with live component examples.
  • Content where authors want Markdown but developers want components.
4 features Import and render JSX components inside Markdown. Show all
  • Import and render JSX components inside Markdown.
  • Compiles each document to a component.
  • Plugin pipeline via remark/rehype for custom transforms.
  • First-class support in Next.js, Astro, Gatsby, and Docusaurus.

Because MDX executes JSX, content is no longer just data — a malformed or untrusted document can break the build or run code, so it’s unsafe for user-submitted content. Editors comfortable with plain Markdown can be tripped up by the component syntax.

 JavaScript MDX team + OSS MIT
Decap CMS Git-based content editing for static sites (ex-Netlify CMS).
● mainstream▤🔧
▤ Frontend🔧 Tooling
● mainstream gentle 2016

A Git-based headless CMS — formerly Netlify CMS — that adds an editing UI on top of files in your repository. Edits commit Markdown and assets straight back to Git, so your content stays version-controlled and your static site generator rebuilds from those files with no separate content database.
3 use cases Adding an editor UI to a Git-backed static site (Jekyll, ... Show all
  • Adding an editor UI to a Git-backed static site (Jekyll, Hugo, Astro).
  • JAMstack sites that want content version-controlled in the repo.
  • Small teams avoiding a separate CMS database or service.
4 features Edits commit Markdown and media back to Git. Show all
  • Edits commit Markdown and media back to Git.
  • Single-file admin app configured with a YAML schema.
  • Editorial workflow backed by branches and pull requests.
  • Backend-agnostic: GitHub, GitLab, Gitea, and more.

Content scales with your Git repo, so it suits modest sites, not thousands of entries or many concurrent editors. After the Netlify-to-Decap rename, maintenance slowed and a v3/Decap 4 refresh has been slow, so evaluate its momentum before adopting.

 JavaScript Decap/Netlify + OSS MIT
Bootstrap The original responsive CSS + component framework.
● mainstream◈▤
◈ Styling▤ Frontend
● mainstream gentle 2011

The framework that popularized the 12-column responsive grid and a full set of ready-styled components — buttons, navbars, modals, cards — driven by utility and component classes. Born at Twitter, it’s still everywhere on dashboards, internal tools, and CMS themes. v5 dropped the jQuery dependency and added its own CSS custom properties and utility API.
3 use cases Standing up a responsive, conventional UI quickly without... Show all
  • Standing up a responsive, conventional UI quickly without bespoke CSS.
  • Admin dashboards, internal tools, and CMS/server-rendered themes.
  • Prototypes and MVPs where a familiar, neutral look is fine.
4 features Responsive 12-column grid and a deep utility-class library. Show all
  • Responsive 12-column grid and a deep utility-class library.
  • Large catalogue of pre-styled components (modals, navbars, cards).
  • v5 is jQuery-free with vanilla-JS plugins and CSS variables.
  • Sass source and theming via variable overrides.

The trade-off is sameness — out-of-the-box Bootstrap sites look alike, so meaningful branding means overriding its Sass variables, not just adding classes. It’s class-and-markup driven rather than component-based, so it doesn’t integrate as naturally with React/Vue as framework-native kits.

 JavaScript Bootstrap team + OSS MIT
MUI (Material UI) Comprehensive React components implementing Material Design.
★ standard▤◈
▤ Frontend◈ Styling
★ standard moderate 2014

The most widely used React component library, implementing Google’s Material Design with a deep catalogue — data grids, date pickers, autocomplete, and more. It’s styled via a theming system (historically on Emotion) and ships both free and commercial (MUI X) tiers. Comprehensive but opinionated, it brings the Material look unless you invest in re-theming.
3 use cases React dashboards and admin panels needing rich components... Show all
  • React dashboards and admin panels needing rich components fast.
  • Teams that want a polished, accessible component set out of the box.
  • Apps comfortable adopting (or heavily theming) Material Design.
4 features Large catalogue including advanced MUI X data grid and pi... Show all
  • Large catalogue including advanced MUI X data grid and pickers.
  • Theming system with design tokens and dark mode support.
  • Accessible components following Material Design guidelines.
  • First-class TypeScript types throughout.

The Material look is strong and re-theming it to not look like Material is real work — budget for it if you want a distinct brand. The runtime CSS-in-JS styling engine adds overhead and complicates React Server Components, and the most powerful MUI X features (grid pro, charts) sit behind a paid licence.

 TypeScript MUI MIT
shadcn/ui Copy-in components on Radix + Tailwind that you own.
▲ rising▤◈
▤ Frontend◈ Styling
▲ rising gentle 2023

Not an installed dependency but a collection of beautifully styled components you copy into your own codebase via a CLI — built on Radix UI primitives and styled with Tailwind. Because the source lands in your repo, you own and edit it directly, with no version lock-in or black-box package. It exploded in popularity as the default look for modern React/Next.js apps.
3 use cases React/Next.js apps wanting polished components you fully ... Show all
  • React/Next.js apps wanting polished components you fully control.
  • Teams that prefer owning component source over a dependency.
  • Building a bespoke design system on accessible Radix primitives.
4 features CLI copies component source into your project — you own t... Show all
  • CLI copies component source into your project — you own the code.
  • Built on accessible Radix UI primitives, styled with Tailwind.
  • No runtime dependency or version lock-in to a UI package.
  • Theming via CSS variables and a registry of add-on blocks.

You own the code — which means you also own the maintenance, since there’s no npm update to pull upstream fixes; updates mean re-running the CLI and reconciling your edits. It assumes a Tailwind + Radix setup, so it isn’t a drop-in for projects on other styling stacks.

 TypeScript shadcn + OSS MIT
Radix UI Headless, accessible React primitives — behaviour, no styles.
● mainstream▤
▤ Frontend
● mainstream moderate 2020

A set of unstyled, fully accessible React component primitives — dialogs, dropdowns, tooltips, tabs — that handle the hard parts (keyboard navigation, focus management, ARIA, WAI-ARIA patterns) while leaving all visuals to you. It’s the behavioural foundation under many design systems, most visibly shadcn/ui. You bring the CSS; Radix brings correct, accessible interaction.
3 use cases Building a custom-styled design system on a correct acces... Show all
  • Building a custom-styled design system on a correct accessibility base.
  • Replacing fiddly hand-rolled menus, dialogs, and comboboxes.
  • Pairing with Tailwind or any styling layer for full visual control.
4 features Unstyled primitives — you supply 100% of the visuals. Show all
  • Unstyled primitives — you supply 100% of the visuals.
  • Robust accessibility: focus traps, keyboard nav, ARIA.
  • Composable parts (Root/Trigger/Content) per component.
  • Powers shadcn/ui and many bespoke design systems.

It ships zero styles by design, so “nothing looks like anything” until you write CSS — great for control, slower for a quick UI. You assemble multi-part components (Root/Trigger/Content) yourself, which is more verbose than a styled kit’s single component import.

 TypeScript WorkOS/Radix MIT
Chakra UI Simple, accessible, themeable React components with style props.
● mainstream▤◈
▤ Frontend◈ Styling
● mainstream gentle 2019

A React component library built around ergonomics — style props let you style components inline (<Box p={4} bg="blue.500">), and everything ships accessible and themeable out of the box. It hits a sweet spot between a full styled kit and a primitive library, with a clean, modern default look and strong dark-mode support.
3 use cases React apps wanting fast, accessible UI with minimal styli... Show all
  • React apps wanting fast, accessible UI with minimal styling friction.
  • Teams who like styling via props instead of separate CSS.
  • Products needing solid dark mode and theming with little setup.
4 features Style props for inline, token-aware styling of components. Show all
  • Style props for inline, token-aware styling of components.
  • Accessible components with built-in dark-mode support.
  • Composable primitives plus higher-level components.
  • Theme system based on design tokens.

Style props are convenient but spread styling across your JSX, which can get noisy on complex components. The library’s major versions have reworked the styling internals (the team also maintains Panda CSS), so upgrades can involve real migration rather than a simple bump.

 TypeScript Chakra team MIT
Headless UI Unstyled, accessible UI components from the Tailwind team.
● mainstream▤
▤ Frontend
● mainstream gentle 2020

A small set of completely unstyled, fully accessible components — menus, dialogs, listboxes, switches, tabs — built by Tailwind Labs to pair with Tailwind. Like Radix, it gives you the interaction logic and accessibility with no visuals, so you style everything with utility classes. It ships for both React and Vue.
3 use cases Adding accessible menus/dialogs to a Tailwind project. Show all
  • Adding accessible menus/dialogs to a Tailwind project.
  • Styling interactive components entirely with utility classes.
  • React or Vue apps wanting a lightweight headless primitive set.
4 features Unstyled components — style with Tailwind utilities. Show all
  • Unstyled components — style with Tailwind utilities.
  • Accessible by default: ARIA, focus, and keyboard handling.
  • Official React and Vue packages.
  • Designed to complement Tailwind CSS.

The component set is intentionally small, so it covers common interactive widgets but not a full design system — you’ll reach for Radix or hand-rolled pieces for anything it lacks. As headless components they ship no styles, so expect to write all the visuals yourself.

 TypeScript Tailwind Labs MIT
Mantine Full-featured React components and hooks library.
● mainstream▤◈
▤ Frontend◈ Styling
● mainstream gentle 2021

A comprehensive React library combining a large styled component set with an extensive collection of hooks (forms, notifications, modals, dates). It’s known for excellent documentation, strong TypeScript support, and built-in dark mode. It aims to be a batteries-included alternative to MUI without the heavy Material aesthetic.
3 use cases React apps wanting a complete component + hooks toolkit o... Show all
  • React apps wanting a complete component + hooks toolkit out of the box.
  • Dashboards and forms needing date pickers, tables, and notifications.
  • Teams who value thorough docs and TypeScript-first APIs.
4 features Large styled component set plus 100+ utility hooks. Show all
  • Large styled component set plus 100+ utility hooks.
  • Built-in dark mode and a flexible theming system.
  • Form, notification, modal, and date packages included.
  • Strong TypeScript types and extensive documentation.

Its breadth means a larger API surface to learn, and pulling many @mantine/* packages can add weight if you only need a few. Major versions have moved the styling internals (toward CSS modules and away from a runtime CSS-in-JS engine), so upgrades can require migration work.

 TypeScript Mantine + OSS MIT
Ant Design Enterprise-grade React UI for data-dense applications.
★ standard▤◈
▤ Frontend◈ Styling
★ standard moderate 2016

A large, polished React component library from Ant Group (Alibaba) aimed at enterprise and data-heavy admin applications. Its catalogue is exceptionally deep — advanced tables, forms, date pickers, transfer lists — with a distinctive, professional design language. It’s especially dominant in the Chinese tech ecosystem and for internal business tools.
3 use cases Enterprise admin panels and data-dense back-office tools. Show all
  • Enterprise admin panels and data-dense back-office tools.
  • Complex forms and tables that need powerful built-in components.
  • Teams wanting a complete, professional design language out of the box.
4 features Very deep catalogue including advanced tables and form co... Show all
  • Very deep catalogue including advanced tables and form controls.
  • Cohesive enterprise design language with strong defaults.
  • Built-in internationalization and theming (design tokens in v5).
  • Mature, battle-tested in large business applications.

The design language is strongly opinionated and heavily branded, so heavy customization can fight the framework. The bundle is large given the catalogue’s depth, and some documentation and community discussion is primarily in Chinese, which can slow non-Chinese-speaking teams.

 TypeScript Ant Group + OSS MIT
DaisyUI Tailwind component classes — semantic, themeable, low-markup.
● mainstream◈
◈ Styling
● mainstream gentle 2021

A Tailwind CSS plugin that adds semantic component classes (btn, card, modal) on top of Tailwind’s utilities, so you write class="btn btn-primary" instead of a long utility string. It includes a theming system with many ready-made themes and stays framework-agnostic — it’s just CSS, so it works anywhere Tailwind does.
3 use cases Cutting down verbose Tailwind utility strings with compon... Show all
  • Cutting down verbose Tailwind utility strings with component classes.
  • Quickly theming a Tailwind project with prebuilt color themes.
  • Framework-agnostic styling — works with any stack using Tailwind.
4 features Semantic component classes layered over Tailwind utilities. Show all
  • Semantic component classes layered over Tailwind utilities.
  • Dozens of built-in themes plus a theming system.
  • Pure CSS plugin — framework-agnostic, no JS runtime.
  • Components stay customizable with ordinary Tailwind utilities.

It styles markup but provides no JavaScript behaviour, so interactive widgets (dropdowns, modals) still need your own JS or a headless library for accessibility. Its semantic classes also reintroduce some of the abstraction Tailwind set out to avoid, which is a philosophical trade-off some teams dislike.

 CSS Pouya Saadeghi + OSS MIT
Sentry Application error and performance monitoring.
★ standard🔧☁
🔧 Tooling☁ Infra
★ standard gentle 2012

The default tool for catching and triaging application errors: it captures exceptions with full stack traces, breadcrumbs, release context, and the affected users, then groups them so you fix the right bug first. It has expanded into performance monitoring, distributed tracing, and session replay, with SDKs for virtually every language and framework.
3 use cases Catching and triaging frontend and backend exceptions in ... Show all
  • Catching and triaging frontend and backend exceptions in production.
  • Tracing slow requests and performance regressions across services.
  • Tying errors to specific releases and affected users.
4 features Automatic error capture with stack traces and breadcrumbs. Show all
  • Automatic error capture with stack traces and breadcrumbs.
  • Smart grouping of duplicate errors into single issues.
  • Performance monitoring and distributed tracing.
  • SDKs for most languages plus release and source-map support.

Costs scale with event volume, so a noisy app or a chatty release can burn through your quota fast — sample and filter aggressively. The licence changed from BSD to the source-available FSL/BSL, so the modern server isn’t OSI open source; self-hosting is heavy, and most teams use the SaaS.

 Python/TypeScript Sentry FSL/BSL
Datadog Unified SaaS platform for metrics, logs, traces, and more.
★ standard☁
☁ Infra
★ standard moderate 2010

A comprehensive, hosted observability platform that pulls infrastructure metrics, application traces (APM), logs, real-user monitoring, and security signals into one place. Its breadth is the draw — one SaaS covers what would otherwise be several tools — and an agent plus hundreds of integrations make onboarding existing systems straightforward. It’s a market leader for enterprise monitoring.
3 use cases Single-pane monitoring of infrastructure, apps, and logs ... Show all
  • Single-pane monitoring of infrastructure, apps, and logs together.
  • APM and distributed tracing across microservices.
  • Enterprises wanting a managed platform over self-hosted tooling.
  • Observability concepts
4 features Unified metrics, logs, APM traces, and RUM in one platform. Show all
  • Unified metrics, logs, APM traces, and RUM in one platform.
  • Agent plus 800+ integrations for common services.
  • Dashboards, monitors, and alerting with anomaly detection.
  • Adds security, CI visibility, and synthetic monitoring.

The headline complaint is cost — pricing has many per-host, per-GB, and per-feature dimensions that can produce surprise bills at scale, so watch log and custom-metric volume. It’s fully proprietary SaaS, so you’re committing to a vendor rather than owning the stack.

 — Datadog proprietary
Grafana The open dashboarding and visualization layer for observability.
★ standard☁🔧
☁ Infra🔧 Tooling
★ standard moderate 2014

The de-facto open-source tool for visualizing time-series data and building observability dashboards. It queries many backends — Prometheus, Loki, Tempo, Elasticsearch, SQL databases — and renders graphs, panels, and alerts over them. Grafana Labs has grown it into a full LGTM stack (Loki for logs, Grafana, Tempo for traces, Mimir for metrics).
3 use cases Dashboards on top of Prometheus and other time-series sou... Show all
  • Dashboards on top of Prometheus and other time-series sources.
  • Unified visualization across metrics, logs, and traces.
  • Alerting and on-call workflows over operational data.
4 features Pluggable data sources — Prometheus, Loki, SQL, and many ... Show all
  • Pluggable data sources — Prometheus, Loki, SQL, and many more.
  • Rich, shareable dashboards with templating and variables.
  • Built-in alerting engine and notification routing.
  • Part of the LGTM stack (Loki, Grafana, Tempo, Mimir).

Grafana visualizes data but does not store it — you still need a backend (Prometheus, Loki, etc.), so it’s one piece of the stack, not the whole thing. The core moved to the copyleft AGPL-3.0 licence, and the most advanced features live in the paid Grafana Cloud / Enterprise tiers.

 Go Grafana Labs AGPL-3.0
Prometheus Pull-based metrics collection and time-series database.
★ standard☁
☁ Infra
★ standard moderate 2012

The CNCF-graduated standard for metrics: it scrapes numeric time-series from instrumented targets at intervals, stores them in its own time-series database, and exposes the PromQL query language for slicing and alerting. Its pull model and label-based data model fit dynamic, container environments, which is why it’s the default metrics layer in Kubernetes.
3 use cases Collecting service and infrastructure metrics in Kubernetes. Show all
  • Collecting service and infrastructure metrics in Kubernetes.
  • Alerting on numeric thresholds via Alertmanager.
  • Feeding metrics dashboards (typically rendered in Grafana).
  • Observability concepts
4 features Pull-based scraping of metrics endpoints at intervals. Show all
  • Pull-based scraping of metrics endpoints at intervals.
  • Multi-dimensional, label-based data model.
  • PromQL query language for aggregation and alerting.
  • Alertmanager for routing and deduplicating alerts.

It’s built for metrics, not logs or traces, and a single server’s local storage doesn’t scale or replicate on its own — long-term, highly-available storage needs Thanos, Mimir, or a hosted backend. The pull model also means short-lived/batch jobs need a Pushgateway to be observed at all.

 Go CNCF Apache-2.0
OpenTelemetry The vendor-neutral standard for telemetry — traces, metrics, logs.
▲ rising☁🔧
☁ Infra🔧 Tooling
▲ rising steep 2019

A CNCF project defining a single, vendor-neutral standard and set of SDKs for generating telemetry — distributed traces, metrics, and logs — so you instrument your code once and export to any compatible backend (Datadog, Grafana, Honeycomb, …). The OTel Collector receives, processes, and routes that data, decoupling instrumentation from the vendor you happen to use.
3 use cases Instrumenting apps once and avoiding lock-in to one vendo... Show all
  • Instrumenting apps once and avoiding lock-in to one vendor’s SDK.
  • Distributed tracing across polyglot microservices.
  • Routing telemetry to multiple backends via the Collector.
  • Observability concepts
4 features Unified spec for traces, metrics, and logs. Show all
  • Unified spec for traces, metrics, and logs.
  • SDKs across many languages with a common data model.
  • OTel Collector to receive, transform, and export telemetry.
  • Backend-agnostic — export to most observability vendors.
  • Vendor-specific agents
  • OpenCensus

The breadth is also the cost — there’s a real learning curve to SDKs, exporters, the Collector, and sampling, and the signals have matured at different rates (tracing and metrics are stable; logs landed later). It’s a standard, not a backend: you still need somewhere (Grafana, Datadog) to store and visualize what it emits.

 multi CNCF Apache-2.0
PostHog Open-source product analytics + session replay + feature flags.
▲ rising☁🔧
☁ Infra🔧 Tooling
▲ rising moderate 2020

An all-in-one product analytics platform: event tracking, funnels, and cohorts, plus session replay, feature flags, A/B experiments, and surveys in one tool. It’s open source and self-hostable, with a hosted cloud option, positioning itself as a privacy-friendlier, developer-oriented alternative to stitching together several separate SaaS products.
3 use cases Product analytics — funnels, retention, and user cohorts. Show all
  • Product analytics — funnels, retention, and user cohorts.
  • Watching session replays to debug real user behaviour.
  • Feature flags and A/B experiments alongside the analytics.
4 features Event-based product analytics with funnels and cohorts. Show all
  • Event-based product analytics with funnels and cohorts.
  • Built-in session replay tied to analytics events.
  • Feature flags, experiments, and surveys in one platform.
  • Open source and self-hostable, plus a hosted cloud.

The breadth means more to configure and govern than a single-purpose tool, and session replay plus high event volume can get expensive on cloud and heavy to self-host. As with any analytics, recording user sessions raises privacy and consent obligations you must handle.

 Python/TypeScript PostHog MIT
LogRocket Frontend session replay with performance and error monitoring.
● mainstream🔧
🔧 Tooling
● mainstream gentle 2016

A frontend monitoring tool centered on session replay — it records what users actually did (DOM, network requests, console, Redux/state) so you can watch a pixel-perfect playback of a bug or a confusing flow. It layers performance metrics, error tracking, and analytics on top, aimed squarely at diagnosing client-side issues from the user’s perspective.
3 use cases Replaying a user's session to reproduce a frontend bug. Show all
  • Replaying a user’s session to reproduce a frontend bug.
  • Diagnosing UX friction and rage-clicks from real recordings.
  • Correlating frontend errors with the exact actions that triggered them.
4 features Pixel-accurate session replay with network and console ca... Show all
  • Pixel-accurate session replay with network and console capture.
  • Frontend error tracking tied to the recorded session.
  • Performance metrics including Core Web Vitals.
  • State/Redux capture for deep frontend debugging.

Recording sessions captures potentially sensitive user input, so you must configure input sanitization and meet privacy/consent rules before shipping. It’s frontend-focused and proprietary SaaS, and replay storage means pricing scales with session volume.

 — LogRocket proprietary