scalacenter/bloop

Bloop is a build server for Scala projects that provides fast, incremental compilation and testing via the BSP and DAP protocols. It integrates with build tools like SBT to generate configuration files, supporting compilation, linking, and execution for JVM, Scala.js, and Scala Native targets. The system manages compiler instances, caches dependencies, and handles process forking to enable efficient development workflows.

52 changes.

This period focused on replacing the standard Zinc incremental compiler with a custom Bloop implementation to improve performance and resilience, while restructuring the BSP communication layer for better modularity. The work also established robust release engineering, benchmarking, and testing infrastructure to support the new compilation pipeline and multi-platform targets like Scala.js and Scala Native.

33 changes.

This period focused on enhancing build performance through parallel source hashing, compiler plugin caching, and the introduction of the Buildpress tool for large-scale integration testing. It also expanded platform support by adding bridges for Scala Native 0.4/0.5 and Scala.js 1.x, while significantly broadening test coverage across these new targets and core I/O components.

28 changes.

This period focused on introducing Debug Adapter Protocol support for remote debugging and enhancing the CLI with native entry points and Ammonite console capabilities. The team significantly expanded test coverage across sbt-bloop integrations, compiler plugins, and backend task logic to ensure robust handling of diverse project configurations and edge cases.

A new JMH benchmark suite (BloopLoggerBenchmark) has been added to measure the performance of Bloop's logging operations. It benchmarks info, warn, error, and debug log methods, including a variant that passes a DebugFilter context, using a null output stream to isolate logging overhead.

benchmarks/src/main/scala/bloop/logging · high confidence

The project now includes a new documentation website built with Docusaurus, introducing core React components such as a customizable footer (with links to documentation, build tools, and social channels like Discord) and a flexible GridBlock component for rendering content sections with aligned images and titles.

website/core · high confidence

A new JMH-based benchmark (HotSbtBenchmark) has been added to measure the performance of SBT compilation tasks. This benchmark spawns an SBT process, injects a custom plugin to clean class directories, and measures the time taken to compile specified projects, providing a way to track changes in SBT's hot compilation speed.

benchmarks/src/main/scala/sbt · high confidence

New JMH-based benchmarks have been added to measure Bloop's performance in two key areas: hot compilation and project loading. The \HotBloopBenchmark\ suite spawns a Bloop server process to measure compilation times for various projects, supporting both standard and pipelined compilation modes (\--pipeline\) with configurable JVM arguments and warmup parameters. The \ProjectBenchmark\ suite measures the time required to load project configurations for specific large-scale projects (sbt, lichess, akka) directly via the internal \State.loadActiveStateFor\ API, providing insight into configuration parsing and initialization performance.

benchmarks/src/main/scala/bloop · high confidence

Introduces the \JsBridge\ component for Scala.js 0.6, enabling Bloop to link Scala.js projects and run tests. This implementation supports linking with configurable modes (Debug/Release), module kinds (NoModule, CommonJS, ESModule), and source maps. It also provides test infrastructure by discovering test frameworks and executing them via Node.js or JSDOM, controlled by the new \jsdom\ configuration flag in \JsConfig\.

bridges/scalajs-0.6/src/main · high confidence

The new JsBridge implementation in the Scala.js 1.x bridge enables linking for Scala.js 1.x projects, introducing support for WebAssembly via the experimental linker flag and enabling new minification for release builds. It also implements caching of Scala.js linkers to support incremental linking, allowing faster rebuilds by reusing linker instances when configuration and target directory remain unchanged.

bridges/scalajs-1 · high confidence

The project now includes a new documentation website built with Docusaurus, providing users with a landing page, an installation guide with interactive setup steps, a help page, and a user showcase. This replaces the previous static documentation structure with a navigable site that includes specific guides for various build tools and editors.

website/pages · high confidence

This change introduces three new JavaScript files to the website's static assets to enhance user interaction. The \build-tools.js\ script enables toggleable groups for build tools, persisting the user's selection in session storage so the active tool is remembered across page navigations. The \code-block-buttons.js\ script adds 'Copy' buttons to all code blocks, allowing users to copy code to their clipboard with visual feedback. The \tools.js\ script manages the interactive tools section, supporting both session storage persistence and URL hash-based navigation to maintain state when users share or bookmark specific tool views.

website/static/scripts · high confidence

Users can now link Scala.js and Scala Native projects to generate JavaScript files and native binaries, respectively. This new LinkTask integrates with the BSP protocol via the --link flag, allowing the linker to be invoked through the build server. The implementation supports runtime classpath resolution, configurable optimizer modes (Debug/Release), and handles main class extraction for both platforms.

frontend/src/main/scala/bloop/engine/tasks · high confidence

Bloop now generates shell-specific completion scripts for Bash, Zsh, and Fish, enabling tab-completion for commands, arguments, project names, test classes, main classes, reporters, and BSP protocols. The implementation includes a shared Format trait and shell-specific formatters (BashFormat, ZshFormat, FishFormat) that map CLI arguments to appropriate completion functions (e.g., \_projects, \_files, \_testsfqcn). Additionally, command-line argument names are converted from camelCase to kebab-case to align with standard shell conventions.

frontend/src/main/scala/bloop/cli/completion · high confidence

A new utility object, BloopForkedJavaUtils, has been added to handle the execution of the javac compiler in a forked process. This component manages the construction of command-line arguments, specifically separating JVM-specific arguments (prefixed with -J) from compiler options and source files, and utilizes an argument file to pass the latter to the compiler executable. It also handles logging and reporting of the compilation process results.

backend/src/main/scala/sbt/internal/inc/javac · high confidence

A new \CrossPlatform\ utility object has been added to the shared codebase to provide consistent detection of the operating system (Windows, Mac) and CPU architecture (specifically identifying M1/ARM64 processors). This enables other parts of the build tool to adapt their behavior based on the underlying platform, such as handling native and JavaScript linking differently across environments.

shared/src/main/scala/bloop/util · high confidence

New bridge implementations have been added for Scala Native 0.4 and 0.5, enabling Bloop to link native binaries using the respective Scala Native build APIs. The 0.4 bridge provides synchronous linking, while the 0.5 bridge supports asynchronous linking via \Future\ and includes additional configuration options such as multithreading and base directory settings.

bridges/scala-native-0.4 · high confidence

The \etc\ directory now includes new shell completion scripts for Bash, Fish, and Zsh, enabling users to get command, project, and flag completions for the \bloop\ CLI. These scripts query the \bloop autocomplete\ command to provide context-aware suggestions. Additionally, a new \bloop-coursier.json\ configuration file has been added to define the launcher type, repositories, and dependencies for the Bloop CLI.

etc · high confidence

A new \CommunityBuild\ application has been added to the integration test suite (\frontend/src/it/scala/bloop/CommunityBuild.scala\). This tool reads project definitions from a local 'buildpress' cache directory and compiles them sequentially. It supports features such as pipelining, best-effort compilation, and source generators, and includes logic to clear successful results between runs to manage memory usage. This change introduces a new capability for running large-scale integration tests against multiple external Scala projects.

frontend/src/it · high confidence

Bloop now automatically detects and adds the necessary adapter dependencies for JUnit 5 (via \jupiter-interface\) and TestNG (via \mill-contrib-testng\) when they are present on the classpath but the corresponding framework adapters are missing. This enables Bloop to discover and run tests written with these frameworks without requiring manual configuration of additional dependencies by the user.

frontend/src/main/scala/bloop/testing · high confidence

The docs-gen tool now automatically generates release version tables for Bloop and the launcher (rifle) by querying Sonatype. This change introduces a new Scala-based documentation generator that uses mdoc to embed dynamic version, publication date, and resolver information directly into the documentation site, replacing manual updates and removing previous Bintray references.

docs-gen · high confidence

The buildpress tool now includes a new configuration file, bloop-community-build.buildpress, which defines the initial set of projects to be included in the community build. This file explicitly lists three active repositories—Metals, Quill, and Dotty—with their specific Git commit SHAs, while maintaining a commented-out list of additional projects (such as Linkerd, Cats, and Spark) that are currently marked as out of date or require specific SBT version adjustments.

buildpress/src/main/resources · high confidence

This change establishes the foundational configuration for the Bloop project. It introduces a Code of Conduct and an Apache 2.0 license (replacing the previous MIT license), along with a NOTICE file attributing dependencies like Nailgun and Zinc. It also sets up development tooling by adding \.scalafmt.conf\ (version 3.11.5), \.scalafix.conf\, and \.scala-steward.conf\ for automated dependency updates, while configuring \.gitattributes\ for line endings and \.gitignore\ for build artifacts and IDE files.

(repo-wide) · high confidence

This change introduces the foundational CSS styles for the new Docusaurus-based documentation site. It defines the visual appearance of code blocks with language-specific labels and copy buttons, establishes the layout and responsive behavior for the landing page and installation guides, and styles the setup instructions and tool selection interfaces.

website/static/css · high confidence

Bloop now includes its own Zinc compiler implementation (\BloopZincCompiler\ and \ZincInternals\) to handle incremental compilation. This new code path manages the compilation lifecycle, including incremental logic via \BloopIncremental\, analysis invalidation, and Java compiler instantiation. It also adds support for reporting diagnostics with range positions and handles Javac column information by defaulting to column 0 when unavailable.

backend/src/main/scala/sbt/internal/inc/bloop · high confidence

This change adds the initial prototype for the Buildpress tool, establishing the main entry point in Main.scala which extends the Buildpress class to handle command-line execution and output streams. It also introduces package-level utility functions in package.scala to manage standard output printing and format success/error messages with emojis, providing the foundational interface for the new CLI tool.

buildpress/src/main/scala/buildpress · high confidence

The backend now supports isolated compilation outputs and build pipelining to improve performance and reliability. New classes \CompileProducts\ and \CompileOutPaths\ manage separate \readOnlyClassesDir\ and \newClassesDir\ locations, allowing dependent compilations to proceed immediately using a snapshot of results while background tasks copy files. The \Compiler\ and \CompilerCache\ modules have been refactored to support this architecture, including the creation of internal classes directories (e.g., \bloop-internal-classes\) and the introduction of \CompileExceptions\ to handle fatal compiler crashes gracefully. This infrastructure enables features like build pipelining and parallel compilation by decoupling the immediate compilation result from the final persistence of class files.

repository · high confidence

The Bloop frontend now includes a new interactive shell mode (Bloop.scala) and a dedicated server process (BloopServer.scala). The shell allows users to execute commands like compile, test, clean, and run directly via a CLI interface, though it is marked as unsupported in favor of the Nailgun integration. The server component handles daemon management, including lock file handling, zombie process detection, and configurable port binding, providing the underlying infrastructure for the Bloop service.

frontend/src/main/scala/bloop · high confidence

The compilation engine now supports caching compiler plugin classloaders to improve performance. A new \CompilerPluginAllowlist\ component checks if plugins are safe for caching based on a whitelist and Scala version compatibility, and if so, adds the \-Ycache-plugin-class-loader:last-modified\ scalac option. This is supported by a new \CompileClientStore\ to manage compilation traversal state concurrently.

frontend/src/main/scala/bloop/engine/tasks/compilation · high confidence

The Bloop project now includes a dedicated documentation website built with Docusaurus. This new site provides users with structured guides for installation (supporting Universal, Homebrew, Scoop, and AUR), detailed CLI tutorials, and integration instructions for build tools (Sbt, Maven, Mill, Gradle) and IDEs (IntelliJ, Metals). It also features a release table, debugging references, and a blog section, all organized via a configurable sidebar and styled with a custom theme.

website · high confidence

The \bin\ directory now includes four new scripts to support release engineering and performance testing. \ci-setup-bloopoid-keys.sh\ automates the configuration of SSH keys and git metadata for the Bloopoid bot to push release artifacts. \release\_notes.scala\ generates release notes by querying the GitHub API for merged pull requests and contributors between two tags. \run-benchmarks.sh\ provides a configurable infrastructure for running JMH benchmarks across various Scala projects (such as Spark, Lichess, and Akka) using different JVMs and JMH options. Finally, \test-native-cli.sh\ performs smoke tests on the native Bloop CLI binary, verifying that JVM arguments are correctly handled by the GraalVM native image and that the server can execute tests via Scala CLI.

bin · high confidence

Bloop now includes a new Debug Adapter Protocol (DAP) implementation in the frontend, enabling users to attach external IDEs or editors to debug Scala main classes and test suites. This change introduces new components (BloopDebugToolsResolver, BloopDebuggee, DapCancellableFuture) that resolve debugger tools via dependency resolution, manage debug sessions for JVM applications and tests, and bridge Bloop's internal task execution with the DAP protocol. Users can now use the --jvm-debug flag to start run and test commands in debug mode, allowing remote debugging connections.

frontend/src/main/scala/bloop/dap · high confidence

This change introduces new internal utilities in the \buildpress.io\ and \buildpress.util\ packages to support build analysis. \BuildpressPaths\ provides a helper to resolve the user home directory (preferring the \HOME\ environment variable) and a robust recursive file deletion method. \SbtProjectHasher\ implements logic to detect and hash SBT build files (\.sbt\, \.scala\, \build.properties\) within a repository, including nested \project/\ directories, while excluding \target\ folders. Additionally, \Traverse\ adds functional traversal helpers (\eitherTraverse\, \eitherFlatTraverse\) for processing lists with potential failures.

buildpress/src/main/scala/buildpress/io · high confidence

The CLI module now provides a new native launcher entry point (Bloop.scala) that correctly handles \-D\ system properties by separating launcher-specific flags from command arguments, ensuring that flags passed after \--\ reach the underlying tools. It introduces a new \console\ command that runs the Ammonite REPL locally with proper terminal access, fixing previous issues where interactive sessions failed. The CLI also includes GraalVM reflection configuration for necessary Java classes, custom progress bar displays for dependency downloads, and utilities for detecting the Linux C library (glibc vs musl) to select the appropriate JVM.

cli · high confidence

Added new utility objects in the frontend's bloop.util package to support core functionality: Console.scala provides ANSI escape sequences for clearing the screen and scrollback; Environment.scala defines the default .bloop directory location; SystemProperties.scala introduces a configurable timeout (defaulting to 30 seconds) for compilation disconnection via the bloop.compilation.seconds-before-disconnection system property; TimeFormat.scala adds human-readable formatting for durations; and JavaCompat.scala provides implicit conversions between Java and Scala types. These utilities enable cleaner handling of terminal output, environment configuration, and timeout management in the build tool.

frontend/src/main/scala/bloop/util · high confidence

Bloop now supports linking and running projects targeting Scala.js 1.x (in addition to 0.6.x) and Scala Native 0.4 and 0.5. The new \ScalaJsToolchain\ and \ScalaNativeToolchain\ implementations in the frontend resolve the appropriate bridge artifacts and linker dependencies (such as \scalajs-env-nodejs\ 1.4.0 for Scala.js) based on the configured platform version, enabling users to build and test applications for these JavaScript and native targets.

frontend/src/main/scala/bloop/engine/tasks/toolchains · high confidence

The benchmarking tooling now includes a custom \ForkedAsyncProfiler\ implementation that enables profiling of forked benchmark processes using async-profiler. This change adds the ability to profile per-thread, generate Java Flight Recorder (JFR) dumps alongside standard profiles, and automatically produce SVG flame graphs from the collected data. It also introduces utility classes (\ProfilerUtils\, \NoResult\) to handle command-line parsing, process execution, and result aggregation for these profiling artifacts.

benchmarks/src/main/java · high confidence

sbt-bloop now correctly handles projects using sbt's multi-jvm configuration. Users can compile multi-jvm sources via sbt and export them to Bloop without requiring additional build setup, ensuring that the generated Bloop configuration files include the multi-jvm sources.

integrations/sbt-bloop/src/sbt-test/sbt-bloop/multi-jvm-configuration · high confidence

Bloop now supports source generators, caching their execution states to avoid redundant work, and adds support for the Java SemanticDB plugin (com.sourcegraph:semanticdb-javac) alongside the existing Scala SemanticDB support. The new SemanticDBCache logic also improves robustness by attempting to find the latest supported SemanticDB version if the requested one is unavailable for a given Scala version.

frontend/src/main/scala/bloop/engine/caches · high confidence

The sbt-bloop integration now supports sbt 2.x by introducing a new compatibility layer (CompatPlatform) that abstracts differences between sbt 1.x and 2.x, such as handling the new Result enum, IntegrationTest configuration, and file reference types. This change accompanies the removal of support for sbt 0.13, as the plugin now requires sbt 1.9.0 or later. Users upgrading to sbt 2.x will benefit from improved compatibility, while those on older sbt versions must upgrade to continue using the plugin.

integrations/sbt-bloop/src/main · high confidence

The frontend now includes three custom Monix operators in the \bloop.util.monix\ package to handle event streams more precisely: \BloopBufferTimedObservable\ replaces the standard \bufferTimed\ to provide custom timed batching with a workaround for a known Monix scheduling issue; \FoldLeftAsyncConsumer\ provides a forked async folding consumer for processing streams with side-effecting tasks; and \WhileBusyDropEventsAndSignalOperator\ buffers events during busy periods and signals a consolidated overflow message when the subscriber is ready, improving responsiveness during high-load compilation events.

frontend/src/main/scala/bloop/util/monix · high confidence

The reporter module now provides more detailed feedback during compilation by logging the start and end of each incremental cycle, including the specific source files involved and the duration of the cycle. To support concurrent execution in Hydra, the reporter implementations now use thread-safe data structures (ConcurrentHashMap-based sets) for tracking compiling files and problem buffers. Additionally, the system now replays and logs warnings from previous successful compilation runs when a new compilation fails, ensuring users see the full context of errors across incremental builds.

frontend/src/main/scala/bloop/reporter · high confidence

The build loading process has been refactored to support incremental loading, which speeds up project initialization by only re-transforming projects that have changed. This change introduces better user feedback, including specific error messages when the configuration directory is missing or when recursive dependencies are detected, and ensures that file watching tasks exit cleanly. Additionally, the system now handles unsupported Scala versions more gracefully by skipping SemanticDB configuration for them rather than failing, and provides clearer guidance on debugging setup issues related to JDK/JRE detection.

frontend/src/main/scala/bloop/engine · high confidence

The \bloop-rifle\ module has been introduced to replace the previous \snailgun\-based launcher, providing a new, self-contained client for starting and connecting to the Bloop build server. This change includes a new logging abstraction (\BloopRifleLogger\), updated connection handling via \BspConnection\, and a refactored \Operations\ object that now uses \java.nio.file.Path\ instead of \java.io.File\ for working directories. Additionally, the launcher now filters out the unsupported \-XX:+UseZGC\ JVM option on BSD systems and improves server startup reliability by removing unnecessary permission checks on lock files.

bloop-rifle · high confidence

Bloop replaces its previous logging infrastructure with a new \BloopLogger\ implementation that supports per-build scoping, configurable color output, and debug filtering via \DebugFilter\. This change introduces an \ObservedLogger\ for replaying log events to external clients, a \ProcessLogger\ to capture and forward standard output/error from forked processes, and a \Slf4jAdapter\ to ensure compatibility with third-party libraries like lsp4s. Users will see more structured, context-aware logs with proper handling of ANSI colors and process stream forwarding.

backend/src/main/scala/bloop/logging · high confidence

The BSP communication layer has been restructured into a new set of core components: \BloopBspServices\ now acts as the central service provider exposing endpoints like compile, test, run, and debug; \BloopLanguageClient\ handles outgoing JSON-RPC messages and request tracking; \BloopLanguageServer\ manages incoming message routing and request cancellation; and \BspServer\ orchestrates the socket listening and connection lifecycle. This change replaces the previous monolithic or legacy BSP handling with a more modular architecture that supports better request cancellation, sequential message processing, and cleaner resource management for both TCP and Unix socket connections.

frontend/src/main/scala/bloop/bsp · high confidence

The classpath hashing mechanism has been rewritten to support cancellation, allowing interrupted compilation tasks to stop hashing early rather than waiting for completion. This new implementation includes a 15-second timeout per file entry to prevent stalling, rehashes entries if their owner process is cancelled, and caches metadata to avoid redundant work. Additionally, a new Timer utility is introduced to log elapsed times for operations, aiding in performance monitoring.

backend/src/main/scala/bloop/io · high confidence

This change introduces a new set of internal I/O utilities in the \bloop.io\ package, including \AbsolutePath\, \RelativePath\, \ByteHasher\, and \Paths\. These components provide a consistent wrapper around Java NIO paths, implement file hashing via XXHash, and manage cache/data directories using the \dev.dirs\ library. Additionally, the \Environment\ object now reliably handles line separators by recognizing valid shell paths in the \SHELL\ environment variable and normalizing carriage returns, which fixes autocompletion issues on Windows. The \Paths\ component also truncates file modification timestamps to milliseconds to ensure consistency across different JVM versions.

shared/src/main/scala/bloop/io · high confidence

The application's logging setup has been replaced with a new Logback configuration. A new logback.xml file defines a console appender that outputs logs with timestamps, thread names, and log levels, while suppressing internal Logback status messages. The root logger level is set to 'error', meaning only error-level messages and above will be displayed to the user. Additionally, a log4j2.properties file was created, though the active configuration is driven by the Logback XML file.

frontend/src/main/resources · high confidence

The CLI frontend now uses a new \case-app\-based parser (\CliParsers.scala\) to handle command-line arguments, introducing support for shell completions (bash, zsh, fish), debug filters (e.g., \--debug-filter=compilation\), and optimizer configurations (\--optimize=release\). A new \ExitStatus\ system replaces generic exit codes with specific, named statuses (e.g., \LinkingError\, \TestExecutionError\) to provide more precise feedback on command failures. Additionally, \Validate.scala\ adds strict validation for BSP socket paths (including length limits on macOS) and JVM debug ports, ensuring users receive clear error messages for invalid configurations before execution.

frontend/src/main/scala/bloop/cli · high confidence

The backend introduces a new component management system for the Zinc incremental compiler, including a \BloopComponentManager\ that handles caching and retrieval of compiler bridges via a primary and optional secondary cache, along with supporting classes for error handling (\InvalidComponent\, \MissingScalaJar\), missing-component resolution strategies (\IfMissing\), and resource loading. It also adds \BloopZincLibraryManagement\ to instantiate instrumented Scala compilers and \HydraSupport\ to detect and configure the Hydra compiler bridge based on system properties, enabling users to leverage Hydra-specific compilation optimizations when available.

backend/src/main/scala/sbt/internal/inc · high confidence

Added several new utility objects and classes to the backend to support improved compilation analysis and internal operations. HashedSource provides an in-memory virtual file representation with content hashing to ensure consistent source identification during compilation. AnalysisUtils extracts source information and reported problems from previous compile analyses, enabling better reporting of classpath hash mismatches and no-op compilations. Diff offers unified diff generation for comparing file contents. UUIDUtil replaces hex UUID strings with Base64 representations for more compact identifiers. Java8Compat provides utilities to convert between Scala Futures and Java CompletableFutures, integrating with Monix for asynchronous execution. CacheHashCode optimizes hash code computation for DAG graph visualization.

backend/src/main/scala/bloop/util · high confidence

The build system now hashes source files in parallel to improve performance, while supporting cancellation of the hashing process to allow for responsive builds. It introduces a new \sourcesGlobs\ configuration field in the Bloop JSON, allowing users to specify custom glob patterns for source discovery alongside standard directory scanning. The implementation also handles source generators and ensures that hidden files are excluded from hashing.

frontend/src/main/scala/bloop/io · high confidence

Bloop introduces a new transactional class file management strategy that uses backup directories and symbolic links to handle invalidated class files, preventing compiler errors when sources move between dependent projects. The build now caches Scala instances and classpath entry lookups (including JAR and directory class definitions) to improve performance, while introducing a custom top-level classloader to correctly resolve sbt interfaces and JDK classes for Scala 3 (Dotty) and Scala 2 compilers. Additionally, a new observer mechanism notifies clients of changed classes to support features like hot reloading in debug sessions.

backend/src/main/scala/bloop · high confidence

The compiler reporter module has been restructured to support more flexible error formatting and better integration with build clients. A new \ReporterFormat\ abstraction allows for distinct output styles, including a \ClassicFormat\ that displays error IDs and a \ScalacFormat\ that mimics the standard Scala compiler output. Additionally, an \ObservedReporter\ wrapper now tracks compilation events (such as problem reporting and progress updates) via an action stream, enabling clients to receive detailed diagnostic information and progress updates in real-time.

backend/src/main/scala/bloop/reporter · high confidence

The logging subsystem has been restructured to introduce a \ScribeAdapter\ trait that bridges the internal logger interface with the Scribe logging library, mapping Scribe levels to internal methods. A new \BspClientLogger\ wrapper has been added to handle BSP-specific logging contexts, including support for origin IDs and verbose modes. Additionally, a \NoopLogger\ implementation was introduced to provide a silent logger instance, and the logging system now utilizes a \DebugFilter\ mechanism to control debug message visibility, replacing the previous \LogContext\ approach.

frontend/src/main/scala/bloop/logging · high confidence

Bloop no longer uses the standard Zinc incremental compiler; instead, it uses a new internal implementation (BloopIncremental, BloopNameHashing, BloopHighLevelCompiler) that wraps Zinc's algorithm in a task-based API. This change introduces Bloop-specific stamp handling (CachedBloopStamps/BloopStamps) and a custom lookup (BloopLookup) that filters out directories and empty classes directories from classpath-hash changes, and it adds crash handling for compiler errors (e.g., StackOverflowError, NoClassDefFoundError) so that compilation failures are reported rather than hanging. The result is more precise incremental invalidation and better resilience to compiler crashes during incremental builds.

backend/src/main/scala/sbt/internal/inc/bloop/internal · high confidence

The process forking mechanism has been rewritten to use \scala.sys.process\ instead of the previous nuprocess library, introducing a new \Forker\ and \JvmProcessForker\ architecture. This change adds support for remote debugging via JDWP, allowing users to attach debuggers to forked JVMs. It also fixes several Windows-specific issues, including proper handling of drive letters, URL-encoding of file paths in manifest JARs, and managing long command-line arguments by creating temporary manifest JARs when limits are exceeded. Standard input is now forwarded via a blocking read on an I/O scheduler to prevent data loss, and process cancellation is more robust with graceful termination attempts.

frontend/src/main/scala/bloop/exec · high confidence

The backend now supports compiling for JDK 8 by dynamically exporting the Java runtime classes into a temporary rt.jar file. New classes in the bloop.rtexport package handle this process: Export0 creates a JAR file containing the contents of the jrt:/modules filesystem (specifically for the current Java version), and Copy assists in transferring directory structures into this archive. This ensures that JDK 8 targets have access to the necessary runtime classes during compilation, addressing a specific bug where rt.jar was not being created for JDK 8 builds.

backend/src/main/java · high confidence

Added SerializableFingerprints to enable forked test execution by wrapping sbt's package-private fingerprint types (SubclassFingerprint and AnnotatedFingerprint) in serializable wrappers compatible with the remote test runner.

frontend/src/main/scala/sbt · high confidence

Distributed tracing via Zipkin is now disabled by default. Users must explicitly enable it using system properties (such as \bloop.tracing.enabled\) to start seeing trace data, reducing overhead for users who do not require distributed tracing.

backend/src/main/scala/bloop/tracing · high confidence

The build system now automatically detects when rt.jar is missing for JDK 8 targets and creates it on demand using the Bloop component manager. This ensures that compilation for JDK 8 proceeds correctly without requiring manual intervention to provide the runtime library.

backend/src/main/scala/bloop/rtexport · high confidence

Bloop now captures standard output generated by the compiler (e.g., via \println\) and forwards it to the user-visible build logs. This is implemented by introducing a \TeeOutputStream\ that splits output to both the original destination and a \FlushingOutputStream\, which feeds the captured text into the Bloop logger. This ensures that diagnostic messages printed by the compiler are no longer lost or hidden from the user.

shared/src/main/scala/bloop/logging · high confidence

Add integration test for exported assembly/shaded jars; Add sbt-bloop pipelining integration test; Add sbt-test for Wartremover integration with version-specific plugin configuration; Add scripted test for non-compiling project behavior; Add test suite for custom SBT configurations; Added DAP debug protocol test infrastructure; Added RecordingLogger test utility for verifying log output; Added Scala Native 0.5 test resources; Added Scala.js 1.x cross-build test resources; Added comprehensive BSP test suite; Added comprehensive test suite for Bloop frontend components; Added cross-test build fixtures for Scala.js 0.6; Added integration tests for custom sbt bridge configuration; Added scripted test for runtime dependency export; Added scripted tests for Scala.js platform extraction; Added scripted tests for cross-compile configurations and source/javadoc jar export; Added scripted tests for cross-project and Scala Native support; Added test coverage for BSP-enabled project configuration; Added test coverage for compiler caching, dependency resolution, and portable analysis; Added test coverage for source hashing, globbing, and server socket handling; Added test fixtures for resources-only downstream project scenario; Added test for BloopThreadLocalInputStream; Added test for incremental compilation issues; Added test for internal configuration dependency export; Added test for meta-build source jar resolution; Added test for optional dependency scope in bloop generation; Added test for provided dependencies in bloop runtime classpath; Added test for provided dependency handling; Added test for resource file accessibility; Added test for sbt-bloop plugin installation in plugin builds; Added test for stale project detection; Added test for unmanaged resources with relative paths; Added test for working directory handling in sbt-bloop; Added test resources for Bloop unit tests; Added test resources for Scala Native 0.4 cross-build verification; Added test resources for Scala seed project scaffolding; Added test resources for Scala/Java processor path; Added test resources for a custom SBT testing framework; Added test resources for compiler plugin allowlist validation; Added test resources for projects without test frameworks; Added test resources for simple sbt build validation; Added test suite for source file exclusion filters; Added test suite for the Scala seed project; Added test utilities for logging scenarios; Added tests for Scala.js 0.6 toolchain integration; Added tests for Scala.js 1.0 cross-build support; Added tests for classpath hashing cancellation and parallel directory copying; Added tests for opt-in meta-build export; Added unit tests for bloop.task.Task; New test infrastructure for Bloop frontend tests; New test infrastructure for the Bloop testing subsystem; Updated test project scaffolding to SBT 1.13.0 and Munit 1.3.6.

The build system now includes sbt-coursier, enabling the use of Coursier for dependency resolution and management within the sbt build definition.

(dependencies) · high confidence

The project build is restructured to use a new BuildPlugin that centralizes configuration, including release asset handling for GitHub releases (copying binaries and shell completions for Linux, Windows, macOS, and macOS M1) and defining task keys for updating Homebrew, Scoop, and Arch Linux packages. A new Dependencies.scala file establishes a single source of truth for all library versions, explicitly setting sbt to 1.9.0, Zinc to 1.12.1, BSP to 2.1.1, and Scala 2.13 to 2.13.18, while also adding support for Scala 3.8.4 and Scala Native 0.5.12. Utility objects for Git operations and GitHub releases are added to support the automated release process.

project · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 66 → 64 (-2.0)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 87 → 87 (+0.1)
• Architecture 98 → 79 (-19.7)
• Maturity 64 → 64 (+0.0)
• Readiness 68 → 58 (-9.2)
• Security 59 → 64 (+5.1)

• Documentation: no architecture or design documentation (docs/build-tools/sbt.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (website/README.md)
• Hotspot: frontend/src/main/scala/bloop/Cli.scala (frontend/src/main/scala/bloop/Cli.scala)
• Hotspot: frontend/src/main/scala/bloop/engine/Interpreter.scala (frontend/src/main/scala/bloop/engine/Interpreter.scala)
• Members sharing a duplicated core (6 members, 50+ identical tokens) (frontend/src/main/scala/bloop/bsp/BloopBspServices.scala)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #3

• Documentation: no architecture or design documentation (docs/cli/reference.md)
• Hotspot: backend/src/main/scala/bloop/io/ClasspathHasher.scala (backend/src/main/scala/bloop/io/ClasspathHasher.scala)
• Hotspot: frontend/src/main/scala/bloop/engine/caches/ResultsCache.scala (frontend/src/main/scala/bloop/engine/caches/ResultsCache.scala)
• Members sharing a duplicated core (6 members, 50+ identical tokens) (frontend/src/main/scala/bloop/bsp/BloopBspServices.scala)
• No ADRs found
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #3
• Outdated: org.eclipse.jgit:org.eclipse.jgit
• Outdated: org.eclipse.jgit:org.eclipse.jgit.ssh.jsch
• Projects may be oversized for their cohesion
• Roots.resolve (cognitive 28) (backend/src/main/scala/bloop/PortableAnalysis.scala)

• 46 commits — 32 feature/other, 14 fixes

• (repo) — 24 commits
• frontend/src — 5 commits
• integrations/sbt-bloop — 4 commits
• project/Dependencies.scala — 4 commits
• backend/src — 2 commits
• project/build.sbt — 2 commits
• .github/workflows — 1 commit
• benchmarks/src — 1 commit
• docs/cli — 1 commit
• docs/server.md — 1 commit
• docs/tools — 1 commit

• fix: Fix #1503: resources of source-less dependencies on compile classpath
• fix: Fix runtime-dependency scripted test under sbt 2
• fix: Fix vacuous sbt scripted tests for the runtime classpath export
• fix: Merge pull request #3067 from jozanek/fix/1503-resources-only-compile-classpath
• fix: Merge pull request #3069 from jozanek/fix/1578-bsp-socket-unlink
• fix: Merge pull request #3071 from jozanek/fix/1606-runtime-classpath-test-coverage
• fix: Merge pull request #3073 from jozanek/fix/1693-benchmark-harness
• fix: Merge pull request #3074 from jozanek/fix/1765-custom-config-test-tags
• fix: Merge pull request #3075 from jozanek/fix/runtime-dependency-scripted-sbt2
• fix: Merge pull request #3078 from jozanek/fix/1693-benchmark-smoke-ci
• fix: Merge pull request #3079 from jozanek/fix/1953-flaky-test-timeouts
• fix: Merge pull request #3080 from jozanek/fix/1724-classpath-hasher-cancellation
• fix: Merge pull request #3081 from jozanek/fix/2007-annotation-processor-sources
• fix: fix: Repair two bugs in the Bloop compile benchmark
• change: Gate portable analysis reads behind the option
• change: Merge branch 'main' into update/sbt-scalafix-0.14.9
• change: Merge pull request #3054 from jozanek/feature/1351-portable-analysis
• change: Merge pull request #3062 from jozanek/reverse-order-flag
• change: Merge pull request #3066 from scalacenter/dependabot/npm_and_yarn/website/js-yaml-4.3.2
• change: Merge pull request #3068 from jozanek/docs/watch-run-long-running-apps
• …and 26 more

• Unchanged — 0 containers · 1 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

scalacenter/bloop was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.