Best of JavaScript

A hand-picked list of JavaScript and TypeScript tools that matter for serious product work.

If I were building, shipping, or maintaining a serious JS/TS product today — what tools are actually worth my attention?

Philosophy

A good curated list should do more than collect links. This one tries to:

favor defaults over novelty;
include battle-tested tools first, then interesting challengers;
prefer tools with strong docs, healthy adoption, and a clear place in a modern stack.

Companion playbooks

These repositories form one playbook suite:

Auth & Identity Playbook — sessions, tokens, OAuth, and identity boundaries across the stack
Backend Architecture Playbook — APIs, boundaries, OpenAPI, persistence, and errors
Best of JavaScript — curated JS/TS tooling and stack defaults
Caching Playbook — HTTP, CDN, and application caches; consistency and invalidation
Code Review Playbook — PR quality, ownership, and review culture
DevOps Delivery Playbook — CI/CD, environments, rollout safety, and observability
Engineering Lead Playbook — standards, RFCs, and technical leadership habits
Frontend Architecture Playbook — React structure, performance, and consuming API contracts
Marketing and SEO Playbook — growth, SEO, experimentation, and marketing surfaces
Monorepo Architecture Playbook — workspaces, package boundaries, and shared code at scale
Node.js Runtime & Performance Playbook — event loop, streams, memory, and production Node performance
Testing Strategy Playbook — unit, integration, contract, E2E, and CI-friendly test layers

The Defaults I'd Reach for First

If I were starting a modern JS/TS project today, I would usually begin with something close to this:

Editor / AI: Cursor or VS Code + Claude Code or Codex
Runtime / package manager: Node.js + pnpm
Language / build: TypeScript + Vite
Frontend: React or Astro depending on dynamic vs static
Full-stack: Next.js for React-heavy apps, Hono or Fastify for lean APIs
Forms & validation: React Hook Form + Zod
Server state: TanStack Query
Database: Drizzle ORM or Prisma
Auth: Better Auth or Auth.js depending on self-hosted vs ecosystem fit
Testing: Vitest + Playwright
Code quality: Biome or ESLint + Prettier
UI: Tailwind CSS + shadcn/ui or Material UI
Tables & virtualization: TanStack Table + TanStack Virtual, or react-virtuoso when you want richer list primitives out of the box
Hosting: Vercel for Next.js-heavy apps, Cloudflare for edge-first apps, Railway or Render for simple full-stack deployments
Pipelines: GitHub Actions or GitLab CI/CD

Developer Experience & AI Coding

Editors

Cursor — The strongest all-around AI-native editor pick for many JS/TS teams today.
Visual Studio Code — Still the universal baseline editor with the broadest extension ecosystem.

AI coding tools

Claude Code — One of the strongest coding agents for repository-aware implementation, refactors, and terminal-heavy workflows.
Codex — Worth using when you want cloud-executed coding tasks tied to GitHub workflows.
Gemini — Worth considering when you want a strong general-purpose coding assistant with a large context window and multimodal strengths.

VS Code / Cursor extensions

These all work naturally in VS Code, and the same extension ecosystem is one of Cursor's practical advantages too.

Must-have

GitLens — Still the best overall Git extension for understanding blame, history, and changes without leaving the editor.
ESLint — Still the most important extension when your repo relies on ESLint for fast feedback and autofix.
Prettier — The obvious formatter extension when your team is still on Prettier rather than Biome-only workflows.
Error Lens — One of the fastest ways to notice lint and TypeScript problems without constantly opening the problems panel.
Pretty TypeScript Errors — Makes complex TypeScript diagnostics much more readable in everyday work.
Tailwind CSS IntelliSense — A must-have if you write Tailwind regularly and want class completion, previews, and validation.
Playwright Test for VS Code — One of the most useful testing extensions in the JS ecosystem thanks to run/debug integration, locator tools, and trace support.
REST Client — The strongest fully free in-editor default for HTTP, GraphQL, and .http-file-based API workflows in VS Code or Cursor.
Prisma — Essential if your stack uses Prisma, adding schema autocomplete, diagnostics, formatting, and better database-model navigation.

Nice-to-have

One Dark Pro — A popular default theme if you want a proven, easy-on-the-eyes setup.
JavaScript and TypeScript Nightly — Great when you want newer TypeScript language-service improvements before they fully land in stable editor builds.
npm IntelliSense — Small but genuinely useful import autocomplete for package-heavy Node and frontend repos.
IntelliCode — Still useful if you want lightweight AI-assisted completion without depending entirely on external coding agents.
Auto Rename Tag — Tiny extension, big quality-of-life win when editing JSX, HTML, and component templates.
Highlight Matching Tag — Makes nested markup easier to scan in large React or template files.
CSS Peek — Handy when you still work in CSS or CSS Modules and want quick selector navigation.
Color Highlight — Simple visual feedback that is still useful in CSS-heavy frontend work.
indent-rainbow — Makes deeply nested JSX, config, and JSON files easier to parse at a glance.
SVG — Nice quality-of-life extension when frontend repos frequently include inline or asset-based SVG work.
Version Lens — Very useful in dependency-heavy JS repos when you want package version drift to be visible in package.json.
Markdown All in One — Great for README-heavy repos, docs work, and faster markdown editing.
Markdown Preview Enhanced — Worth using when built-in markdown preview is not enough for docs-heavy workflows.
markdownlint — The obvious markdown quality extension when your project treats docs as first-class output.
TODO Highlight — Simple but still useful for scanning unfinished work in large codebases.
Docker — Still one of the most practical extensions when your app ships with containers.
Kubernetes — Useful once your stack actually touches Kubernetes, though not a must-have for every JavaScript project.

Runtimes & Package Management

Runtimes

Tool	Why it matters	Signals
Node.js	The default runtime for most production JavaScript backends.	—
Bun	Fast, ambitious, and increasingly credible as a runtime + package manager + test runner + bundler.	—
Deno	Clean developer experience, modern defaults, and a thoughtful runtime model.	—
Cloudflare Workers	A serious edge runtime, not just a niche deployment target anymore.	—

Package managers

Tool	Why it matters	Signals
pnpm	My default recommendation for most teams, especially monorepos.
npm	The universal baseline that works everywhere.
Bun Package Manager	Worth trying when you want one binary for install, scripts, and runtime.	—

Version management

Tool	Why it matters	Signals
nvm	Still the familiar choice for switching Node versions.	—
Volta	Excellent when you want per-project tool pinning with less shell friction.	—

Build, Monorepo & Release Engineering

Core foundations

Tool	Why it matters	Signals
TypeScript	The language layer most serious JS projects now assume.
TypeScript Project References	Important once your repo starts growing sideways.	—
Vite	The best general-purpose starting point for modern frontend apps.

Builders, compilers, bundlers

Tool	Why it matters	Signals
Vite	Still the best default for most new frontend apps.
esbuild	Extremely fast and still one of the best "get out of my way" tools.
SWC	Great when you want speed plus compiler-oriented extensibility.
Rspack	Strong option when you want webpack-compatible ergonomics with much faster Rust-backed performance.
Turbopack	Fast and strategically important in the Next.js world, though still more opinionated than Vite.	—
Rollup	Still excellent for library builds.
Rolldown	One of the most important emerging build tools to watch, especially around the Vite ecosystem.
webpack	Not the default for new projects anymore, but still everywhere in real codebases.

Monorepos & release flows

Tool	Why it matters	Signals
Turborepo	Strong fit for frontend-heavy monorepos and fast incremental builds.
Nx	Excellent when you want deeper workspace tooling and bigger-team structure.
Changesets	Versioning and changelog sanity for package-based repos.

Commit-time hygiene

Tool	Why it matters	Signals
Husky	Git hooks with minimal drama.
Lefthook	Very fast alternative, especially nice in bigger repos.
commitlint	Useful when commit conventions actually matter in your release process.

Frontend & Full-Stack Frameworks

Frontend-first

Tool	Why it matters	Signals
React	The ecosystem center of gravity.
Vue	Excellent developer experience and a strong all-in-one ecosystem.
Svelte	Still one of the cleanest authoring experiences in UI development.
Solid	Great when you want fine-grained reactivity and a different mental model from React.

Full-stack / app frameworks

Tool	Why it matters	Signals
Next.js	Still the default full-stack React framework for many teams.
Astro	A standout choice for content-driven sites, docs, marketing pages, and hybrid content/app builds.
Nuxt	The obvious full-stack default if your team prefers Vue.
SvelteKit	Great full-stack option if you are already in the Svelte world.
Remix	Worth knowing for web-native routing and form-first thinking.

Backend / edge-friendly frameworks

Tool	Why it matters	Signals
Hono	One of the best modern defaults when you want edge-friendly or multi-runtime APIs.
Fastify	A great default for Node APIs when you want speed and structure without a framework tax.
NestJS	Strong fit for enterprise teams that like architecture, modules, decorators, and convention.
Express	Old, familiar, and still absolutely alive in existing codebases.

UI, Styling & Design Systems

CSS & styling systems

Tool	Why it matters	Signals
Tailwind CSS	Still the most widely adopted utility-first styling system in modern JS apps.
vanilla-extract	Great when you want typed, file-based styles without runtime overhead.
Panda CSS	Worth a look if you want design-token-driven styling with static extraction.

Component systems

Tool	Why it matters	Signals
shadcn/ui	A very practical starting point for teams that want ownership over their components.
daisyUI	A fast, pragmatic Tailwind component layer when you want to ship styled UI without building every primitive yourself.
Radix UI	Accessible unstyled primitives that play well with real design systems.
Mantine	One of the nicest batteries-included React UI kits.
Material UI	Still common in enterprise products and dashboard-heavy apps.
Chakra UI	Friendly ergonomics and a coherent component model.
Ant Design	Still a major option for business applications and data-dense interfaces.

Tables & data grids

Tool	Why it matters	Signals
TanStack Table	The headless default when you want powerful table logic, full markup control, and a good fit with the wider TanStack ecosystem.
AG Grid	The feature-rich grid to know for data-heavy products, especially when Excel-like behavior, enterprise features, or very large datasets matter.
MUI X Data Grid	Strong choice when a React dashboard already uses Material UI and wants a polished component with sorting, filtering, pagination, and virtualization.
react-data-grid	Practical React grid for editable, spreadsheet-style tables without taking on the full AG Grid surface area.
Handsontable	Best known for spreadsheet-like editing, copy/paste workflows, formulas, and dense business-data interfaces.

Virtualization & large lists

Tool	Why it matters	Signals
TanStack Virtual	Headless, framework-agnostic virtualization for custom lists, grids, tables, and scroll behavior with minimal UI opinions.
react-virtuoso	The pragmatic React default when you want dynamic heights, grouped lists, sticky headers, tables, and infinite scroll with less wiring.
react-window	Still common and tiny for simple fixed-size list virtualization, but more of a maintenance choice than a new-project default.
react-virtualized	Important legacy option for older React apps with large lists and grids, though heavier and less attractive for greenfield work.

Icons & docs for component work

Tool	Why it matters	Signals
lucide	Clean icon set and one of the easiest defaults for modern UIs.
react-icons	Useful when you need breadth more than purity.
Storybook	Still the standard workshop for components, states, and design-system documentation.

Routing, State, Forms & Validation

Routing

Tool	Why it matters	Signals
React Router	The classic, still important.
TanStack Router	A strong modern choice if type-safe routing matters to you.

State management

Tool	Why it matters	Signals
Zustand	Lightweight, minimal, and a great default for many React apps.
Redux Toolkit	Still the right answer when state complexity is real and long-lived.
XState	Best when your problem is workflow complexity, not just state storage.

Server state & data fetching

Tool	Why it matters	Signals
TanStack Query	The default recommendation for async server-state management.
SWR	Still elegant for simpler React data-fetching patterns.
axios	Popular and familiar; still useful, even in a fetch-first world.
ky	Small, modern, pleasant fetch wrapper.

Forms & validation

Tool	Why it matters	Signals
React Hook Form	The best default for most React forms.
TanStack Form	Strong modern alternative when you want deeper type inference or are already committed to the TanStack ecosystem.
Zod	The current center of gravity for TypeScript-first schema validation.
Ajv	Great when JSON Schema is the right abstraction.
Joi	Still useful in backend and validation-heavy codebases.
Yup	Common in older React form stacks, but less of a new-project default now.

React hooks

Tool	Why it matters	Signals
usehooks-ts	The strongest TypeScript-first default when you want a practical set of reusable React hooks.
ahooks	Great when you want a broader, more enterprise-shaped hooks toolkit.
react-use	Still a useful grab-bag of hooks, especially in older or utility-heavy React codebases.

Localization

Tool	Why it matters	Signals
react-i18next	Still the safest default when a React app needs serious localization.

Dates & IDs

Tool	Why it matters	Signals
date-fns	The best general-purpose date utility default for most JavaScript and TypeScript apps.
Day.js	A lightweight alternative when you want a smaller Moment-like API surface.
Luxon	Strong choice when timezone-heavy date handling matters more than minimal bundle size.
Temporal	The long-term native direction for safer date and time handling in JavaScript.	—
nanoid	My default pick for compact, modern ID generation.
uuid	Still the standard option when interoperability and familiar UUID formats matter.

Backend, APIs & Data

API layers

Tool	Why it matters	Signals
Hono	Lean, modern, edge-friendly, and increasingly hard to ignore.
Fastify	Excellent for structured Node APIs.
NestJS	Strong for teams that want architecture spelled out.
Express	Still important to know because so much Node infrastructure and legacy code still assumes it.
tRPC	Worth evaluating when you want end-to-end TypeScript without hand-written API clients.

When the contract is OpenAPI and the client is React + TypeScript, generate types (and optionally clients) instead of duplicating shapes by hand — this lines up with the backend and frontend playbooks:

Tool	Why it matters	Signals
openapi-typescript	Types from OpenAPI; works well with hand-written `fetch` or TanStack Query.
Hey API OpenAPI TS	Codegen for clients and types with active maintenance.
Orval	OpenAPI → clients, mocks, and hooks (including TanStack Query).

ORMs & query builders

Tool	Why it matters	Signals
Prisma	Still one of the best choices for productivity and onboarding speed.
Drizzle ORM	One of the strongest choices when you want SQL closer to the surface.
Kysely	Great when you want type-safe SQL query building without a full ORM.
Knex	Old but still useful in many backend projects.
Mongoose	Still the obvious entry in MongoDB-heavy Node stacks.

Queues, cache, streaming

Tool	Why it matters	Signals
BullMQ	The default queueing choice for many Redis-backed Node systems.
Redis for JavaScript	Standard Redis client for Node.
Apache Kafka	Still the heavyweight event-streaming answer when scale and durability matter.	—
RabbitMQ	Worth knowing where traditional messaging patterns are a better fit than event logs.	—
Amazon SQS	Boring in the best possible way for many cloud-native job pipelines.	—

Email & notifications

Tool	Why it matters	Signals
Nodemailer	Still the practical default when you need to send email directly from Node services.

GraphQL & adjacent tools

Tool	Why it matters	Signals
Apollo Client	Still important if your frontend lives in GraphQL.
Relay	Worth it when you want serious GraphQL discipline.
GraphQL	Not a default for everything, but still the right tool in some domains.

Authentication & Security

Auth

Tool	Why it matters	Signals
Better Auth	One of the strongest new defaults for TypeScript-first, self-hosted authentication.
Auth.js	Still a very practical choice, especially in the Next.js ecosystem.
Clerk	Worth considering when a managed auth platform is the right tradeoff.
Passport	Old, flexible, and still found everywhere in established Node apps.
Lucia	More notable as a minimalist approach and reference point than as the obvious default for new apps.
Amazon Cognito	Useful when managed identity is the right tradeoff.	—

Tokens & credentials

Tool	Why it matters	Signals
jsonwebtoken	The familiar JWT implementation everyone has seen.
paseto	Worth knowing when you want a stronger alternative to raw JWT habits.
argon2	A better modern default for new password-hashing code than older bcrypt habits.
bcrypt.js	Still extremely common, but more of a compatibility choice than the best new-project default.

Sanitization & frontend security

Tool	Why it matters	Signals
DOMPurify	The obvious default for sanitizing HTML in frontend contexts.
sanitize-html	Good when you need configurable HTML sanitization.

SEO & metadata

Tool	Why it matters	Signals
react-helmet-async	The safer React-era replacement for `react-helmet` in SPA-style apps.

Testing & Code Quality

Unit & component testing

Tool	Why it matters	Signals
Vitest	The best default for modern Vite-flavored JS/TS projects.
Jest	Still important, especially in large existing codebases.
Node Test Runner	Worth watching when you want a built-in, dependency-light testing baseline.	—
bun test	Increasingly interesting if your stack is already Bun-first.	—
Testing Library	The right mental model for UI tests in most apps.
MSW	Excellent for API mocking without contaminating your components.
Supertest	Still a simple and effective way to test HTTP servers.

End-to-end & browser automation

Tool	Why it matters	Signals
Playwright	The current default recommendation for serious end-to-end browser testing.
Cypress	Still widely used and worth knowing well, especially in existing suites.
BrowserStack	Useful when cross-browser reality needs to be tested on actual infrastructure.	—
Sauce Labs	Another established option for broader browser/device coverage.	—

Linting, formatting, repo hygiene

Tool	Why it matters	Signals
Biome	Fast, modern, and increasingly compelling as a formatter + linter combo.
ESLint	Still the standard linting tool most teams know and trust.
Prettier	Still the default formatter in countless repos.
Oxlint / Oxc	Worth tracking as an ultra-fast linting layer, especially in CI-heavy repos.
lint-staged	Simple, effective pre-commit filtering.

Content, Docs, Editors & Media

CMS & content platforms

Tool	Why it matters	Signals
Payload	One of the most compelling TypeScript-first CMS/app-platform choices for modern Next.js stacks.
Strapi	Still one of the most recognizable headless CMS options in JS land.
Keystone	Great when you want a customizable app + CMS foundation.
Ghost	Strong publishing platform with a mature product story behind it.

Documentation

Tool	Why it matters	Signals
Docusaurus	Great docs portal and content site framework.
VitePress	One of the cleanest choices for docs sites in the Vite ecosystem.
TypeDoc	Still the obvious API docs option for TypeScript libraries.

Rich text & code editing

Tool	Why it matters	Signals
Monaco Editor	Best for VS Code-like editing in the browser.
CodeMirror	Flexible and lightweight code editing foundation.
Tiptap	One of the strongest modern rich-text editor choices in React and full-stack content apps.
TinyMCE	Mature rich text editor.
Quill	Still a familiar choice for rich text editing.

Files, PDF, uploads, images

Tool	Why it matters	Signals
react-pdf	Useful for both generating and rendering PDFs in React workflows.
PDF.js	The classic for browser PDF rendering.
jsPDF	Still useful for client-side PDF generation.
react-dropzone	The best default when you want a headless drag-and-drop file upload foundation.
Uppy	Great when uploads need resumability, remote sources, or a more full-featured upload workflow.
UploadThing	Strong option for modern TypeScript and Next.js stacks that want an integrated upload backend story.
FilePond	Great UX for uploads.
Sharp	The default serious image-processing library for Node.
imagemin	Handy for asset optimization pipelines.
blurhash	Still a nice touch for image placeholders.
Papa Parse	Reliable CSV parsing in the browser.

Infrastructure, Delivery & Observability

Dev environment & containers

Tool	Why it matters	Signals
Git	Still the one tool nobody gets to avoid.	—
Docker	The default container story for local dev and many deployments.	—
Docker Compose	Still the easiest way to boot app-shaped local environments.	—

Container orchestration

Tool	Why it matters	Signals
Kubernetes	Still the default orchestration layer once your deployment model becomes cluster-shaped.	—
Amazon ECS / Fargate	Great when you want AWS-native container orchestration with less Kubernetes overhead.	—

Hosting & platforms

Tool	Why it matters	Signals
Vercel	Still the default deployment answer for many Next.js-heavy teams.	—
Cloudflare	Strong choice when edge runtimes, caching, and global performance matter a lot.	—
Netlify	Still very good for static-heavy sites, docs, and simpler frontend deployments.	—
Railway	Great default when you want to ship a full-stack app quickly without much platform ceremony.	—
Render	Good practical platform for web apps, APIs, workers, and managed services.	—
Fly.io	Strong option when you want more infrastructure control and global placement.	—

CI/CD

Tool	Why it matters	Signals
GitHub Actions	The default CI/CD answer for a lot of GitHub-native teams.	—
GitLab CI/CD	Strong option when your repo and deployment flow already live in GitLab.	—

Infrastructure as code & secrets

Tool	Why it matters	Signals
AWS CDK	Great fit if your team thinks in code and already lives in AWS.
Terraform	Still the standard multi-cloud IaC reference point.	—
AWS Secrets Manager	The obvious managed choice when you are already deep in AWS.	—
Infisical	Modern secrets management worth knowing.	—
Vault	Still the heavyweight name in secrets infrastructure.	—

Monitoring, logs & product visibility

Tool	Why it matters	Signals
Sentry	The default frontend and full-stack error-monitoring answer for many teams.
TrackJS	Focused browser error monitoring when you want a tight, JS-first product.
Datadog	Still a major observability platform in production backends.
Grafana	Strong for dashboards and metrics visibility.	—
Better Stack	Logs, uptime, and incident tooling in a cleaner modern package.	—
Axiom	Worth considering for developer-friendly logs and analytics.
LogRocket	Very useful when product teams need session replay in web apps.	—
OpenReplay	Good open-source-minded alternative in the replay space.

Cross-Platform Apps

Desktop

Tool	Why it matters	Signals
Tauri	My first stop when a desktop shell should stay lean.
Electron	Bigger footprint, bigger ecosystem, still a reality when compatibility matters more than size.

Mobile

Tool	Why it matters	Signals
Expo	The best default starting point for most React Native teams.
React Native	Still the default cross-platform native conversation in JS.
Capacitor	Great when your team is fundamentally building a web app that also needs native packaging.
Ionic	Still relevant in hybrid app workflows.

AI / ML for JavaScript Apps

LLM app tooling

Tool	Why it matters	Signals
OpenAI SDK	Official JS/TS SDK for OpenAI APIs.
AI SDK by Vercel	One of the best ways to build streaming AI UX in modern JS apps.
LangChain.js	Useful when you want chain / agent abstractions in TypeScript.
Mastra	Worth watching if you want a TypeScript-native framework for AI agents and workflows.
Transformers.js	Strong option for running transformer models in JavaScript environments.

Traditional ML in JS

Tool	Why it matters	Signals
TensorFlow.js	Still the most recognizable ML framework in JS.
ml5.js	Great for friendlier creative-coding and educational workflows.
Brain.js	Lightweight neural-net tooling worth knowing exists.

Worth Reading

You Don't Know JS Yet — Still one of the best deep dives into how JavaScript actually works.
Clean Code JavaScript — Useful when you want pragmatic readability rules for day-to-day code.
javascript-algorithms — Excellent reference repo for algorithms and data structures in JS.
Roadmap.sh — JavaScript — Good bird's-eye view of the learning surface area.
JS: The Right Way — Still a worthwhile reference list.

License

MIT is a sensible default for a repository like this, but choose the license that fits how you want others to reuse the material.

Name		Name	Last commit message	Last commit date
Latest commit History 4 Commits
LICENSE		LICENSE
README.md		README.md

Folders and files

Latest commit

History

Repository files navigation