oyvindberg/bleep

Bleep is a modern, high-performance build system for Scala, Kotlin, and Java projects that replaces legacy tools like SBT and Bloop with a native BSP server. It provides a comprehensive CLI for managing build configurations, importing existing Maven and SBT projects, and executing custom automation scripts in Java. The system features robust resource governance for concurrent compilation, deep IDE integration via an IntelliJ plugin, and specialized support for AI agent interaction through a Model Context Protocol (MCP) server.

25 changes.

This period focused on rebuilding the project's core architecture by removing legacy bloop generation infrastructure and introducing a structured BSP protocol with strongly-typed models. It also established a robust CLI with compile server management and build refactoring commands, while simultaneously launching a comprehensive Docusaurus-based documentation site with a new visual identity.

29 changes.

This period focused on expanding the native BSP server with support for Kotlin and Scala JS/Native targets, alongside significant improvements to the test runner's protocol and resource management. The project also introduced extensive IDE integrations, including an IntelliJ plugin, an MCP server for AI agents, and a TUI dashboard for managing compile servers. Additionally, build script capabilities were broadened with a new Java-based API, Maven import support, and a Spring Boot plugin.

The scripts-java module now includes example Java implementations for bleep scripts, specifically Hello, ListProjects, and ShowDeps. These examples demonstrate how to extend BleepScript to create custom commands, access build metadata, iterate over projects, and handle dependencies using Java-specific features like pattern matching.

scripts-java · high confidence

The bleep-test-ksp-processor module now includes a test KSP processor (ToyProcessor) that supports code generation via @GenerateKotlin and @GenerateJava annotations, enabling verification of mixed Kotlin/Java compilation paths and processor error handling in bleep's integration tests.

bleep-test-ksp-processor · high confidence

The shared module now includes a Scala source file defining a \Main\ object with a \greet\ method and a \@main\ entry point that prints a greeting. This provides the core application logic for the shared codebase in the snapshot test setup.

snapshot-tests/create-new-build/build/myapp/shared · high confidence

The documentation build now automatically extracts code snippets from the Java, Kotlin, and Scala example projects, supporting both full-file inclusion and marker-based snippet selection (//start//stop) to keep docs in sync with source code. Additionally, the site now dynamically resolves the current Bleep version from git tags at build time, replacing the BLEEP\_LATEST\_VERSION placeholder in markdown and code blocks so that documentation always reflects the latest release without requiring manual updates or causing commit drift.

bleep-site/scripts · high confidence

The repository is initialized with the core configuration files required for the bleep build tool, including the primary \bleep.yaml\ build definition, the \schema.json\ for validation, and the \coursier-channel.json\ for launcher resolution. The setup includes \.gitattributes\ to enforce LF line endings for cross-platform consistency, \.gitmodules\ for the 'liberated' sbt submodules, and formatting configurations for Scala (\scalafmt.conf\) and Java (\javafmt.conf\). Additionally, developer documentation (\CLAUDE.md\), design specifications (\ksp-design.md\), and a \LICENSE\ file are added to the project root.

(repo-wide) · high confidence

The \bleep server\ command now includes a terminal-based user interface (TUI) that allows you to list, inspect, and control compile servers. This dashboard provides a real-time view of server status, resource usage (CPU slots, heap memory), and build activity, while supporting keyboard and mouse interactions to select servers, view logs, and perform actions like restarting or killing servers. A new \ServerTarget\ logic ensures consistent server selection across subcommands by prioritizing explicit IDs, workspace association, or unique running instances.

bleep-cli/src/scala/bleep/commands/server · high confidence

Adds a new IntelliJ plugin that integrates the Bleep build tool into the IDE. The plugin automatically detects projects containing a bleep.yaml file, downloads the correct Bleep binary for the host OS and architecture, and provides a dedicated tool window for selecting projects to mount via BSP. It supports JSON schema validation for bleep.yaml, offers a 'Setup IDE' action to generate the BSP configuration, and includes a listener that automatically triggers a BSP sync when the build file is modified.

intellij-plugin · high confidence

Adds a new Model Context Protocol (MCP) server implementation in the Scala 3 CLI module, exposing tools such as compile, test, history, and build resolution to AI agents. The server is designed to be stateless, bootstrapping a fresh workspace connection for each tool call to ensure it always operates against the current configuration without holding stale state, and filters build events to provide only actionable information while stripping ANSI codes for clean output.

bleep-cli/src/scala-3 · high confidence

Users can now write bleep build scripts directly in Java using the new \bleepscript\ module. This adds two base classes, \BleepScript\ for general automation and \BleepCodegenScript\ for code generation, along with a comprehensive API for interacting with the build. The \Commands\ interface allows scripts to compile, link, test, run, and publish projects programmatically, while \Packaging\ and \Coursier\ provide utilities for dependency resolution, JAR creation, and publishing to local or remote repositories. The framework handles script bootstrapping and service loading automatically, enabling seamless integration with the existing bleep build lifecycle.

bleepscript · high confidence

Bleep now resolves \build.bleep::\*\ artifacts with \dev:\ versions from local compiled class directories instead of requiring published artifacts. This allows forked sourcegen JVMs to correctly load bleep's own internal dependencies (such as plugins and test runners) during development, ensuring that resources like SPI files are available on the classpath and that transitive bleep dependencies are resolved without needing a published repository.

bleep-core · high confidence

The \bleep-model\ module now includes a set of internal helper classes and serialization definitions to support the build model. This adds \EnumCodec\ for safe string-to-enum mapping, a \codecs\ object providing Circe encoders/decoders for standard types (File, URI, Path) and Coursier artifacts (Organization, ModuleName, Type, etc.), and \compat\ utilities for Scala 2.12/2.13 interoperability. Additionally, \internal.scala\ provides generic iterable operations (\optReduce\, \firstDefined\), and \rewriteDependentData.scala\ introduces a lazy evaluation framework for processing data with dependencies, ensuring consistent ordering and deferred computation.

bleep-model/src/scala/bleep/internal · high confidence

The bleep-nosbt module now includes a new compatibility layer that brings in essential sbt-like primitives required for dependency checking and sbt imports. This change adds core IO utilities (file operations, directory creation, hashing, and property loading), a resource management abstraction (Using), and foundational utility classes including a logging framework (Logger, Level), credential handling for Ivy repositories, and terminal interaction services. These components provide the necessary low-level building blocks for the nosbt integration without depending on the full sbt runtime.

bleep-nosbt · high confidence

Added a new benchmark suite for the native bleep-bsp server, replacing the previous Bloop-based benchmarks. This includes a bash script (benchmark-bsp.sh) that runs concurrent workspace compilations to measure performance, and a Python visualization tool (visualize.py) that generates an interactive HTML dashboard from the collected metrics and workspace data.

benchmark · high confidence

The build system now includes dedicated runners and linker bridges for Kotlin/JS, Kotlin/Native, Scala.js, and Scala Native. Users can compile and execute JavaScript outputs via Node.js and run native binaries directly, with proper process management and cancellation support. The implementation uses reflection to load specific linker versions in isolated classloaders, ensuring compatibility across different toolchain versions.

bleep-bsp · high confidence

The tool now supports importing existing Maven projects. This change introduces the core logic to execute Maven commands to extract effective POMs, parse the resulting XML structure (including dependencies, plugins, and source directories), and generate a corresponding bleep build configuration with project filtering and source generation script support.

bleep-cli/src/scala/bleep/mavenimport · high confidence

The \bleep server\ command is now available to inspect and control compile server (BSP daemon) processes running on the machine. Users can use subcommands like \top\ for a live dashboard, \ls\ to list servers, \status\ for details, \kill\ or \stop-all\ to terminate them, \restart\ to refresh configurations, and \log\ to view logs. Additionally, \bleep server config\ allows users to view and modify compile server settings (such as parallelism and memory limits) directly via the CLI, replacing the need to manually edit configuration files.

bleep-cli/src/scala/bleep · high confidence

A new developer script, \linkify-cli-mentions\, has been added to the \scripts-dev\ module. This tool automatically converts inline \bleep \<command\>\ mentions in Markdown and MDX documentation files into clickable links pointing to the corresponding CLI reference pages. It operates idempotently, skipping mentions already linked, those inside headings or fenced code blocks, and requires the CLI documentation to be generated first via \bleep gen-cli-docs\.

scripts-dev · high confidence

A new shell script harness (\asciinema-rec\_script\) has been added to the resources directory to facilitate the creation of screencast demos. This tool records asciinema v2 casts by executing an augmented version of a provided script, which simulates typing, displays syntax-highlighted code comments, and renders countdown timers for pauses. It ensures consistent formatting for demo videos by handling ANSI escapes and integrating with tools like \bat\ for syntax highlighting.

scripts/src/resources · high confidence

The build system now includes four new executable scripts: \GenDocumentation\ automates building the site by compiling documentation snippet projects and running npm to build or deploy the Docusaurus site; \GenNativeImage\ handles GraalVM native-image compilation with optimized quick-build modes for non-release builds and supports emitting standalone launcher scripts; \It\ runs integration tests against the built native-image binary by executing demo scripts in temporary directories; and \Scalafix\ applies semanticdb-based code rewrites to the jvm3 project.

scripts/src/scala · high confidence

This release introduces a new bleepscript API, allowing build scripts to be written in Java with a fluent builder for external commands (Cli) and structured records for build configuration, dependencies, and publishing targets (including Sonatype Central). Concurrently, the test runner's communication protocol has been moved from shared stdout/stderr to a dedicated loopback socket to prevent test output from corrupting the protocol stream, and the JUnit 5 integration now uses the LauncherSession SPI to properly support frameworks like Quarkus and Spring Boot that require custom classloaders during session initialization.

_moduleName\2.13 · high confidence

Users can now restructure their projects directly via the CLI with new commands: \bleep build project-rename\ to rename a project and update its directory and dependencies, \bleep build projects-move\ to move one or more projects to a new parent directory, \bleep build project-merge-into\ to merge a project into another (combining sources and dependencies), \bleep build normalize\ to clean up the build configuration, \bleep build templates-reapply\ to regenerate templates, and \bleep build move-files-into-bleep-layout\ to reorganize files into the standard layout. Additionally, shell tab completions are now available for zsh (and bash via rc-file patching), and the tool now correctly handles its own installation path when running under Coursier.

bleep-cli/src/scala/bleep/commands · high confidence

The documentation now includes new example projects demonstrating how to write and run custom build scripts in Java, Kotlin, and Scala using the bleepscript API. It also provides reference configurations for publishing artifacts to plain Maven and Ivy repositories, applying ProGuard shrinking to Java, Kotlin, and Scala libraries, generating source code via the sourcegen API, and configuring cross-compilation for Scala and Kotlin targets.

docs-snippets-from-tests · high confidence

The demo-claude-agents area now includes a complete, runnable demonstration that uses a real interactive Claude Code session to compare build times. The demo sets up two git worktrees—one seeded with bleep's \copy-state\ tool and one starting cold—then uses bleep's MCP tools to measure and compare the compilation timing, displaying the resulting performance ratio. The entry adds the necessary scripts (\fixture.sh\, \demo.sh\, \drive.exp\, \run.sh\) and documentation (\README.md\) to generate this interactive cast, which is trimmed to show only the relevant demo output.

demo-claude-agents · high confidence

The site now includes a one-line install script at https://bleep.build/install, allowing users to install bleep on Linux and macOS by piping the script to sh. The script automatically detects the OS and architecture, downloads the appropriate binary from GitHub releases, and installs it to \~/.local/bin. Additionally, a CNAME file is added to configure the bleep.build domain, and a .nojekyll file is included to ensure static site generators do not process the site content.

bleep-site/static · high confidence

Added the bleep-plugin-spring-boot plugin, which provides scripts to run Spring Boot applications (SpringBootRun), create executable fat JARs with optional layered Docker support (SpringBootRepackage), and generate build-info.properties for the Actuator info endpoint (SpringBootBuildInfo). Included a spring-boot-myapp example demonstrating these capabilities with dev and prod run scripts, layered packaging, and a DuckDB-backed application.

bleep-plugin-spring-boot, docs-snippets-from-tests/spring-boot-myapp/myapp, docs-snippets-from-tests/spring-boot-myapp/scripts · high confidence

The \src/main\ directory has been completely cleared of the previous bloop file generation implementation. This includes the deletion of the \Main\ entry point, the \CoursierResolver\ for dependency fetching, the \Dep\ and \model\ data structures for parsing project definitions, and the \generateBloopFiles\ logic that translated project configurations into Bloop JSON files. Additionally, supporting utilities such as \Defaults\, \JsonList\, \RelPath\, \Versions\, and internal helpers like \Lazy\ and \EnumDecoder\ have been removed, indicating a significant architectural shift away from this specific codebase location for build file generation.

src/main · high confidence

The \bleep bsp\ proxy now acts as a full client that loads and resolves the build (including applying SemanticDB rewrites for IDEs) before connecting to the daemon. This centralizes build resolution and file watching in the proxy process, ensuring the server receives a pre-resolved build and receives notifications when build files change, rather than the server loading the build itself.

bleep-cli/src/scala/bleep/bsp · high confidence

The documentation site has been migrated to Docusaurus 2, introducing a restructured layout with separate 'Learn' and 'Reference' navigation sections. This update includes a new landing page featuring key product value propositions, a custom component for displaying multi-language code snippets with a 'Show entire file' toggle, and support for embedded terminal recordings via Asciinema. Additionally, the site now automatically resolves and displays the current version from git tags during the build process.

bleep-site · high confidence

The snapshot tests for scalameta and tapir now include generated \BleepCodegenScript\ scripts (e.g., \GenerateForBench\, \GenerateForCommon\, \GenerateForParsers\) that replace the previous sbt-based code generation. These scripts, located in \snapshot-tests/scalameta/imported/scripts\ and \snapshot-tests/tapir/imported/scripts\, are responsible for producing specific build artifacts such as \BuildInfo.scala\ objects and mdoc configuration properties, ensuring the snapshot environments remain consistent with the new build system.

snapshot-tests/scalameta/imported/scripts, snapshot-tests/tapir/imported/scripts · high confidence

The model layer now enforces that Scala.js and Scala Native projects explicitly declare their platform and language versions at build load, preventing confusing mid-build crashes. It introduces a comprehensive replacement system for build templates (such as ${BLEEP\_VERSION}, ${HOME\_DIR}, and ${COURSIER\_CACHE\_DIR}) and centralizes all hardcoded toolchain versions (Scala, Kotlin, JUnit, etc.) in a single configuration object. Additionally, project completion and selection now support grouping by language (Java-only, Kotlin) and prefix, and provides tab-completion for test tags.

bleep-model/src/scala/bleep/model · high confidence

The \GenerateResources\ script is now implemented as a \BleepCodegenScript\ that runs inline during the build process. It generates \BleepVersion.scala\, \BleepscriptVersion.java\, and \Jvm.scala\ source files based on the current build version and configured JVM. The implementation includes a \writeIfChanged\ mechanism to avoid unnecessary file updates and timestamp changes, ensuring a more stable and bug-free development experience with improved logging.

scripts-init · high confidence

The static demos directory now includes new asciinema cast recordings (\agents.cast\, \claude-agents.cast\, \copy-state.cast\, \diff.cast\) that visually demonstrate the parallel agent workflow, the \copy-state\ command, and the build history diff story. These updated assets replace previous versions to show the features on camera with the current binary, ensuring the site's documentation reflects the latest interactive sessions and tool outputs.

bleep-site/static/demos · high confidence

The site now features a complete visual overhaul with a 'manifesto' aesthetic, introducing Fraunces for headings, IBM Plex Sans for body text, and JetBrains Mono for code, along with distinct light (paper) and dark (ink) themes. This update also resolves a bug where the mobile navigation drawer was rendered behind the fold by restructuring the navbar's background styling to use a ::before pseudo-element with backdrop-filter, ensuring the fixed-position sidebar remains visible.

bleep-site/src/css · high confidence

The build system now uses a new templating engine located in \bleep-model/src/scala/bleep/templates\ to automatically infer and apply project templates. This engine groups cross-platform projects, infers necessary templates based on Scala versions and platforms, and applies them to the build configuration. It also includes logic to inline trivial templates and garbage collect unused ones, ensuring the final build file is clean and optimized.

bleep-model/src/scala/bleep/templates · high confidence

The site now features a completely rewritten landing page (index.js) and a new /why page (why.js) that serve as the primary entry points for users. The landing page presents a manifesto-style introduction to Bleep, highlighting its simplicity for agentic development, while the /why page provides a detailed, evidence-based argument for the tool's performance, citing specific metrics like 10 ms CLI startup and fast worktree forking. Both pages utilize a shared design system with scroll-triggered reveal animations, cursor-tracked hero effects, and embedded asciinema player demos to illustrate agent interactions and build processes.

bleep-site/src/pages · high confidence

The build tool now uses the external ryddig library for structured logging, replacing the previous internal implementation with a new BleepTemplateLogger that delegates to ryddig's Logger. Additionally, new internal utilities have been added to parse Bloop configuration files and convert between Bloop's internal configuration models (such as compile order, module kinds, and native linker settings) and the build tool's own model types.

bleep-cli/src/scala/bleep/internal · high confidence

The bleep-model module now uses a centralized BleepException hierarchy for consistent error reporting, including specific handling for subprocess exit codes so that a script's own exit code is propagated to the user rather than being masked as a build failure. Path resolution logic has been corrected to properly handle parent directory references (..) in relative paths, and source generation inputs are now consistently tracked across all project mechanisms to ensure accurate file watching and staleness checks.

bleep-model/src/scala/bleep · high confidence

The snapshot test infrastructure for the SBT importer has been updated to generate a dedicated \BleepCodegenScript\ for each project containing generated files. This change introduces new Scala scripts (e.g., \GenerateForImporterPortable\, \GenerateForSbtConverter\) that act as placeholders for file generation logic, ensuring that the import process correctly handles project-specific generated artifacts like \BuildInfo.scala\ and sbt autoplugins.

snapshot-tests/converter/imported/scripts · medium confidence

The sbt import process has been updated to produce a dedicated \BleepCodegenScript\ for each project that contains generated files. This change introduces new script files (such as \GenerateForCollections\ and \GenerateForSbtDependencyTree\) within the \snapshot-tests/sbt/imported/scripts\ location, which serve as placeholders for generating specific artifacts like Scala keywords or sbt autoplugins, ensuring that generated content is managed on a per-project basis rather than globally.

snapshot-tests/sbt/imported/scripts · high confidence

The sbt import process now generates dedicated \BleepCodegenScript\ scripts for projects containing generated files, replacing the previous generic approach. Additionally, the import command supports comprehensive filtering, allowing users to exclude specific projects (including their downstream dependencies) and filter by Scala version or platform during the import phase. The import logic also now correctly identifies original target directories from Bloop configurations to handle scalacOptions references accurately.

bleep-cli/src/scala/bleep/sbtimport · high confidence

The snapshot tests for bloop, doobie, and http4s have been updated to use generated \BleepCodegenScript\ scripts (e.g., \GenerateForBenchmarks\, \GenerateForBloopBackend\) instead of previous input data. These scripts, located in the \scripts\ package, are responsible for generating specific source files like \BuildInfo.scala\ or \es.properties\ for their respective projects, ensuring the snapshot test inputs reflect the current state of code generation.

snapshot-tests/bloop/imported/scripts, snapshot-tests/doobie/imported/scripts, snapshot-tests/http4s/imported/scripts · high confidence

The \bleep-bsp-protocol\ module introduces a set of strongly-typed Scala ADTs (e.g., \SuiteOutcome\, \CompileStatus\, \CompilePhase\, \TestStatus\) to replace previous string-based event representations in the BSP protocol. This change ensures that build and test events—such as compilation phases, test suite outcomes, and diagnostic severities—are handled with type safety and explicit semantics (e.g., distinguishing between \Empty\, \NoFrameworkMatched\, and \Errored\ test suites) across the BSP boundary, improving reliability for IDE clients and the \FancyBuildDisplay\ UI.

repository · high confidence

The build system now applies a structured pipeline of rewrites to normalize project definitions after imports or user edits. This includes unifying Scala dependency flags (like \forceJvm\) across projects with the same version, removing redundant default compile setups and platform configurations, deduplicating dependencies that are already provided by parent projects, and optionally enabling SemanticDB support for Scala 2 and 3. These changes ensure a cleaner, more consistent internal build model before generation.

bleep-model/src/scala/bleep/rewrites · high confidence

Added integration and unit tests for annotation processing, BOM support, and BSP proxying; Added integration tests for BSP analysis cache, compilation, and diagnostics; Added snapshot test for main greeting logic; Added tests for JVM exit attribution and concurrency limits; Added tests for the fork cost model and machine resource governor; Added unit and integration tests for the Spring Boot myapp example; Expanded test coverage for BSP server internals and admin endpoints; Introduce structured JSON test protocol for forked JVMs; Removed test infrastructure and snapshot test for project parsing.

This change adds the build configuration for a new IntelliJ IDEA plugin (bleep-intellij-plugin) and the dependency manifest for the Bleep documentation site (bleep-site). The IntelliJ plugin is built with Kotlin 2.1.0 and Gradle 8.13, targeting IntelliJ Platform 2025.3 and Java 21, and includes dependencies for YAML and JSON parsing. The documentation site is configured with Docusaurus 3.10.1 and React 18.2.0, requiring Node.js 18 or higher. Additionally, the legacy SBT build file (build.sbt) for the main project has been removed.

(dependencies) · high confidence

The \liberated\ directory has been updated to point to new commits for its embedded submodules, including librarymanagement, mdoc, mill-scalafix, sbt-ci-release, sbt-dynver, sbt-git-versioning, sbt-jni, sbt-native-image, sbt-pgp, sbt-sonatype, and sbt-tpolecat.

liberated · high confidence

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

• First survey — no prior run to compare against. CAI 50.

• Code Health 43
• Architecture 99
• Maturity 56
• Readiness 50
• Security 55

• 300 commits — 283 feature/other, 17 fixes

• bleep-site/src — 48 commits
• bleep-bsp/src — 46 commits
• bleep-core/src — 44 commits
• bleep-bsp-tests/src — 30 commits
• bleep-cli/src — 16 commits
• bleep-tests/src — 16 commits
• (root) — 12 commits
• (repo) — 11 commits
• .github/workflows — 10 commits
• docs/reference — 10 commits
• bleep-site/static — 8 commits
• docs-snippets-from-tests/test-framework-output — 6 commits
• docs/guides — 5 commits
• snapshot-tests/tapir — 5 commits
• bleep-model/src — 4 commits
• scripts/src — 4 commits
• bleep-site/sidebars.js — 3 commits
• docs/compared-to-other-build-tools — 3 commits
• .github/scripts — 2 commits
• docs/appendix — 2 commits

• fix: Fix Windows startup crash (#601), and unhide the 42 Windows test failures CI was swallowing (#607)
• fix: Fix factual claims on the build-tool comparison pages
• fix: Fix remote cache on Windows; regenerate noop manifest after pull (#587)
• fix: Fix the hanging text.
• fix: Post-#582 CI fixes: JvmRunIT memory + scripts-java release level (#583)
• fix: Revert "Post-#582 CI fixes: JvmRunIT memory + scripts-java release level (#583)"
• fix: Revert "stabilize integration tests (#582)"
• fix: Revert the native-image scripts transformation, keeping the plugin fixes
• fix: bleep-bsp: fix cross-connection state bugs in ProjectLock and KSP mutexes
• fix: bleep-bsp: fix zinc under-invalidation causing silent green builds over broken sources
• fix: bsp: fix compile-server self-deadlock, cut ECJ and footprint overhead, keep CI telemetry (#623)
• fix: ci: fix a racy resource test, bound the native-image test step, skip linker suites there (#639)
• fix: exit strategy: show the proof, and fix the bug that broke it
• fix: fix(navbar): mobile drawer rendered behind the fold
• fix: fix: deleteDirectory clears read-only entries instead of refusing (windows)
• fix: fix: make thread dumps actually contain the process you want (#649)
• fix: site: front page agents section sells capability, not fixed bugs
• change: Add Maven plugin coverage doc as proof of bleep model sufficiency
• change: Add bleep-plugin-spring-boot + spring-boot-myapp example (#590)
• change: AlienValue: name the classloader boundary, and test it
• …and 280 more

• 0 containers · 2 bounded contexts · 0 dependency edges (baseline)

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

oyvindberg/bleep 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.