React

Drive the product through a documented public API G

Agent access

Connect an agent via an official MCP server G

Agent access

Delegate tasks to a built-in AI assistant inside the product G

Agentic features

Plug MCP servers into this product so it can use their tools G

Agent access

Point an agent at llms.txt or agent-oriented docs G

Agent access

Download a machine-readable API spec (OpenAPI or equivalent) G

Api quality

Build against official SDKs G

Agent access

Explore an interactive API reference with runnable examples G

Api quality

Get AI-generated insights and suggestions from my data inside the product G

Agentic features

Issue scoped/least-privilege API credentials for an agent G

Agent access

Operate the product with natural-language commands G

Agentic features

Rely on versioned APIs with a documented deprecation policy G

Api quality

Run the product headlessly / in CI for automation G

Agent access

Set up automations that run autonomously in the background G

Agentic features

Subscribe to events via webhooks G

Agent access

Use an official CLI G

Agent access

Test against a sandbox environment without touching production data G

Api quality

Build encapsulated components that manage their own local state and compose them into complex UIs C

Component encapsulation

Render my application on the server with streaming support to reach interactivity faster C

Server rendering streaming

Use an official full-stack meta-framework built on top of the framework for routing and data fetching C

Meta framework fullstack

Write markup and rendering logic together in a single component using HTML, CSS, and JavaScript I already know C

Unified markup logic

Stream server-rendered content so pages get faster perceived loads before all JavaScript arrives C

Streaming page loads

Declare reactive state and have only the dependent UI code re-run when it changes C

Fine grained reactivity

Self-host the core product G

Whether the framework is governed by a foundation or a single company, so I can assess long-term continuity and lock-in risk C

Governance risk

Write components using standard HTML, CSS, and JavaScript syntax I already know, minimizing new concepts to learn C

Approachable familiar syntax

Scaffold and run a new project in just a few minutes using an official CLI or starter C

Quick project scaffolding

Use an official first-party routing library that integrates seamlessly with the framework C

Official routing library

Define rules that trigger actions automatically on events G

Export all of my data in open formats and leave G

Get accurate autocompletion and inline type errors in my editor via a language service integration C

Ide autocompletion

Get automatic type inference for component props and emitted events without writing extra type annotations C

Typed props inference

Prevent my data from being used to train AI models G

Ship a small, dependency-light JS bundle to minimize runtime footprint and reduce supply-chain risk C

Bundle size

Use official testing utilities to render and interact with components in isolation C

Component testing utilities

Drop the framework into an existing server-rendered HTML page and render interactive components without rewriting the whole page C

Incremental html integration

Incrementally adopt the framework, scaling from a small part of a page up to a full application C

Incremental adoption

Read the product's source under an open license G

Build large applications that stay fast and maintainable as my team and codebase grow C

Scales with app size

Use the framework directly via a script tag without needing a package manager or bundler C

Buildless usage

Debug my UI directly in browser devtools because the framework renders real DOM nodes C

Direct dom debugging

Fetch data in asynchronous server-rendered components and pass it down to interactive client components C

Async server data fetching

Hydrate my server-rendered app progressively so pages become interactive faster C

Progressive hydration

Reuse my framework skills and code to build performant native mobile apps for iOS and Android C

Shared code native mobile

Organize my app into modular, dependency-injected building blocks C

Dependency injection modules

Treat server-loaded data as reactive state and build a responsive loading UI for it using resource and suspense primitives C

Server data as reactive resources

Deploy my server-rendered app to serverless or edge runtimes without custom infrastructure setup C

Deployment targets

Manage global application state using built-in primitives without adding a third-party library C

Global state primitives

Trace state changes through explicit, predictable data flow instead of debugging implicit two-way bindings C

Explicit state flow

Build native desktop applications by reusing my framework's component model and tooling C

Cross platform app development

Get compile-time type checking inside my component templates, not just script blocks C

Typed templates

Rely on a compiler to translate my components into efficient, surgical DOM updates instead of writing manual diffing code C

Compiler driven updates

Rely on a compiler-optimized rendering system that updates the DOM without a virtual DOM diffing step C

No virtual dom overhead

Try an in-browser interactive tutorial to learn the framework hands-on without any local setup C

Interactive browser tutorial

Check a public status page and incident history for the framework's official hosting/deploy platform before relying on it in production G

Deploy platform ops

Choose where my data is stored (region/residency) G

Control data retention and deletion G

Do everything through the API that I can do in the UI G

Follow a dedicated migration guide when moving between two incompatible major versions of the framework C

Major version migration guide

Follow an official upgrade guide to move my existing project to a newer version G

Version upgrade guide

Get built-in accessibility warnings during development instead of relying on separate audit tools G

Accessibility testing

Get clear, actionable error messages from the dev server and build tool when something breaks C

Dev server error diagnostics

Have AI generate component-level tests based on the props and reactive state my component declares C

Ai generated component tests

How the framework's build and type-check times scale in large, multi-thousand-component codebases or monorepos C

Scale limits

Integrate official end-to-end testing tools that work out of the box with the framework's dev server C

E2e testing integration

Opt out of telemetry and usage tracking G

Perform bulk operations across many items at once G

Pick from a rich ecosystem of third-party pre-built UI component libraries for the framework C

Component library ecosystem

Review the project's public CVE/security-advisory history to judge its track record of handling and disclosing vulnerabilities G

Security track record

Schedule recurring jobs or workflows G

The framework's officially supported browser matrix so I can plan polyfills or decide when to drop legacy support C

Browser support

Unit test my reactive state and logic without needing to render the DOM C

State logic unit testing

Use AI tooling that automatically resolves type errors surfaced by the framework's type system C

Ai assisted type inference fixes

Use AI-powered devtools that analyze my component tree and suggest specific rendering or reactivity optimizations C

Ai assisted performance profiling

Use an official first-party state management library maintained alongside the framework C

Official state management library

Use first-party modules for building and validating forms that integrate with the rest of the framework C

First party forms support

Which TypeScript versions the framework officially supports so I can avoid compatibility breaks when upgrading either one C

Typescript version support

Write custom renderers so the framework's component model can target platforms other than the browser DOM C

Custom renderer targets

Author standards-based web components and custom elements using the framework C

Web components authoring

Check a public roadmap to see what the core team is currently working on C

Public roadmap visibility

Continue receiving security updates for an older major version while I plan my migration C

Legacy version security support

Directly manipulate the DOM to integrate native JavaScript libraries like charting or visualization tools C

Direct dom manipulation integration

Find and join a local in-person user group or meetup for the framework C

Local user groups

Join an official community chatroom to get help and connect with other framework users C

Community chat support

Version, review, and roll back my automations G