Why Wallaby?

Wallaby.js offers a radically different testing experience that prioritizes speed, ease of use, and tight integration into your development workflow. Here’s why Wallaby.js stands out and how it can transform your development process.

Instant Feedback

With Wallaby.js, tests run immediately as you type, giving you instant feedback on your code. You don’t have to wait for files to save or manually run tests. Imagine working on a feature and seeing test results, code coverage, and even console logs appear as you’re still writing the function. This cuts down the time between writing code and catching bugs or errors, allowing you to fix issues right away.

For example, if you’re implementing a new feature and accidentally introduce a regression, Wallaby will alert you before you’ve even saved the file. You can fix the problem without disrupting your flow, instead of finding it after running all tests manually and sifting through failures later.

Smart Test Execution

As projects grow, running a full suite of tests can take longer and longer. Other test runners often require running all tests or, at best, all tests in affected files. Wallaby.js is different because it understands the relationship between your code and your tests. When you make a change, it runs only the tests that are impacted by that change, drastically reducing the time you wait for feedback. Other tools might run the entire test suite, making you wait unnecessarily while they process results that you don’t need.

Wallaby includes features that make it easy to work on large projects without sacrificing speed. For example, Wallaby has an option to only start tests for the files that you’re currently working on (either by opening them or editing them), instead of all tests in your project. This ensures that you get feedback on your changes quickly.

No More Context Switching

Unlike using a CLI-based workflow where you run tests manually and need to parse walls of terminal output, and scroll through logs to find the relevant information, Wallaby.js displays everything you need right inside your code editor (or through Wallaby’s web-based interface). Test results, errors, logs, and coverage reports are all shown next to the line of code they relate to. This eliminates the constant back-and-forth between your editor and the terminal, significantly improving your focus and productivity.

For instance, if a test fails, the error message appears directly beside the failing line of code. Instead of sifting through hundreds of lines of terminal output, you get instant clarity, allowing you to quickly diagnose and fix issues. This streamlined experience means less mental effort is spent switching contexts, and more on solving problems.

Powerful Debugging Tools

Wallaby.js isn’t just about running tests, it’s about helping you understand your code better. The time travel debugging feature allows you to step backward and forward in your code execution to see exactly how a bug occurred. You can inspect variables and runtime values inline, right next to the code, and even use Wallaby’s special comment format to measure code execution times or log values without adding console.log statements.

For example, if a test fails because of an edge case, you can use the time travel debugger to trace the execution path and understand where things went wrong. You can inspect variables in real-time and pinpoint exactly where the issue lies, rather than hunting through logs and breakpoints manually.

Minimal Setup

Wallaby.js works with any editor and is compatible with a wide range of testing frameworks, including Jest, Vitest, Angular CLI, node:test , mocha, and more. Wallaby also supports with the latest versions of node.js and emerging JavaScript/TypeScript language features. This flexibility means you can use Wallaby in any environment, from VS Code to Neovim, and still benefit from its powerful features.

Wallaby provides some additional in-editor features for VS Code, JetBrains IDEs, Visual Studio, Sublime Text but these same features are also available to developers using other editors through Wallaby’s web-based interface.

No matter which testing framework you’re using, the Wallaby.js interface remains consistent, so once you learn Wallaby, you can switch between projects and frameworks without having to adjust to different ways of interpreting test results.

Smarter Testing at Scale

As your project grows, so do your testing needs. Wallaby.js is designed to scale with your project. Its ability to run tests in parallel, selectively re-run affected tests, and provide detailed coverage reports means you can keep your feedback loop fast even as your codebase expands. Whether you’re working on a small personal project or a massive enterprise codebase, Wallaby ensures that testing never becomes a bottleneck.