What Happened to the JavaScript Framework Wars?

TL;DR

The wars ended. The tier list solidified. React (~25M weekly downloads) dominates enterprise and the job market. Vue (~5M) held the midmarket. Svelte (~3M) became the developer-satisfaction champion for projects where bundle size and simplicity matter. Angular (~4M) retained enterprise legacy. The new frameworks (Solid, Qwik, Marko) found niches but didn't unseat the top three. The battle is over; the question is now "which tier of the framework landscape applies to my project?"

Key Takeaways

• React: ~25M weekly downloads — dominant; 65%+ of job postings require React
• Vue 3: ~5M downloads — strong midmarket; preferred in Asia-Pacific and Laravel ecosystem
• Angular: ~4M downloads — enterprise legacy; Google-backed, TypeScript-first
• Svelte: ~3M downloads — developer satisfaction leader; best for smaller teams, non-SPA
• Solid: ~800K downloads — performance-focused; React-like syntax, best Lighthouse scores

---

How the Dust Settled

The State of JS Survey 2025 Trend

Developer satisfaction scores (State of JS 2025):
1. Svelte:  92% satisfaction
2. Solid:   89% satisfaction
3. React:   83% satisfaction
4. Vue:     79% satisfaction
5. Angular: 71% satisfaction
6. Qwik:    71% satisfaction

Retention scores (would use again):
1. React:   79%  (massive installed base = massive retention)
2. Vue:     75%
3. Svelte:  81%  (small but loyal)
4. Angular: 65%

Usage (% of developers):
1. React:   83%
2. Angular: 49% (many enterprise devs)
3. Vue:     46%
4. Svelte:  23%
5. Solid:   6%

High satisfaction ≠ high usage. Svelte wins satisfaction; React wins usage. The reasons developers don't switch to higher-satisfaction frameworks: existing codebases, team skills, hiring pools.

---

React: Why It Won and Why It'll Stay

// React's moat is not technical — it's ecosystem
// 2026 React ecosystem:

Frameworks:        Next.js, Remix, Gatsby, TanStack Start
UI Libraries:      shadcn/ui, Radix, Headless UI, MUI, Ant Design
State:             Zustand, Jotai, Redux Toolkit, TanStack Query
Testing:           Testing Library (React-first), Vitest
Animation:         Framer Motion, Motion One, React Spring
Tables:            TanStack Table
Forms:             React Hook Form
Data Fetching:     TanStack Query, SWR
Auth:              Auth.js, Clerk, Lucia
Mobile:            React Native / Expo

Every category has React-first solutions.
Vue/Svelte equivalents exist but React gets them 6-12 months earlier.

# Job market reality (LinkedIn, March 2026)
"React developer":     ~85,000 postings (US)
"Vue developer":       ~12,000 postings
"Angular developer":   ~25,000 postings
"Svelte developer":    ~1,800 postings
"Next.js developer":   ~40,000 postings

Hiring pool size matters as much as developer experience.

---

Vue: The Stable Midmarket

// Vue 3 Composition API — shares React Hooks' mental model
import { ref, computed, onMounted } from 'vue';

export default defineComponent({
  setup() {
    const packages = ref<Package[]>([]);
    const query = ref('');

    const filteredPackages = computed(() =>
      packages.value.filter(p =>
        p.name.toLowerCase().includes(query.value.toLowerCase())
      )
    );

    onMounted(async () => {
      packages.value = await fetchPackages();
    });

    return { packages, query, filteredPackages };
  },
});

// Or Vue 3 script setup (simpler):
<script setup lang="ts">
const packages = ref<Package[]>([]);
const query = ref('');
const filteredPackages = computed(() =>
  packages.value.filter(p => p.name.includes(query.value))
);
</script>

Vue's niche in 2026:

• Laravel ecosystem — Laravel ships with Inertia.js; Vue is the default JS layer
• Asia-Pacific — strongest non-English community, especially China
• PHP/WordPress shops — gradual modernization path
• Enterprise with no React requirement — slightly less complex than React

---

Svelte: The Satisfaction Champion

<!-- Svelte — compiler approach, less framework code -->
<script lang="ts">
  import { onMount } from 'svelte';

  let packages: Package[] = [];
  let query = '';

  $: filteredPackages = packages.filter(p =>
    p.name.toLowerCase().includes(query.toLowerCase())
  );

  onMount(async () => {
    packages = await fetchPackages();
  });
</script>

<input bind:value={query} placeholder="Search packages..." />

{#each filteredPackages as pkg}
  <PackageCard {pkg} />
{/each}

Why Svelte scores high on satisfaction:

• No virtual DOM — compiles to vanilla JS
• Reactive statements with $: — no hooks, no dependency arrays
• True two-way binding with bind:
• Smaller bundle output than React for equivalent functionality
• SvelteKit is an excellent full-stack framework

Why it didn't surpass React:

• Smaller ecosystem (fewer UI libraries, fewer jobs)
• Every SvelteKit hire needs someone who knows Svelte specifically
• RSC has no Svelte equivalent; full-stack Svelte requires SvelteKit

---

The New Challengers: Solid, Qwik, and Others

Solid.js — Performance Leader

// Solid — React-like syntax, NO virtual DOM
import { createSignal, createEffect, For } from 'solid-js';

function PackageList() {
  const [packages, setPackages] = createSignal<Package[]>([]);
  const [query, setQuery] = createSignal('');

  const filtered = () =>
    packages().filter(p => p.name.includes(query()));
    // Note: packages is a FUNCTION (signal getter), not a value

  createEffect(() => {
    fetchPackages(query()).then(setPackages);
  });

  return (
    <For each={filtered()}>
      {(pkg) => <PackageCard pkg={pkg} />}
    </For>
  );
}

// Solid's performance advantage:
// No virtual DOM reconciliation
// Fine-grained reactivity (only the exact DOM nodes that changed update)
// Lighthouse scores consistently beat React by 20-30 points

Qwik — Resumability

// Qwik — zero JS on initial load, "resumable" not hydration
import { component$, useSignal } from '@builder.io/qwik';

export const Counter = component$(() => {
  const count = useSignal(0);

  return (
    <button onClick$={() => count.value++}>
      Count: {count.value}
    </button>
  );
});

// Qwik's model: serialize app state to HTML
// When user clicks, download ONLY the event handler code (not the whole component)
// vs React/Solid: download full component tree for hydration

// Reality check: impressive for content-heavy sites; complex for SPAs

---

The Tier List (2026)

Tier S: Use this for most new projects
  React + Next.js (full-stack, enterprise, job market)
  SvelteKit (team prefers simplicity, non-enterprise, content sites)

Tier A: Strong choice for specific contexts
  Vue 3 + Nuxt (Laravel ecosystem, PHP teams, Asia-Pacific)
  Angular (enterprise with existing Angular codebase or Google affinity)
  Astro (content-heavy, multi-framework, blog/marketing sites)

Tier B: Worth knowing, niche advantages
  Solid.js (performance-critical apps, React-compatible mindset)
  Remix (full-stack React, Web Standards over Vercel conventions)
  Qwik (resumability experiments, content sites with lots of JS)

Tier C: Interesting but limited ecosystem
  HTMX (hypermedia fans, Python/Ruby backend teams)
  Alpine.js (jQuery-replacement for server-rendered HTML)
  Marko (streaming SSR, massive scale)

---

Compare framework package health on PkgPulse.