Wallaby v3

Wallaby.js continues to evolve, building on the foundation laid by Wallaby v2. We’re proud to introduce Wallaby v3, an overhauled engine that streams test, coverage, log, and error results in real time. Wallaby v3 starts instantly with cached results, prioritizes execution of the files you’re working on, and keeps you updated with progress and time estimates.

While v2 was a complete UI overhaul, v3 focuses on how your tests are executed. The new engine is designed to be real‑time, resilient, and smarter about what to run and when. The major capabilities in v3 are result streaming and cached results - together they make test feedback feel instant and more informative, especially in larger codebases.

At a glance, Wallaby v3 delivers:

• Real‑time result streaming: tests, coverage, logs, and errors stream live into your editor, so you spot issues immediately without waiting for a full run to finish.
• Instant startup with cached results: cached execution data lets you start instantly and get immediate feedback, even on large projects.
• Smart, prioritized execution: edits during a run only re-queue affected tests, while others continue and already-streamed results stay valid; open files and related tests run first.
• Accurate progress indicators and time estimates: time-to-result estimates keep you aware of how long things will take, so you can code confidently without guesswork.

These changes are only possible because v2’s UI can present clearer in‑progress indicators and time estimates while handling incremental, out‑of‑order updates gracefully. With v3, the engine and UI work together: the UI stays live and contextual while the engine streams and reconciles results continuously.

What this means for you

There’s nothing you need to do to benefit from v3. Your existing Wallaby config, workflows, and shortcuts continue to work exactly as before. The engine changes are designed to be additive and seamless.

What you may notice in day‑to‑day usage:

• Faster first feedback: prior results appear immediately (when unchanged), and new results start streaming sooner.
• Earlier visibility of problems: failing or long‑running tests surface incrementally instead of waiting for all tests to finish executing.
• New/updated UI elements: progress indicators and time estimates now show when tests are expected to finish.
• Instant startup feel: the UI is “warm” instantly, then quietly reconciles anything that changed in the background.

No configuration changes are required, and you don’t need to “opt in”. If you’ve rolled back to the v1 UI, result streaming (and most of these improvements) won’t be available - now is a great time to reevaluate the UI improvements from Wallaby v2.

Everything has been fine-tuned to feel natural: if you ignore the new indicators, Wallaby just feels faster; if you lean in, you get richer insight into what’s happening while tests execute. The screenshot above shows examples of the new progress/time remaining signals you’ll see during longer runs.

Result streaming

Before v3, test results were delivered only after all tests had completed execution. Testing framework CLI tools also work this way. This can lead to noticeable delays in larger projects where full test suites can take minutes to run for the first time. Worse yet, when modifying code, a single change could invalidate tests that are already executing and force them to be cancelled and restarted, leading to even longer wait times.

With result streaming, Wallaby now provides test results, coverage, logs, and errors as soon as they become available, without waiting for your entire suite or all change related test files to finish. This includes real-time updates to the Overview panel and Side View, where you can see failing tests, logs, and progress indicators incrementally.

See progress indicators and time estimates for executing tests

A key part of this feature is smart prioritized execution. Wallaby now intelligently orders test file execution. For example, opened test files or source files (and their related tests) are prioritized. This ensures that the most relevant feedback appears first, reducing wait times for results for code that you’re working on.

In practice, this means:

• Faster iteration cycles: Edit code, and see affected test results almost immediately.
• Better handling of long-running suites: Progress is visible in the Status tab, with time estimates updating dynamically.
• Minimal disruption on changes: If you edit code while a run is in progress, Wallaby incrementally cancels only the affected test batches and immediately re‑queues them. This lets unaffected tests continue. Already-streamed results stay visible (and aren’t re-run unless needed), so you keep feedback and valid test execution that is already in progress instead of restarting from scratch.

This update is particularly valuable for projects with extensive test suites, where traditional batch execution could interrupt your flow.

Cached results

Starting Wallaby in any project used to mean waiting for a full test run before seeing any output. Cached results change this by displaying the last known execution results immediately on startup, for unchanged test files (and their dependent source files).

Once displayed, Wallaby begins re-executing those tests in the background to verify they’re still valid. If any discrepancies are identified (e.g. due to environmental changes), the results are updated seamlessly. Because this verification uses the same prioritized execution and result‑streaming pipeline as normal runs, any potentially stale results for opened or recently edited files are rechecked first and refreshed immediately. This keeps the interface feeling instant on launch. The Overview panel and Side Views are populated immediately with cached results, and then quickly and seamlessly reconcile only the pieces that actually changed.

Cached coverage, test results, and inline feedback is displayed instantly on startup

Key benefits include:

• Immediate visibility: See coverage, logs, and test status from the previous session without delay.
• Efficient startups: Ideal for switching between projects or restarting your editor.
• Reliability checks: Background execution ensures cached data is refreshed, with any updates reflected in real time via result streaming.
• Full‑project awareness without waiting: Even if you’re only touching a single file, you instantly see the status and coverage picture for the whole suite. It’s effectively “Smart Start” always on but you no longer trade the “big picture” for faster feedback or feel the need to stop/restart to get a clean, comprehensive view.

Combined with Value Peek and persistent watch expressions from Wallaby v2, this allows you to dive into analysis without initial downtime.

Because cached results participate in the same prioritized, streaming reconciliation pipeline as fresh executions, any stale entries are replaced quickly and surgically. You keep immediate whole‑project insights, and the actions that matter (executing your edited files and their impacted tests) are automatically prioritized as soon as you make a change.

Under the hood: the Wallaby v3 engine

The changes available in Wallaby v3 required some major refactoring and redesign of many of the internals of Wallaby’s test execution model. We’ve envisioned these changes for a number of years and have been actively working on them for the last 12 months. Previously, the engine operated in a synchronous, all‑or‑nothing manner, which limited how we could handle partial results or reuse prior data.

Before Wallaby v3

The overhaul introduces an asynchronous, event‑driven architecture that supports streaming outputs and caching mechanisms. This includes:

• Prioritization queues for test runs, integrated with editor events like file opens and edits.
• Enhanced progress monitoring to provide accurate time estimates and status updates.
• Granular tracking of file dependencies between Wallaby restarts to determine cache validity.

With Wallaby v3

Critically, these changes were only feasible because of Wallaby v2’s UI framework. The redesigned panels (e.g., Overview Tests, Errors, and Logs) and modes (Linked and Standalone) can handle incremental updates, out‑of‑order results, and potential stale data indicators without overwhelming users. Without the flexibility of the v2 UI, we couldn’t reliably communicate progress or display interim states.

Try it out

To experience Wallaby v3 (result streaming and cached results), we recommend using the sample repository below. Clone the Wallaby Vitest sample from GitHub:

• git clone https://github.com/wallabyjs/wallaby-v3-demo
• cd wallaby-v3-demo
• npm ci

Then, install and start Wallaby in your preferred editor. For Standalone Mode, run npm install -g @wallabyjs/cli && wallaby.

Suggestions to try:

• Result Streaming: Open a shared file, src/common.js in your editor. At the same time, open ./test/snail.test.js and ./test/car.test.js in your editor so you can see all 3 files at the same time. Change the value returned by the helloWorld function of common.js. You will see the updated value returned for the faster test (./test/car.test.js) first and then the slower test (./test/snail.test.js) when it finishes.
• Cached Results: Stop Wallaby, then open ./test/snail.test.js restart Wallaby without making changes. Note how coverage indicators with the previous results appear instantly in the file, and the test results are updated in the Side View’s Tests and Coverage tabs. Refer to the comments at the top of snail.test.js for more scenarios to explore.

These experiments highlight the speed gains, especially if you scale up by adding more tests to the repo.

What’s next

Wallaby v3 is the engine overhaul; result streaming and cached results are simply the first visible outcomes. The architectural work gives us room to explore broader improvements that weren’t practical before. Directionally, we’re looking at ways to:

• Surface deeper test impact analytics and statistical insights.
• Distributed result cache that is shared across your team.
• Test run diff viewer to compare results between different git branches or commits.
• Mutation testing/assertion coverage to increase quality of assertions.
• Improved integration with AI tools.

We’d love your feedback as we continue to roll out more Wallaby capabilities.

Tweet us at @wallabyjs or drop a line at hello@wallabyjs.com.

Thanks for reading.