Skip to content

khasky/best-of-javascript

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

1 Commit
LICENSE
LICENSE
 
 
README.md
README.md
 
 

Repository files navigation

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?

Table of Contents

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:

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:

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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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.

Icons & docs for component work

  • 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

State management

  • 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

  • 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

  • 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

  • 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

  • react-i18next — Still the safest default when a React app needs serious localization.

Dates & IDs

  • 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

  • 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:

  • 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

  • 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

  • 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

  • Nodemailer — Still the practical default when you need to send email directly from Node services.

GraphQL & adjacent tools

  • 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

  • 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

  • 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

  • DOMPurify — The obvious default for sanitizing HTML in frontend contexts.
  • sanitize-html — Good when you need configurable HTML sanitization.

SEO & metadata

  • react-helmet-async — The safer React-era replacement for react-helmet in SPA-style apps.

Testing & Code Quality

Unit & component testing

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

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.

About

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

Topics

nodejs javascript list typescript tools curated best top bestof best-tools thebest hand-picked handpicked toppicks

Resources

Readme

License

MIT license
Activity

Stars

2 stars

Watchers

0 watching

Forks

0 forks
Report repository

Contributors