Modern Faster Alternatives to ESLint

The Evolution of JavaScript Linting

For years, ESLint dominated the JavaScript linting landscape. But as projects grew larger and TypeScript became the standard, developers began encountering performance bottlenecks, configuration sprawl, and feedback loops that slowed down development. Enter a new generation of linting tools built for modern workflows.

This guide explores the leading alternatives to ESLint, with a focus on type safety, developer experience, and the performance gains that can transform your development workflow. Whether you're working with Vite frontend tooling or managing a full-stack monorepo with pnpm, modern linting tools integrate seamlessly with contemporary development practices.

From JSHint to ESLint: A Brief History

The Early Days of JavaScript Linting

JavaScript linting began with JSLint, created by Douglas Crockford in 2002. While it established the concept of automated code quality checking, its opinionated defaults made it difficult to customize for different projects and teams.

JSHint emerged in 2011 as a more configurable alternative, allowing developers to toggle specific rules on and off. This flexibility made it popular among teams that needed more control over their linting configuration.

ESLint's Rise to Dominance

ESLint changed everything when it launched in 2013. Unlike its predecessors, ESLint was built with a plugin-first architecture that allowed anyone to create and share custom linting rules. This opened the door for framework-specific linting and made ESLint adaptable to the rapidly evolving JavaScript ecosystem.

Key advantages that drove ESLint's adoption:

• Plugin architecture enabling framework-specific rules
• Flexible configuration through JavaScript
• Auto-fix support for many rule violations
• Extensive ecosystem of shareable configs

According to Better Stack's analysis of ESLint's architecture, the plugin-first design proved both a strength and eventual limitation as JavaScript projects scaled in complexity.

The Configuration Complexity Problem

As ESLint's ecosystem grew, so did configuration complexity. Teams found themselves managing multiple config files, plugins, and shareable configurations. Understanding how to effectively lint JavaScript became a skill in itself, with documentation spanning hundreds of pages.

Why Modern Projects Need Modern Alternatives

Performance Bottlenecks

As JavaScript projects grew in size and complexity, ESLint's JavaScript-based architecture became a limiting factor. Large monorepos with hundreds or thousands of files can take minutes to lint, creating significant friction in development workflows.

Common pain points include:

• Slow pre-commit hooks: Waiting for linting before commits can interrupt developer flow
• Lengthy CI pipelines: Linting steps that add minutes to every build
• IDE responsiveness: Editor integrations that lag during active development
• Configuration complexity: Managing multiple config files for ESLint, Prettier, and various plugins

The TypeScript Imperative

TypeScript adoption became nearly universal in modern web development, but ESLint required additional configuration and plugins to handle TypeScript effectively. The need for type-aware linting--understanding TypeScript types to provide accurate suggestions--added another layer of complexity to ESLint setups. For projects using TypeScript 5.1 with JSX types, proper linting integration becomes critical for catching type-related errors early. When choosing between Babel and TypeScript as your compiler, having a linting tool that understands your type system becomes essential for catching errors early.

Bundle Size Considerations

Linting performance is just one piece of the puzzle. Modern development also requires attention to bundle size optimization through techniques like tree shaking and code splitting. A well-configured linting tool that runs quickly complements these build-time optimizations, helping developers maintain code quality without sacrificing velocity.

Performance Comparison: Biome vs ESLint

Benchmark Results

Real-world benchmarks demonstrate Biome's significant performance advantages across different project sizes:

Better Stack's performance benchmarks confirm these dramatic improvements, with Biome consistently outperforming ESLint by 10-20x across various project sizes.

Impact on Development Workflow

Pre-commit hooks that once added 30+ seconds to every commit now complete in under 2 seconds, keeping developers in flow.

CI/CD pipelines benefit from dramatically faster linting steps, reducing build times and enabling more frequent deployments. Combined with advanced npm features and optimized bundling strategies, these improvements significantly impact overall development velocity.

IDE integrations provide near-instant feedback as developers type, catching issues before they become problems.

Package Manager Integration

Modern linting tools work seamlessly with advanced package managers. Understanding npm v7 features and how to manage full-stack monorepos with pnpm ensures your tooling stack is optimized for performance at every level.

Configuration: From Complexity to Simplicity

ESLint Configuration Complexity

A typical ESLint setup requires managing multiple files:

.eslintrc.js # Main ESLint configuration
.eslintignore # Files to exclude
.prettierrc.js # Prettier formatting preferences
.prettierignore # Files to exclude from formatting
package.json # Script definitions

Plus various plugins and shareable configs:

// Typical ESLint config requires multiple extends
extends: [
 'eslint:recommended',
 'plugin:@typescript-eslint/recommended',
 'plugin:react/recommended',
 'prettier',
 'plugin:import/typescript'
]

Biome's Unified Configuration

Biome consolidates everything into a single biome.json file:

{
 "$schema": "https://biomejs.dev/schemas/latest/schema.json",
 "formatter": {
 "enabled": true,
 "indentStyle": "space",
 "indentWidth": 2,
 "lineWidth": 100
 },
 "linter": {
 "enabled": true,
 "rules": {
 "recommended": true,
 "style": {
 "useNamingConvention": "warn"
 },
 "correctness": {
 "noUnusedVariables": "error"
 }
 }
 },
 "organizeImports": {
 "enabled": true
 }
}

This single file handles linting rules, formatting preferences, and import organization--eliminating configuration drift and simplifying maintenance. The declarative JSON format makes configurations version-controlled and easily auditable, a practice that aligns with code splitting and tree shaking strategies for maintaining clean, optimized codebases.

Migration Strategies: Moving from ESLint to Biome

Step-by-Step Migration Process

Phase 1: Evaluation

1. Run Biome on your existing codebase to identify rule coverage
2. Compare Biome's output with your current ESLint results
3. Document any custom ESLint rules without Biome equivalents
4. Assess framework-specific rule availability

Phase 2: Parallel Operation

# Install Biome alongside ESLint
npm install --save-dev @biomejs/biome

# Initialize Biome configuration
npx biome init

# Run both linters during transition
npm run lint # ESLint (existing)
npx biome check . # Biome (new)

Phase 3: Gradual Transition

1. Update pre-commit hooks to use Biome
2. Modify CI pipelines to make Biome the primary linter
3. Remove ESLint dependencies once Biome coverage is sufficient
4. Update documentation and team training materials

Handling Custom Rules and Plugins

Custom ESLint rules can be migrated using Biome's GritQL patterns for simple rules. Complex custom rules may require:

• Contributing rules to Biome directly
• Maintaining parallel ESLint configuration for specific needs
• Rewriting rules as Biome-compatible configurations

Framework-specific plugins have varying Biome support:

• React: Basic JSX rules available, full React hooks rules in development
• Vue: Limited support, may need ESLint for Vue-specific rules
• Angular: Similar limitations, ecosystem still maturing

Migrating from Prettier

For teams also considering migrating from Prettier to Biome, Biome's unified approach eliminates the need for separate formatting tools. This migration path is well-documented and offers significant advantages for reducing toolchain complexity.

Alternative Tools Beyond Biome

Oxlint: The Performance-First Alternative

Oxlint is another high-performance alternative gaining traction in the JavaScript community:

• Architecture: JavaScript parser with Rust components for performance
• Compatibility: Supports ESLint rule format for easier migration
• Focus: Parsing speed and rule execution optimization
• Trade-off: Smaller ecosystem compared to Biome

When to Stick with ESLint

Despite Biome's advantages, ESLint remains the right choice in certain scenarios:

Maintain ESLint when:

• Your project relies on specialized plugins with no Biome equivalent
• Migration costs exceed the performance benefits for your team
• Team training and familiarity with ESLint is a significant investment
• Legacy projects with extensive custom rule configurations

The ecosystem is evolving rapidly, and the gap between Biome and ESLint continues to narrow. Regular evaluation of your tooling needs will help you make informed decisions as these tools mature.

Making the Right Choice

Choosing the right linting tool involves evaluating your project's specific needs. Whether you're building a web application with Vite or managing a complex monorepo with pnpm, the right tooling choice impacts developer productivity and code quality.

Best Practices for Modern Linting

Establishing Linting Standards

Configuration principles for effective linting:

1. Start with defaults: Begin with Biome's recommended rule set as a baseline
2. Add incrementally: Introduce project-specific rules based on actual issues encountered
3. Enable auto-fix: Configure auto-fix for all applicable rules to maximize developer productivity
4. Balance strictness: Find the right balance between code quality and developer velocity
5. Document exceptions: Document any rule overrides and the reasoning behind them

Editor Integration and Workflow

VS Code configuration for optimal Biome integration:

{
 "editor.formatOnSave": true,
 "editor.codeActionsOnSave": {
 "source.fixAll.biome": "explicit"
 },
 "[javascript][typescript][jsx][tsx]": {
 "editor.defaultFormatter": "biomejs.biome"
 },
 "files.associations": {
 "*.config.js": "javascript"
 }
}

Recommended plugins:

• Biome VS Code extension for native editor integration
• Biome language server for enhanced IntelliSense

CI/CD Pipeline Integration

Best practices for continuous integration:

# Example GitHub Actions workflow
- name: Lint with Biome
 run: npx biome ci .
 env:
 BIOME_VERSION: latest

Key recommendations:

• Run Biome as part of the build process, not as a separate step
• Use Biome's --ci flag for deterministic output
• Fail builds on correctness errors, warn on style issues
• Cache Biome binary between runs for faster execution
• Run linting before type checking to catch simple issues quickly

Following linting best practices ensures consistent code quality across your development team.

Conclusion

Modern linting tools like Biome represent a significant advancement for TypeScript-first development teams. The performance improvements are substantial--often 10-20x faster than ESLint--transforming linting from a potential bottleneck into an invisible quality gate.

Key takeaways:

• For new projects: Biome offers a compelling path to fast, unified tooling with minimal configuration overhead
• For existing ESLint projects: Gradual migration paths make adoption feasible without disrupting established workflows
• TypeScript-first design: Native TypeScript support eliminates configuration complexity
• Unified toolchain: One tool replaces ESLint, Prettier, and import sorters

The choice between tools should consider your specific context: project size, TypeScript complexity, framework requirements, and team migration capacity. Biome's TypeScript-first design and unified architecture make it particularly well-suited for modern web development.

As the JavaScript ecosystem continues to evolve, having fast, reliable tooling becomes increasingly important for developer productivity and code quality. Whether you choose Biome, stick with ESLint, or use a combination of both, investing in proper linting configuration pays dividends throughout your project's lifecycle. Our frontend development team can help you evaluate and implement the optimal tooling strategy for your specific needs.

Sources

1. Better Stack - Biome vs ESLint: Comparing JavaScript Linters and Formatters
2. Softcolon - Biome Guide: Replace ESLint and Prettier
3. LogRocket - Modern, faster alternatives to ESLint
4. Biome.js Official Website