| 
                                   Hello! 
                                  
                                    This week, we shipped a major release: Wallaby v3. The new version
                                    streams results in real time, starts instantly with cached results, and prioritizes
                                    what matters. Below you'll find a quick tour of v3, Wallaby/Quokka highlights since
                                    our last newsletter, an update on Console Ninja, and what's next.
                                   
                                  Wallaby v3: faster, real-time results
                                  
                                    Wallaby v3 includes an overhauled execution engine that delivers
                                    streaming test results, coverage, logs, and errors directly to your
                                    editor, plus cached results on startup and
                                    smart prioritized execution. You'll also see updated progress
                                    indicators and execution time estimates. You don't need to do anything special to
                                    take advantage of these improvements.
                                    Read the full announcement.
                                   
                                  
                                     
                                   
                                  
                                    The video below shows Wallaby's instant start with cached results even though the
                                    test takes ~10 seconds to run.
                                   
                                  
                                     
                                   
                                  Result streaming
                                  
                                    See feedback as it happens: failing tests, logs, coverage, and errors stream
                                    into the Overview panel and Side View without waiting for the full run to finish.
                                    Open files and related tests are prioritized, and editing mid-run only re-queues
                                    what changed.
                                    Learn more.
                                   
                                  
                                     
                                   
                                  
                                    The video below shows Wallaby streaming results for a faster test file before the
                                    slower one finishes.
                                   
                                  
                                     
                                   
                                  Cached results on startup
                                  
                                    Start Wallaby and get immediate coverage and test results from your last session.
                                    Wallaby then quickly verifies results in the background using it's new prioritized,
                                    streaming pipeline, refreshing anything that changed.
                                    How cached results work.
                                   
                                  
                                     
                                   
                                  What's New
                                  
                                    Here are some highlights of the updates we've shipped since our last newsletter. You
                                    can read more on
                                    Wallaby's What's New page,
                                    Quokka's What's New page and in our
                                    CHANGELOG.md.
                                   
                                  Wallaby - Test Explorer in Overview panel
                                  
                                    Toggle between a list of failing tests and your full test tree directly in the
                                    Overview panel. The same actions and keyboard shortcuts work in both views, making
                                    it easy to jump between a failure-focused workflow and full-suite navigation.
                                   
                                  
                                     
                                   
                                  Wallaby - Coverage View improvements
                                  
                                    Coverage is now automatically filtered based on
                                    Smart Start and
                                    selected/focused tests, helping you concentrate on relevant files and avoid noise from unrelated parts of
                                    your project.
                                    Read more.
                                   
                                  
                                     
                                   
                                  Wallaby/Quokka - Log copying improvements
                                  
                                    Quickly copy values and paths (including nested values) from Wallaby/Quokka Logs
                                    using new keyboard shortcuts and a context menu — super handy for object hierarchies
                                    and arrays.
                                   
                                  
                                     
                                   
                                  Wallaby - VS Code coverage in Explorer View
                                  
                                    See file-level code coverage at a glance in VS Code's Explorer and the Coverage
                                    View. It's much faster to spot what's covered and what isn't.
                                    Read more.
                                   
                                  
                                     
                                   
                                  Wallaby - Angular v20 support
                                  
                                    Full support for Angular CLI v20, which switches to esbuild by default. Works with
                                    both @angular/build:karma and legacy
                                    @angular-devkit/build-angular:karma
                                    configurations.
                                   
                                  Wallaby - Improved diffs for Jest/Vitest
                                  
                                    Cleaner, more readable asymmetric matchers diffs when using
                                    expect.any(), expect.objectContaining(),
                                    expect.stringContaining(), etc. We replace verbose raw matcher code
                                    with intuitive labels like Anything<String> and
                                    StringContaining "hello" while keeping full values available for
                                    copying.
                                   
                                  
                                     
                                   
                                  Wallaby - Automatic Node.js version selection
                                  
                                    Wallaby now automatically detects and selects the correct Node.js version based on
                                    .nvmrc, .node-version,
                                    package.json (engines.node), and more. When multiple versions are
                                    installed, Wallaby picks the right one using your existing version manager
                                    (nvm, volta, fnm, asdf, etc.).
                                   
                                  Wallaby - Major performance improvements
                                  
                                    Faster incremental runs, better handling of compute-heavy/path-rich tests, and
                                    quicker startup for small projects: ~10x less CPU/memory for code insights,
                                    incremental metadata, and fewer unnecessary workers.
                                   
                                  Wallaby - Support for Jest 30.0.x+
                                  
                                    Compatibility with the latest Jest (30.0.x+), which included some major breaking
                                    changes.
                                   
                                  Console Ninja: Next.js Turbopack support
                                  
                                    Console Ninja has supported Next.js since day one, giving you instant inline logs,
                                    runtime errors, and smart tooling while you build. Until now, that support relied on
                                    the classic webpack pipeline. As Next.js moves its default dev experience to
                                    Turbopack, we wanted Console Ninja to keep feeling invisible and effortless, no
                                    matter which bundler you use.
                                   
                                  
                                    We're excited to add native Turbopack support. Fire up a modern
                                    Next.js project (where npm run dev runs Turbopack by default) and
                                    Console Ninja will seamlessly capture and map your runtime logs, errors, and network
                                    calls just like it does with webpack builds.
                                   
                                  
                                     
                                   
                                  
                                    Supporting Turbopack wasn't as simple as reusing our existing webpack integration.
                                    Turbopack is written in Rust, and its native architecture meant we couldn't "patch"
                                    JavaScript build steps the usual way. Instead, Console Ninja now goes native: under
                                    the hood we use a high-performance N-API addon to efficiently intercept and
                                    instrument the files Turbopack is bundling. This lets us preserve accurate source
                                    locations and deliver the same low-friction experience.
                                   
                                  
                                    Turbopack support for Next.js projects is a PRO feature but we are making it available
                                    to Community Edition users during an extended preview period. If you are using
                                    Community Edition and wish to use Turbopack, you must also be using a supported
                                    version of Next.js (usually available within ~2 months of release). If you are a PRO
                                    user, you can use Turbopack with any supported Next.js version (including the latest
                                    version).
                                   
                                  What's next
                                  
                                    Across Wallaby, Quokka, and Console Ninja, we're exploring improvements that speed
                                    up feedback and deepen insight:
                                   
                                  
                                    - 
                                      Deeper test and runtime impact analytics with statistical insights.
                                    
 
                                    - 
                                      Distributed execution/result cache shared across your team.
                                    
 
                                    - 
                                      Test run diff viewer to compare results across branches/commits.
                                    
 
                                    - 
                                      Mutation testing and assertion coverage to improve test quality.
                                    
 
                                    - Richer, more integrated AI-assisted workflows.
 
                                   
                                   
                                  
                                    As always, thank you for being a part of our community. If you have any feedback or
                                    suggestions, please don't hesitate to reach out.
                                   
                                  Happy Coding! 🧑💻 
                                  Regards, Simon McEnlly 
                                 |