Bun Just Killed Concurrently.

Bun 1.4, a significant Rust rewrite, recently landed, introducing more than just performance enhancements to the JavaScript runtime. This update reinforces Bun's position as an all-in-one toolkit, aiming to consolidate developer utilities into a single, cohesive platform. It represents a strategic move towards a more integrated development environment.

Central to Bun 1.4's impact is its new built-in script runner, which natively handles parallel and sequential execution of package.json scripts. This capability renders third-party tools such as concurrently and npm-run-all largely obsolete for many projects, absorbing functionality previously requiring external dependencies. Developers can now use the --parallel flag to run multiple scripts concurrently.

The integrated runner provides essential features, including prefixed output for clarity, glob matching for script selection, and workspace filtering. An option also allows other scripts to continue even if one errors out, enhancing robustness. This internal mechanism streamlines complex development workflows directly within Bun.

This absorption of common tooling exemplifies Bun's broader strategy to simplify the JavaScript ecosystem. By providing native alternatives, Bun actively reduces node_modules bloat and streamlines project configuration, moving away from fragmented toolchains. It offers a more unified and efficient developer experience.

Bun 1.4 introduces a native --parallel flag, fundamentally altering how developers execute multiple package.json scripts. This enhancement eliminates the need for external tools like concurrently or npm-run-all, streamlining development workflows directly within Bun. Users now launch multiple development servers or watchers simultaneously from a single command.

Execute scripts concurrently by listing them after bun run --parallel. For example, bun run --parallel "dev:frontend" "dev:backend" initiates both tasks in parallel. This mirrors common package.json setups where dev:frontend might start a React server and dev:backend a Node.js API.

Quality-of-life improvements accompany the parallel execution. Output from each concurrent script automatically includes a prefixed name, clarifying which process generated which log. Developers can also leverage glob matching; bun run --parallel "dev:*" will execute all scripts matching the dev: prefix, such as dev:frontend and dev:backend, without explicit listing.

Further control is available through the --continue-on-error option. This flag ensures that a non-critical script failure, like a linter reporting errors, does not halt the entire development environment. Other parallel processes, such as active dev servers, continue running uninterrupted, preserving workflow continuity. This feature enhances robustness in complex multi-service development setups.

Bun 1.4 extends its native script execution capabilities beyond parallel processing with the introduction of the --sequential flag. This complementary feature establishes Bun as a complete, integrated task runner, eliminating the need for external npm packages to manage complex script workflows.

The --sequential flag ensures tasks execute in a defined order, critical for numerous development and deployment scenarios where dependencies exist between steps. Specific use cases include:

• Running database migrations to completion before a server starts.
• Executing a build process entirely before initiating a test suite.
• Performing sequential data seeding operations where data integrity relies on ordered inserts.

Bun maintains a consistent developer experience across both parallel and sequential operations. Developers leverage the same elegant package.json script syntax, benefiting from clear, prefixed output that attributes logs directly to their originating script, enhancing debugging and monitoring.

This consistency extends to advanced filtering capabilities, allowing precise control over which scripts execute within a workspace, particularly useful in monorepo environments. For comprehensive information on these filtering options, consult bun --filter | Bun Docs. Bun's --sequential flag, alongside --parallel, provides robust, native script orchestration, simplifying project setup and significantly reducing reliance on tools like concurrently or npm-run-all.

Bun 1.4 introduces the --filter flag, a significant enhancement for monorepo management. This feature allows developers to target specific packages within a workspace when executing scripts, directly streamlining complex project workflows. It addresses a long-standing challenge in large-scale development environments, moving beyond generic script execution.

Previously, coordinating commands across numerous sub-packages often necessitated custom shell scripts or intricate tooling configurations with external utilities like Lerna or Nx. With --filter, Bun simplifies this process natively, embedding workspace awareness into its core. For instance, to run tests solely for a specific backend service, developers execute bun run test --filter=@my-app/backend.

This command directly targets the @my-app/backend package, isolating test execution without initiating operations on unrelated project components. The capability extends beyond testing, applying to build, lint, or development server commands across the entire workspace. It provides granular, efficient control over multi-package operations.

The --filter flag drastically reduces reliance on bespoke scripting solutions, which grow difficult to maintain and debug as projects scale. This native integration solidifies Bun's utility for organizations managing extensive codebases and complex dependencies. It positions Bun 1.4 as a robust, all-in-one task runner for enterprise-level workspaces.

What's new in Bun 1.4 for running scripts?

Bun 1.4 introduced native support for running package.json scripts in parallel (--parallel) or sequentially (--sequential), eliminating the need for third-party packages like concurrently or npm-run-all.

How does Bun's script runner handle errors?

By default, if one script fails, all others are terminated. However, you can use a flag to allow the other scripts to continue running even if one encounters an error, which is useful for complex development environments.

Can I run scripts for specific packages in a monorepo with Bun?

Yes, Bun includes a --filter flag that lets you target specific packages within a workspace (monorepo), allowing for precise command execution across your project.

Does Bun only support parallel scripts?

No, Bun supports both parallel and sequential script execution. The --sequential flag runs scripts one after another, offering the same prefixed output and filtering capabilities as the parallel runner.

Why is Bun 1.4 referred to as a Rust rewrite?

The video transcript mentions Bun 1.4 as a 'Rust rewrite,' indicating a significant architectural change where major parts of the runtime were rewritten in the Rust programming language for enhanced performance and safety.