📚 JavaScript Topics

A comprehensive reference guide covering JavaScript from fundamentals to advanced topics — updated for 2026 with ES2025 and ES2026 features.

Legend:

• 🆕 [ES2024] — Added in ECMAScript 2024
• ✨ [ES2025] — Added in ECMAScript 2025 (finalized June 2025)
• 🚀 [ES2026] — Finalized or Stage 4 for ECMAScript 2026
• 🔥 [2026 Trend] — Ecosystem shift as of 2026

Important correction from prior edition: Several features listed as [ES2024] in earlier versions of this guide were finalized in ES2025. The table below reflects the correct edition assignments per the TC39 finished proposals list.

---

📋 Table of Contents

• Basic Syntax and Concepts
• Advanced Concepts
• DOM Manipulation
• Browser APIs
• Modern JavaScript Features
• JavaScript Tooling
• Frameworks and Libraries
• State Management
• Server-side JavaScript
• Testing and Debugging
• Performance Optimization
• Security
• Progressive Web Apps (PWAs)
• WebAssembly (Wasm)
• Machine Learning in JavaScript
• WebGL and 3D Graphics
• Functional Programming
• Design Patterns
• TypeScript
• Web Components
• Accessibility
• Cross-platform Development
• GraphQL
• Serverless Architecture
• Microservices
• Blockchain and Cryptocurrency
• WebRTC
• Web Development Best Practices
• Emerging Trends

---

🔤 Basic Syntax and Concepts

Variables

• Declaration (var, let, const)
• Variable scope (global, function, block scope)
• Variable hoisting
• Variable redeclaration and shadowing
• Naming conventions and best practices
• using / await using — Explicit Resource Management for block-scoped cleanup 🚀 [ES2026]

Data Types

• Primitive types: string, number, boolean, null, undefined, symbol, bigint
• Object data type
• Type coercion and conversion
• Checking types with typeof, instanceof
• Equality comparisons (== vs ===)
• String.prototype.isWellFormed() and toWellFormed() for Unicode safety 🆕 [ES2024]
• Float16Array — 16-bit floating-point typed array for ML/GPU workloads ✨ [ES2025]

Operators

• Arithmetic, assignment, comparison, logical, bitwise operators
• Ternary operator
• Pipeline operator (|>) — Stage 2 proposal 🔥 [2026 Trend]
• Math.sumPrecise(iterable) — accurate floating-point summation without drift 🚀 [ES2026]

Control Flow

• Conditional statements (if...else, switch)
• Loops (for, while, do...while) and loop control (break, continue)
• Pattern matching — Stage 2 proposal; expressive alternative to switch/if chains 🔥 [2026 Trend]

Functions

• Function declaration vs expression
• Arrow functions, anonymous functions
• Parameters, arguments, return statement
• Function scope and hoisting

Objects

• Creation via object literals, constructor functions, classes
• Property access (dot notation, bracket notation)
• Adding, deleting, and iterating properties
• Object.groupBy() / Map.groupBy() — group iterables by key 🆕 [ES2024]

Arrays

• Array creation and common methods (push, pop, map, filter, reduce, etc.)
• Immutable methods: toSorted(), toReversed(), toSpliced(), with() 🆕 [ES2024]
• Array.fromAsync() for async iterables ✨ [ES2025]
• Destructuring, multidimensional arrays, mutating vs non-mutating methods

✏️ Correction: Array.fromAsync() was finalized in ES2025, not ES2024 as stated in older references.

---

⚙️ Advanced Concepts

Closures

• Lexical scope and closure relationship
• Creating closures and practical examples
• Memory management and common pitfalls

Prototypes and Inheritance

• Prototype chain and object prototypes
• Prototypal vs classical inheritance
• Object.create() vs new keyword

Promises

• States: pending, fulfilled, rejected
• Chaining and error handling
• Promise.all(), Promise.race(), Promise.allSettled(), Promise.any()
• Promise.withResolvers() — expose resolve/reject outside constructor 🆕 [ES2024]
• Promise.try() — wrap sync/async uniformly in a Promise chain ✨ [ES2025]

Asynchronous Programming

• Callbacks and callback hell
• Async/Await syntax
• Top-level await in ES modules
• Event loop and concurrency model
• setTimeout, setInterval, requestAnimationFrame
• scheduler.yield() / scheduler.postTask() — cooperative task scheduling for better INP 🔥 [2026 Trend]

Modules

• CommonJS (require / module.exports)
• ES Modules (import / export, static vs dynamic)
• Import Attributes (import ... with { type: 'json' }) ✨ [ES2025]
• Import Defer — lazy module evaluation until first property access 🚀 [ES2026]
• Native TypeScript support in Node.js 22+ (no build step needed) 🔥 [2026 Trend]

Generators

• function* syntax, yield keyword, iterator protocol
• Iterator helpers — .map(), .filter(), .take(), .drop(), .toArray() on iterators natively ✨ [ES2025]
• Async generators and for await...of

Decorators

• Standardized in ES2025 (Stage 4 / TC39 finished) ✨ [ES2025]
• Natively supported in TypeScript 5.0+ and Babel
• Class, method, accessor, and field decorators
• Common use cases: logging, validation, dependency injection, memoization

Explicit Resource Management 🚀 [ES2026]

• using — synchronous resource disposal at block exit (implements [Symbol.dispose])
• await using — async disposal (implements [Symbol.asyncDispose])
• DisposableStack / AsyncDisposableStack — manage groups of disposables
• Replaces try/finally patterns for file handles, DB connections, timers

---

🌐 DOM Manipulation

Selecting Elements

• getElementById, getElementsByClassName, querySelector, querySelectorAll
• Performance considerations and scoped selection

Modifying Elements

• innerHTML vs textContent vs innerText
• Attribute manipulation, inline styles vs CSS classes
• Adding, removing, and toggling classes

Creating and Removing Elements

• createElement, appendChild, insertBefore, removeChild

Event Handling

• addEventListener — preferred over inline handlers
• Event bubbling vs capturing, event delegation
• Removing event listeners
• AbortSignal to remove multiple listeners at once 🔥 [2026 Trend]

DOM Traversal

• parentElement, children, nextElementSibling, previousElementSibling

AJAX and Fetch API

• XMLHttpRequest and the Fetch API
• Handling responses, CORS, error handling, JSON data

---

🌍 Browser APIs

• Web Storage — localStorage, sessionStorage (storage, retrieval, limits)
• Geolocation — current position, watching changes, permissions
• Web Workers — dedicated and shared workers, off-main-thread computation
• OffscreenCanvas — canvas rendering in a Worker 🔥 [2026 Trend]
• WebSockets — real-time bidirectional communication
• Canvas API — drawing shapes, text, images, animations
• View Transitions API — native animated page/state transitions; same-document now Baseline 🔥 [2026 Trend]
• Intersection Observer / Resize Observer — performant scroll and layout effects
• Web Share API, Clipboard API, File System Access API
• Drag and Drop API
• Popover API — native floating overlays, now Baseline 🔥 [2026 Trend]
• Speculation Rules API — prerender next pages for near-instant navigation 🔥 [2026 Trend]
• scheduler.yield() — yield to browser mid-task; directly improves INP 🔥 [2026 Trend]

---

✨ Modern JavaScript Features

ES6+ Foundations (Still Essential in 2026)

• Arrow functions, template literals, destructuring
• Spread/rest operators, default parameters
• let and const, classes, ES Modules
• Iterators, Symbols, Proxy, Reflect
• WeakRef and FinalizationRegistry

ES2022 & ES2023 (Widely Supported)

• Top-level await
• Private class fields and methods (#name)
• Static class blocks
• Error cause — new Error('msg', { cause: err })
• Array.at(), String.at() — negative index access
• Object.hasOwn() — safer than hasOwnProperty
• Array.findLast(), Array.findLastIndex()

ES2024 Features 🆕

Feature	Description
Promise.withResolvers()	Expose resolve/reject outside constructor
Object.groupBy() / Map.groupBy()	Group iterables by key
String.isWellFormed() / toWellFormed()	Safe Unicode handling
RegExp /v flag	Set notation and improved Unicode matching
ArrayBuffer.prototype.transfer()	Resizable / transferable ArrayBuffers
Array.fromAsync()	⚠️ Moved to ES2025 — see note below
Immutable Array methods	toSorted(), toReversed(), toSpliced(), with()

✏️ Correction: Array.fromAsync() is confirmed as an ES2025 feature in the TC39 finished proposals list, not ES2024.

ES2025 Features ✨

Feature	Description
Iterator helpers	.map(), .filter(), .take(), .drop(), .flatMap(), .toArray() on all iterators
Import Attributes	import x with { type: 'json' } — native JSON/CSS module imports
Decorators	Standardized class/method/accessor decoration
Set methods	union(), intersection(), difference(), symmetricDifference(), isSubsetOf(), isSupersetOf(), isDisjointFrom()
RegExp.escape()	Safely escape user input for use in a RegExp
Promise.try()	Wrap sync/async uniformly — sync throws become rejections
Float16Array	16-bit float typed array for ML/GPU workloads
Explicit Resource Management	using / await using — deterministic cleanup at block exit
Array.fromAsync()	Create arrays from async iterables

ES2026 Features 🚀 (Finalized or Stage 4)

Feature	Status	Description
Temporal API	Stage 3 → 4	Immutable, timezone-aware replacement for Date
Math.sumPrecise()	Stage 4	Compensated (accurate) summation of an iterable
Import Defer	Stage 3	Lazy module evaluation until first use
ArrayBuffer Base64	Stage 4	Native Uint8Array.fromBase64() / .toBase64()
Error.isError()	Stage 4	Reliable cross-realm error detection
Intl locale improvements	Stage 4	More precise control over locale, calendar, numbering

🚀 ES2026 finalization timeline: Stage 4 proposals are incorporated at the March TC39 meeting; the Ecma General Assembly approves in July 2026.

Optional Chaining & Nullish Coalescing

• ?. — safely access nested properties
• ?? — differs from || for 0 and empty strings
• Logical assignment: &&=, ||=, ??=

---

🛠 JavaScript Tooling

Package Managers

Tool	Notes
npm	Still most widely used; workspaces, corepack
pnpm	Content-addressable, fastest installs 🔥
yarn (v4)	Plug'n'play, zero-installs
Bun	Ultra-fast, built into Bun runtime 🔥

Runtimes

Runtime	Notes
Node.js 22+	Native TypeScript type stripping; LTS in 2026 🔥 [2026 Trend]
Bun	All-in-one: runtime, bundler, package manager, test runner 🔥 [2026 Trend]
Deno 2	Node.js compatible, built-in TS/JSX, secure by default 🔥 [2026 Trend]

Bundlers & Build Tools

Tool	Notes
Vite 6	Surpassing Webpack; fast HMR, Environment API 🔥
Webpack 5	Still widely deployed in enterprise
Rolldown	Rust-based, Vite-native bundler; powers Vite 6 internals 🔥
Turbopack	Rust bundler, integrated with Next.js 15 🔥
esbuild	Ultra-fast Go-based, used by Vite and others
Rspack	Rust-based Webpack-compatible bundler (ByteDance) 🔥

Linters & Formatters

Tool	Notes
ESLint v9	Flat config (eslint.config.js) is now the default 🔥
Prettier	Opinionated formatter
Biome	Rust-based all-in-one linter + formatter; replaces both 🔥
Oxlint	Extremely fast, from the Oxc ecosystem 🔥

Testing Frameworks

Tool	Notes
Vitest	Vite-native, Jest-compatible; the default for new projects 🔥
Jest	Still widely used; being replaced by Vitest in new setups
Playwright	Cross-browser E2E by Microsoft; preferred over Cypress 🔥
Cypress	E2E + component testing

---

🏗 Frameworks and Libraries

React

• React 19 / 19.2 — Actions, useActionState, useOptimistic, use(), <Activity /> 🔥 [2026 Trend]
• React Compiler — stable release (2025); auto-memoization, eliminates manual useMemo/useCallback 🔥 [2026 Trend]
• Server Components and Server Actions (RSC model)
• React Router v7 / TanStack Router

Meta-Frameworks for React

• Next.js 15 — App Router, Server Actions, Partial Pre-rendering
• TanStack Start — rising full-stack React alternative with RSC support 🔥
• Remix / React Router v7 — web-standards-first full-stack
• Astro — islands architecture, zero-JS by default 🔥

Vue.js

• Vue 3 with Composition API as the standard
• Pinia replacing Vuex as the official state manager
• Nuxt 3 built on Vite and Nitro

Svelte

• Svelte 5 with Runes — fine-grained reactivity; Runes are the new default 🔥 [2026 Trend]
• SvelteKit for full-stack SSR/SSG/edge support

Angular

• Angular 17+ — standalone components as default
• Signals for reactive state management 🔥
• Zoneless change detection stable in Angular 18+

Other Notable Frameworks

• Solid.js — fine-grained signals reactivity, no virtual DOM 🔥
• Hono — ultralight, highest satisfaction in surveys, edge-ready 🔥
• Qwik — resumable for instant load performance
• Lit — lightweight Web Components

Backend Frameworks

Framework	Notes
Express.js	#1 in usage; widely deployed
Fastify	Faster, schema-validated, TypeScript-ready
NestJS	TypeScript-first, Angular-inspired
Hono	Highest satisfaction; edge-native, runs on Cloudflare/Deno/Bun 🔥
ElysiaJS	Bun-native, end-to-end type safety 🔥

---

🗃 State Management

Client-side State

Library	Notes
Redux Toolkit	Modern Redux, less boilerplate
Zustand	Minimal, hook-based; most popular lightweight option 🔥
Jotai	Atomic state model
Signals	Native in Angular, Vue, Svelte 5, Solid, Preact; TC39 proposal advancing 🔥

Server State

Library	Notes
TanStack Query	Caching, background refetch; de facto standard for async state 🔥
SWR	Stale-while-revalidate (Vercel)
Apollo Client	For GraphQL-backed apps

---

🖥 Server-side JavaScript

Node.js Fundamentals

• Event-driven architecture, modules, npm packages
• File system (fs), streams, buffers
• Async programming: callbacks, Promises, async/await
• Native TypeScript type stripping in Node.js 22+ — run .ts files directly 🔥 [2026 Trend]

Creating RESTful APIs

• REST architecture, CRUD operations
• Routing, middleware, authentication, versioning

Authentication & Authorization

• JWT, OAuth 2.0 / OIDC, session-based auth
• Passkeys / WebAuthn — modern passwordless auth; now broadly adopted 🔥 [2026 Trend]
• Role-based access control (RBAC)

Edge Computing 🔥

• Running JS at the edge (Cloudflare Workers, Deno Deploy, Vercel Edge)
• Hono as the leading edge framework
• WinterCG / WinterTC — interoperability standards for non-Node runtimes

---

🧪 Testing and Debugging

Testing Strategies

• Unit testing with Vitest (preferred) or Jest
• Integration testing
• E2E testing with Playwright (preferred) or Cypress
• Component testing (Vitest Browser Mode) 🔥 [2026 Trend]

Debugging Techniques

• Console methods (log, warn, error, table, time)
• Chrome DevTools — Elements, Console, Network, Performance, Sources
• Breakpoints, call stack inspection, async debugging
• Source maps for transpiled/bundled code
• React Performance Tracks in Chrome DevTools (React 19.2+) 🔥 [2026 Trend]

---

⚡ Performance Optimization

Bundling & Loading

• Code splitting with dynamic imports
• Lazy loading modules, images, and routes
• Tree shaking — eliminating dead code
• Minification with Terser or esbuild

Runtime Performance

• Memoization (useMemo, useCallback, React Compiler auto-memoization)
• Debouncing and throttling
• Signals for fine-grained reactivity (fewer re-renders) 🔥 [2026 Trend]
• Web Workers for CPU-intensive tasks
• scheduler.yield() — break up long tasks to improve INP 🔥 [2026 Trend]

Core Web Vitals

• LCP (Largest Contentful Paint) — target < 2.5s
• CLS (Cumulative Layout Shift) — target < 0.1
• INP (Interaction to Next Paint) — replaced FID in March 2024; target < 200ms 🔥 [2026 Trend]
• Performance profiling with Lighthouse and Chrome DevTools

---

🔒 Security

• XSS — input sanitization, Content Security Policy (CSP), Trusted Types
• CSRF — anti-CSRF tokens, SameSite=Lax/Strict cookie attribute
• Authentication — password hashing (bcrypt/Argon2), MFA, Passkeys/WebAuthn 🔥
• Authorization — RBAC, ABAC, JWT best practices
• HTTPS / HSTS — enforcing secure connections
• Input validation — client and server side; Zod/Valibot for schema-based validation
• RegExp.escape() — prevent regex injection ✨ [ES2025]
• Dependency security — npm audit, Dependabot, SBOM, supply chain awareness
• Sanitizer API — native browser alternative to DOMPurify (emerging) 🔥 [2026 Trend]

---

📱 Progressive Web Apps (PWAs)

• Service Workers — caching strategies, offline support, lifecycle
• Web App Manifest and "Add to Home Screen"
• Push Notifications and Background Sync
• Offline-first data with IndexedDB
• PWA capabilities expanding: File System Access, NFC, Bluetooth 🔥 [2026 Trend]
• iOS Safari fully supporting Push API and install prompts 🔥 [2026 Trend]

---

🧩 WebAssembly (Wasm)

• Binary format and JavaScript interop
• Performance-critical use cases (image processing, games, codecs)
• WASI — WebAssembly System Interface for server-side Wasm 🔥 [2026 Trend]
• Component Model — composable Wasm modules across languages 🔥 [2026 Trend]
• WasmGC — garbage collection for Wasm; enables Kotlin/Dart → Wasm 🔥 [2026 Trend]
• Wasm in edge/serverless environments 🔥 [2026 Trend]

---

🤖 Machine Learning in JavaScript

• TensorFlow.js — training and inference in browser or Node.js
• ONNX Runtime Web — run ONNX models in the browser 🔥 [2026 Trend]
• WebGPU — accelerated ML inference, now broadly supported 🔥 [2026 Trend]
• WebNN API — neural network inference using dedicated hardware 🔥 [2026 Trend]
• AI SDK (Vercel) — framework-agnostic LLM-powered UIs 🔥 [2026 Trend]
• On-device models (Gemini Nano via Prompt API, WebLLM) running in-browser 🔥 [2026 Trend]
• ML5.js and Brain.js for beginner-friendly ML
• MCP (Model Context Protocol) integrations for JS frameworks 🔥 [2026 Trend]

---

🎨 WebGL and 3D Graphics

• WebGL 2 — rendering pipeline, shaders (GLSL)
• WebGPU — next-generation graphics and compute API; broadly supported in 2026 🔥 [2026 Trend]
• Three.js — 3D scenes, geometries, materials, lighting
• React Three Fiber — React renderer for Three.js 🔥 [2026 Trend]
• Babylon.js — feature-rich 3D/XR engine
• WGSL — WebGPU shading language 🔥 [2026 Trend]

---

🔧 Functional Programming in JavaScript

• Higher-order functions (map, filter, reduce)
• Immutability — spreading, Immer, native toSorted()/toReversed() methods
• Pure functions and avoiding side effects
• Recursion and tail recursion optimization
• Function composition with pipe and compose
• Iterator helpers enabling lazy functional pipelines natively ✨ [ES2025]
• Math.sumPrecise() for precise reductions over numeric iterables 🚀 [ES2026]

---

🏛 Design Patterns

• Singleton — single instance guarantee
• Factory — Simple Factory, Factory Method, Abstract Factory
• Observer / Pub-Sub — foundational to Signals 🔥 [2026 Trend]
• Strategy — encapsulating interchangeable algorithms
• Module — revealing module pattern, ES modules
• MV* patterns — MVC, MVP, MVVM
• Flux / Redux — unidirectional data flow
• Explicit Resource pattern — using / DisposableStack for lifecycle management 🚀 [ES2026]

---

🔷 TypeScript

Fundamentals

• Static typing, type inference, type annotations
• Interfaces, type aliases, union and intersection types
• Generics and utility types (Partial, Readonly, Pick, Record)
• Type guards, discriminated unions, narrowing

TypeScript in 2026 🔥

• TypeScript 5.x — standardized decorators (ES2025), const type parameters
• Native type stripping in Node.js 22+ (run .ts files without compilation)
• Deno 2 and Bun support TypeScript natively out-of-the-box
• TypeScript is now the de facto default for new JS projects
• tsconfig paths and project references for monorepos
• Go-based TypeScript compiler (tsc 7 preview) — dramatically faster type-checking 🔥 [2026 Trend]

---

🧱 Web Components

• Custom Elements — defining custom HTML elements
• Shadow DOM — encapsulated styles and DOM
• HTML Templates — <template> element
• Scoped Custom Element Registries 🔥 [2026 Trend]
• Declarative Shadow DOM (<template shadowrootmode="open">) — server-rendered shadow roots 🔥 [2026 Trend]
• Lit — lightweight Web Component authoring library
• Custom State Pseudo-Class API (:state()) — expose internal states to external CSS 🔥 [2026 Trend]

---

♿ Accessibility

• Semantic HTML — document structure, appropriate elements
• ARIA attributes — roles, properties, states, live regions
• Keyboard accessibility and focus management
• Screen reader compatibility
• Color contrast, prefers-reduced-motion, prefers-contrast
• WCAG 2.2 — current standard; WCAG 3.0 in active development 🔥 [2026 Trend]
• Automated testing with axe-core, Lighthouse, Playwright
• :focus-visible — keyboard-only focus styles 🔥 [2026 Trend]

---

📱 Cross-platform Development

Tool	Notes
React Native	New architecture (JSI/Fabric) stable; Expo as the standard setup 🔥
Expo	React Native toolkit with Expo Router; recommended starting point 🔥
One (React)	Shared web + native codebase from TanStack creator 🔥
NativeScript	Native APIs from JS/TypeScript
Ionic	Hybrid mobile with web technologies
Electron	Desktop apps with web tech
Tauri 2	Rust-based lighter Electron alternative; mobile support added 🔥

---

🔗 GraphQL

• Query language basics — queries, mutations, subscriptions, directives
• Setting up with Apollo Server, GraphQL Yoga, or Pothos
• Apollo Client for React/Angular/Vue
• tRPC — type-safe API without a schema layer 🔥 [2026 Trend]
• Persisted queries, DataLoader for N+1 prevention

---

☁️ Serverless Architecture

• AWS Lambda, Azure Functions, Google Cloud Functions
• Edge functions — Cloudflare Workers, Vercel Edge, Deno Deploy 🔥 [2026 Trend]
• Serverless frameworks: Serverless Framework, SST v3, AWS SAM
• Durable Objects for stateful serverless (Cloudflare) 🔥 [2026 Trend]

---

🔀 Microservices

• Microservices principles (single responsibility, bounded contexts)
• Service-to-service communication (REST, gRPC, event-driven)
• Containerization with Docker
• Orchestration with Kubernetes
• Service mesh (Istio, Linkerd)
• Local-first / sync engine architecture as emerging alternative 🔥 [2026 Trend]

---

₿ Blockchain and Cryptocurrency

• Blockchain fundamentals (distributed ledger, consensus mechanisms)
• Web3.js and Ethers.js for Ethereum interaction
• Smart contracts with Solidity and Hardhat
• Decentralized applications (DApps)
• Cryptocurrency wallets and key management

---

📡 WebRTC

• Real-time peer-to-peer communication (audio, video, data channels)
• Signaling, ICE, STUN/TURN servers
• Video conferencing and screen sharing
• Peer-to-peer data sharing use cases

---

✅ Web Development Best Practices

• Code organization — modularization, separation of concerns
• Version control — Git branching, conventional commits, pull requests
• Documentation — JSDoc, README, Storybook for UI components
• Code reviews — PR process, constructive feedback, automated checks
• CI/CD — GitHub Actions, automated testing and deployment
• Monorepo tooling — Turborepo, Nx, pnpm workspaces 🔥 [2026 Trend]
• Agile — Scrum, Kanban, sprints, retrospectives
• Progressive enhancement — HTML baseline → CSS → JS → modern APIs 🔥 [2026 Trend]

---

🚀 Emerging Trends (2025–2026)

AI Integration in JavaScript Development

• AI-assisted coding (GitHub Copilot, Cursor, Claude Code) transforming developer workflows
• Vercel AI SDK and TanStack AI for LLM-powered UIs
• MCP (Model Context Protocol) — standardized tool protocol connecting AI agents to APIs and services
• On-device AI inference via WebGPU, WebNN, and the Chrome Prompt API (Gemini Nano)
• LLM-first frameworks designed to be generated and debugged by AI agents

Signals and Fine-Grained Reactivity

• Signals now adopted by Angular, Vue, Svelte 5 (Runes), Solid, and Preact
• TC39 Signals proposal (Stage 1) — standardizing reactive primitives in JavaScript
• Fine-grained updates without virtual DOM diffing; directly improves INP

Tooling Consolidation

• Vite surpassing Webpack; Vitest replacing Jest in new projects
• Rust-based tools (Rolldown, Oxc, Biome, SWC) replacing JS-based tooling for speed
• VoidZero — unified JS toolchain (Vite, Vitest, Rolldown, Oxc) with a single config 🔥
• TypeScript without a build step (Node.js 22+, Bun, Deno 2)
• Go-based TypeScript compiler — up to 10× faster type-checking 🔥

Web Standards Renaissance

• View Transitions API — smooth page transitions now Baseline; cross-document support landing
• CSS Anchor Positioning — native tooltip/popover placement, no JS needed
• Declarative Shadow DOM for server-rendered Web Components
• CSS :has(), Container Queries, if() function reducing JS for layout/theming
• "Zero-JS by default" architectures (Astro, Qwik, Marko) gaining traction
• Customizable <select> — first fully styleable native form control 🔥

Edge and Serverless Evolution

• Edge computing moving JS closer to users globally
• WinterTC — cross-runtime standard APIs (successor to WinterCG) across Bun, Deno, Cloudflare, Node.js
• WASI and WebAssembly Component Model for language-agnostic edge computing

Spatial Computing and WebXR

• WebXR API for AR/VR in the browser
• AR.js, A-Frame, Babylon.js XR for immersive experiences
• Growing with Apple Vision Pro and Android XR headsets 🔥 [2026 Trend]

ES2026 Highlights (Final or Near-Final)

• Temporal API — fixing JavaScript's broken Date object after 30 years
• Math.sumPrecise() — accurate floating-point addition; replaces Kahan summation hacks
• Import Defer — deferred module evaluation for faster startup in large codebases
• Uint8Array Base64/hex — native binary↔string conversion without third-party libs
• Error.isError() — reliable cross-realm / cross-iframe error detection

---

📅 Last updated: March 2026 — ECMAScript 2025 (ES16) is the current finalized specification. ES2026 proposals are at Stage 4 or Stage 3 pending March 2026 TC39 approval.