· typescript / flow / javascript

TypeScript vs Flow — Flow's Last Stand in the 2026 Ecosystem

TypeScript has 244× more weekly downloads, native Node.js support, and a 10× faster compiler in 2026. Flow is alive at Meta — zombie-ware everywhere else.

By

2,032 words · 11 min read

Pick TypeScript for anything new. If you’re running Flow outside Meta, start planning the migration — the ecosystem gap is now wide enough that staying is an active cost. Flow is alive and actively maintained, but only for Meta’s internal use. For everyone else it’s zombie-ware: breathing, but unsupported where it counts.

Who this is for

Engineers picking a static type system for a new JS or React project, and teams already on Flow wondering whether to migrate. If you’re at Meta building something that touches React internals, this comparison is moot — Flow is your constraint, not your choice.

What we tested

TypeScript 6.0.3 (released 2026-03-23) and Flow 0.315.0 (released 2026-05-28). npm download data from npmtrends.com, May 2026 snapshot. IDE behaviour in VSCode 1.98 on macOS: TypeScript language service built-in, Flow Language Support extension v3.1.3. Incremental check benchmarks sourced from a May 2026 public test on a 50,000-line monorepo running on AWS EC2 G4dn.xlarge / Ubuntu 24.04 / 16 GB RAM.

Overview

TypeScript launched in 2012 as Microsoft’s answer to scaling JavaScript at enterprise size. Flow launched at Facebook in 2014 with a different thesis: gradual typing via per-file // @flow opt-in, integrated tightly with React and Babel’s AST.

For a few years the competition was real. Flow’s type inference was sharper in some areas, its React integration was first-party, and Facebook’s backing signalled longevity. The React community split: large Facebook-adjacent shops ran Flow, most of the broader ecosystem picked TypeScript or stayed untyped.

By 2026, the split is over. TypeScript won. The question now is whether there’s any legitimate reason to keep Flow on an existing codebase — or whether you’re just deferring a migration that will only get harder.

Ecosystem today (2026)

The download numbers tell the story bluntly.

TypeScript: ~143.7 million weekly npm downloads. Flow (via flow-bin): ~587,000. That’s a 244:1 ratio.

State of JS 2025 reported 40% of respondents write exclusively TypeScript — up from 34% in 2024 and 28% in 2022. Only 6% use plain JavaScript exclusively. Flow doesn’t appear in the survey at all, not even as a footnote.

TypeScript ranked #1 on GitHub by monthly contributors in August 2025: 2.6 million contributors, up 66% year-over-year.

The @types/* ecosystem — type definitions for third-party packages — is built almost entirely on TypeScript. When you import a package in TypeScript, there’s a high chance the IDE gives you autocomplete and error feedback with zero configuration. With Flow, you’re on your own for any package that doesn’t ship Flow types, which is most of them.

Real-world migrations also tell you which direction the current flows. Pinterest moved 3.7 million lines from Flow to TypeScript in April 2025. Stripe migrated 6.5 million lines using a custom codemod. Factorial moved 400,000+ lines. Nobody is migrating the other way.

Tooling

This is where the day-to-day experience diverges most.

IDE support

VSCode and TypeScript require zero configuration. TypeScript ships as part of VSCode itself — both are Microsoft products. Open a .ts file and you get full IntelliSense, error underlining, go-to-definition, rename, and refactor. No extension, no binary, no config file.

VSCode and Flow require the Flow Language Support extension (v3.1.3, rated 3/5 stars across 43 reviews). You also need a local Flow binary, a .flowconfig in the project root, and // @flow at the top of every file you want checked. The extension’s standalone repository was archived on December 19, 2024 — development moved into the main facebook/flow monorepo, but users spent roughly two years (January 2022 to December 2024) with no extension releases and reported IDE crashes, server hangs, and stale diagnostics.

The extension is in better shape now (v3.0 was a rewrite), but the trust damage is real. 3/5 stars after years of instability reflects the lingering doubt.

JetBrains (WebStorm, IntelliJ): both TypeScript and Flow have built-in support in 2026.1. TypeScript is deeper — tsconfig.json is auto-detected, the TypeScript Language Service is bundled, no per-file annotation needed. Flow support is present but secondary.

If your team runs Cursor — the AI-first editor built on VS Code — TypeScript’s zero-config setup means the AI features (autocomplete, inline edits, codebase-aware chat) work out of the box. Flow requires the same manual setup as VSCode, and the extension’s historical instability means the AI layer often gets stale or missing type context.

Node.js native type stripping

TypeScript 5.8 (February 2025) introduced --erasableSyntaxOnly, a flag that restricts TypeScript to syntax Node.js can natively strip. Node.js 22.18 (released July 31, 2025) shipped that native stripping as stable — you can now run .ts files directly with node in Node 22.18+ with no build step.

Flow has no equivalent path. It was never designed around the JS-runtime-first model TypeScript has converged on.

Migration tooling

When you’re ready to migrate from Flow to TypeScript, your main option is @khanacademy/flow-to-ts. Last published: April 27, 2021. Repository archived: April 26, 2024. It handles most object types, interfaces, function signatures, and React-specific types — but it self-describes as “WIP — many things still do not work properly.”

Stripe’s codemod (stripe-archive/flow-to-typescript-codemod) is also archived. Both tools treated migration as a closed problem once they’d served their internal purposes.

What that means practically: you run the codemod, it converts 80–90% of your codebase mechanically, and you spend weeks manually fixing the rest. The gap between “converted” and “compiles clean” can be large depending on how much Flow-specific syntax you’ve used.

For a TypeScript team completing the transition, Biome vs ESLint covers whether the 2026 linting ecosystem has shifted far enough to make a linter swap worthwhile as part of the same migration.

Performance

On raw incremental type-checking speed, Flow is faster today.

On a 50,000-line monorepo in watch mode, Flow completes an incremental check in 2.1 seconds. TypeScript takes 4.8 seconds — roughly 2.3× slower.

Meta’s internal data from 2021, after deploying their Types-First architecture, showed average recheck time dropping from 9.10s to 1.37s (−85%) and p99 recheck time dropping from 107s to 5.63s (−95%). Flow’s server model has always been architected around keeping incremental checks fast.

This advantage is real but probably temporary.

TypeScript 7.0 Beta launched April 21, 2026 with a Go-based compiler targeting ~10× faster performance than TypeScript 6.0. At 10×, TypeScript’s incremental check on the same 50K-line repo would drop to roughly 0.5 seconds — well below Flow’s 2.1s.

TypeScript 7.0 is in beta as of this writing. The Go compiler is the primary development target and production releases are expected in late 2026. Flow’s speed lead is on a timer.

It’s also worth noting: Flow’s ~50% Rust rewrite (visible in the repo’s language breakdown — 49.9% Rust, 30.3% OCaml — but never announced publicly) is presumably aimed at keeping performance competitive. But the rewrite hasn’t shipped publicly, and there’s been no announcement of what it targets.

DimensionTypeScriptFlow
Type inference✅ Advanced (satisfies, const params, conditional types)✅ Good (conditional types added 2024)
IDE support✅ Built-in VSCode (zero config)⚠️ Extension required (3/5 stars)
Strictness options✅ strict, noUncheckedIndexedAccess, etc.✅ flow strict mode
Community/ecosystem✅ 143M weekly downloads⚠️ 588K weekly downloads
Migration path— (already there)⚠️ flow-to-ts (archived 2024)
Active maintenance✅ Microsoft, quarterly releases✅ Meta, weekly releases
External adoption✅ 40% exclusive (State of JS 2025)❌ Not tracked in surveys
Speed (incremental)⚠️ 4.8s (50K repo)✅ 2.1s (50K repo)
Node.js native strip✅ Node 22.18+ (Jul 2025)❌ Not supported

Migration

If you’re on Flow and want out, here’s what you’re actually signing up for.

The codemod handles the easy parts. @khanacademy/flow-to-ts mechanically converts object types, interfaces, function signatures, React types, and generic annotations. You get approximately 80–90% of the conversion for free.

You fix the rest by hand. Three categories of Flow-specific syntax have no clean automated conversion:

  • %checks type predicates — removed with a warning, logic must be re-implemented as TypeScript type predicates
  • $Keys<T> utility type — equivalent is keyof T, but the codemod doesn’t always catch it in context
  • $FlowFixMe suppression comments — need to become // @ts-ignore or // @ts-expect-error

A minimal before/after to illustrate what the easy path looks like:

// BEFORE (Flow)
// @flow
type User = {
  id: number,
  name: string,
  email: ?string,
};

function greet(user: User): string {
  return `Hello, ${user.name}`;
}

const getUser = (id: number): Promise<User> =>
  fetch(`/users/${id}`).then(r => r.json());
// AFTER (TypeScript)
type User = {
  id: number;
  name: string;
  email: string | null;  // ?T becomes T | null
};

function greet(user: User): string {
  return `Hello, ${user.name}`;
}

const getUser = (id: number): Promise<User> =>
  fetch(`/users/${id}`).then(r => r.json());

Key syntax differences:

  • ?T (nullable) → T | null
  • Trailing commas in object types → semicolons (or commas; both valid in TypeScript)
  • // @flow removed — TypeScript is opt-out via tsconfig.json, not opt-in per file
  • $Keys<T> → keyof T
  • $Values<T> → T[keyof T]

Scale matters. Pinterest’s 3.7 million line migration took significant engineering time even with automation. Stripe’s required a custom multi-step codemod (Babel conversion pass + ts-morph error-fixing pass) to handle their React-heavy codebase. Neither company found a push-button solution.

The practical implication: start the migration before your team adds another million lines of Flow code. The gap between flow-to-ts’s last publish (2021) and today (2026) is five years. It won’t get better.

Verdict

Flow is not dead. It has weekly releases, a near-total Rust rewrite in progress (unreleased), and React Component Syntax already deployed across Meta’s codebases. Meta is running it on hundreds of millions of lines of internal code and betting engineering resources on it.

But “not dead” is a low bar. For anyone outside Meta, Flow in 2026 is zombie-ware. The ecosystem has moved on, the IDE tooling has a fractured history, the migration tooling is archived, and the only reason to stay on Flow is the cost of migrating off it.

ScenarioRecommendationRationale
Greenfield projectTypeScriptEcosystem, IDE, Node native strip, TS 7.0 incoming
Legacy Flow codebase (external company)Plan migrationflow-to-ts archived; gap widens yearly; TS 7.0 closes speed advantage
Legacy Flow codebase at Meta scaleFlow for nowInternal tooling, React coordination, proven incremental performance
Team already on TypeScriptStayNothing in Flow justifies switching

The “last stand” framing in this article’s title is accurate for the external ecosystem. Flow’s last stand is happening entirely inside Meta’s walls. Outside them, the decision was made years ago — the 244:1 download ratio is the scoreboard.

If backend language is still an open question and Go is on the shortlist alongside TypeScript, Go vs TypeScript for backend services breaks down how the runtime and ecosystem tradeoffs land in 2026. If you’ve settled on TypeScript, TypeScript strictness and real bug rates covers which strict-mode settings actually move the quality needle.

Caveats

The incremental benchmark used a single 50,000-line repo on specific hardware. Your numbers will differ. TypeScript 7.0’s 10× claim is based on benchmarks Microsoft ran on their own test suite; independent validation is pending. The @khanacademy/flow-to-ts archive means its behaviour may diverge from current Flow syntax over time — test on a branch before running it across production code.

The Cursor link above (/go/cursor) is an affiliate link.

References