scalameta/scalafmt

Scalafmt is a high-performance code formatter for the Scala programming language that supports JVM, JavaScript, and Native platforms. It provides a command-line interface and a stable public API for editor and build tool integration, enabling automated formatting with configurable styles and rewrite rules. The system handles complex syntax across Scala 2 and 3, including optional braces and Scala.js specific patterns, while ensuring binary compatibility and fast execution through native image support and asynchronous I/O.

18 changes.

The project modernized its build infrastructure by migrating to sbt 2.0 and GitHub Actions, while significantly expanding platform support to include JavaScript via Scala.js and native images through GraalVM. Concurrently, the formatter was updated to support Scala 3 syntax features, and the documentation site was rebuilt with Docusaurus v3 to improve user experience and code comparison tools.

31 changes.

This period focused on expanding Scalafmt's runtime compatibility by introducing Scala Native support, GraalVM native-image builds, and a stable JVM interface for external integration. The CLI was refactored for asynchronous execution and new diff modes, while the codebase was restructured into modular components like scalafmt-sysops and scalafmt-config to ensure platform-agnostic design. Extensive test coverage was added to verify formatting correctness across Scala 2, Scala 3, and Scala.js, alongside robustness improvements in configuration parsing and dynamic version handling.

17 changes.

This period focused on extending Scalafmt's reach by adding JavaScript and Native platform support, including a new JS interface for editor plugins and platform-specific system operations. It also significantly broadened test coverage by introducing comprehensive suites for the CLI, system utilities, and a wide range of community projects across Scala 2 and 3 versions.

This change introduces the JavaScript-specific implementation of the Scalafmt public API, enabling editor plugins and build tools running on Node.js to interact with Scalafmt. It adds the core interface definitions (Scalafmt, ScalafmtSession, ScalafmtReporter, etc.) and a custom ScalafmtClassLoader to manage class loading for the dynamic module. This allows JS-based integrations to format code, handle configuration, and report errors using the same stable, binary-compatible interface as the JVM version.

scalafmt-interfaces/js · high confidence

This change introduces a new JavaScript (Scala.js) implementation for the scalafmt-sysops module, enabling Scalafmt to run in browser or Node.js environments. The diff adds platform-specific compatibility layers including \PlatformCompat\ for runtime detection, \PlatformFileOps\ for asynchronous file system operations (read/write/walk), \PlatformRunOps\ for executing external commands via \child\_process\, and \PlatformPathMatcher\ for regex/glob pattern matching. It also includes \CollectionConverters\ to handle parallel collection syntax and test utilities like \DeleteTree\.

scalafmt-cli/js, scalafmt-core/js, scalafmt-sysops/js · high confidence

The CLI module now includes platform-agnostic utility traits (CliOptionsUtils, CliUtils, TermUtils) that provide default, no-op implementations for console output, dynamic runner access, and terminal formatting. These changes enable the scalafmt CLI to compile against Scala Native by replacing JVM-specific dependencies with portable abstractions, ensuring the tool can run in native environments without relying on Java NIO or dynamic class loading.

scalafmt-cli/native · high confidence

The scalafmt-interfaces/native module now provides the core Scala interface definitions (PositionException, RepositoryCredential, Scalafmt, ScalafmtClassLoader, ScalafmtException, ScalafmtReporter, ScalafmtResult, ScalafmtSession, and ScalafmtSessionFactory) required to integrate Scalafmt with Scala Native targets. This change introduces the interface contracts that allow editor plugins and build tools to interact with the formatter on Native platforms, replacing the previous state where these specific interface files were absent from the native source tree.

scalafmt-interfaces/native · high confidence

Introduces a new \RegexCompat\ module in the Scala Native target to handle regex patterns that are incompatible with Scala Native's underlying RE2 engine. This implementation replaces unsupported features like lookaheads/lookbehinds and the \\\h\ horizontal whitespace shorthand with custom Java \Pattern\ equivalents, ensuring that formatting logic for comments, docstrings, and multiline strings works correctly on Native platforms.

scalafmt-core/native · high confidence

Added a new set of Scala source files under \scalafmt-benchmarks/src/resources/scala-js/\ to serve as input for Scala.js-specific formatting benchmarks. These files include core Scala.js compiler and linker components (such as \Analyzer\, \BaseLinker\, \GenJSCode\, and \OptimizerCore\), standard library emulations (like \CopyOnWriteArrayList\ and \JavaLangString\), and utility classes, providing a realistic codebase for measuring the formatter's performance on Scala.js projects.

scalafmt-benchmarks/src/resources · high confidence

The scalafmt-cli module now includes native-image configuration files to support building a native executable. A new \native-image.properties\ file defines build arguments such as disabling the server mode, enabling HTTP/HTTPS, initializing specific packages at build time, and configuring experimental VM options. Additionally, a \reflection.json\ file registers reflection access for \SAXParserFactoryImpl\ to ensure compatibility during the native image build process.

scalafmt-cli/shared/src/main/resources · high confidence

A new JMH-based macro benchmark has been added to measure the performance of Scalafmt's formatting capabilities. This benchmark loads a corpus of Scala source files (specifically filtering for scala-js projects) and runs formatting operations, including both standard formatting and rewrite-enabled formatting, to provide performance metrics for the tool.

scalafmt-benchmarks/src/main/scala-2.12 · high confidence

This change adds the \scalafmt-interfaces\ module, providing a stable, binary-compatible public API for editor plugins and build tools to integrate with Scalafmt. The new interface allows users to format code while automatically downloading the correct Scalafmt version defined in \.scalafmt.conf\, respecting project include/exclude filters, and handling custom Maven repositories and credentials. It introduces key components such as \Scalafmt\ for single-file formatting, \ScalafmtSession\ for batch operations with file discovery capabilities, and extension points for custom dependency downloaders and error reporting.

scalafmt-interfaces/jvm · high confidence

The benchmark module now includes dedicated JMH benchmarks to measure specific aspects of the formatting pipeline. BenchStyles defines configuration variants for different \newlines.source\ modes (classic, keep, fold, unfold) to compare formatting behavior. DynamicBenchmark measures the startup and per-format overhead of the dynamic interface (resolving external versions via coursier) against the in-process core. FormatBenchmark exercises the \Imports\ and \RedundantBraces\ rewrite rules. MicroBenchmark provides file-formatting benchmarks across various codebases (Scala.js, Spark, Scala 3) using the defined styles. WrapperBenchmark isolates and measures the non-formatting costs of the CLI, including file discovery (recursive vs. git), reading, writing, and the orchestration pipeline.

scalafmt-benchmarks/src/main/scala · high confidence

This change introduces several new scripts in the bin directory to enhance the user experience and build process. It adds a ZSH tab-completion file (\_scalafmt) that provides autocompletion for scalafmt CLI options, including the new --mode diff and --diff-branch flags. It also includes a script (build-native-image.sh) to build the native image via sbt, and an installation script (install-scalafmt-native.sh) for downloading and installing the native binary, which now supports macOS, Linux, and Linux with musl libc. Additionally, a Nailgun interoperability script (scalafmt\_ng) is added to allow faster invocation of scalafmt via Nailgun, and a test script (test-release.sh) is provided to verify release artifacts.

bin · high confidence

The configuration module now provides distinct platform implementations for parsing settings: the JVM build uses the Typesafe Config library, while the Scala.js build uses the standard sconfig library. This separation allows the scalafmt-config library to compile and function correctly on both the JVM and Scala.js platforms by selecting the appropriate parser at compile time.

scalafmt-config/jvm · high confidence

The ScalaFmt utility object, which previously provided a procedureSyntax transformation to normalize method definitions lacking an explicit return type, has been removed from the codebase. Users relying on this specific helper to process Scala meta trees for procedure syntax normalization will no longer have access to this functionality.

src/main · high confidence

A new \scalafmt-sysops\ module has been added to centralize shared system-level operations, including file system interactions (\FileOps\, \AbsoluteFile\), Git repository management (\GitOps\), path matching (\PathMatcher\), and OS-specific utilities (\OsSpecific\). This refactoring extracts these capabilities from the main codebase into a dedicated shared module, providing a cleaner separation of concerns and reusable components for file walking, Git status/diff operations, and path resolution across the Scalafmt tooling.

scalafmt-sysops/shared/src/main/scala · high confidence

The documentation now lists additional companies and projects that use Scalafmt, including Mendix, Foursquare, and Codacy, alongside existing adopters like http4s and sbt. This update reflects the growing community adoption of the tool.

readme/src · high confidence

The project has migrated its continuous integration infrastructure from Travis CI to GitHub Actions and Drone, removing the legacy .travis.yml and introducing .drone.yml for build orchestration. Concurrently, the codebase has been upgraded to Scalafmt version 3.11.5, which enforces the Scala 2.13 dialect and applies a comprehensive set of formatting rules including AvoidInfix, Imports, RedundantBraces, RedundantParens, and SortModifiers. The release process is now containerized via a new Dockerfile, and automated dependency updates are managed by Scala Steward.

(repo-wide) · high confidence

The CLI's terminal progress display poller now runs on a daemon thread, ensuring that the background timer does not keep the Java Virtual Machine alive after the main formatting task completes. This change prevents the process from hanging or failing to exit cleanly due to a lingering non-daemon thread, improving the user experience when running scalafmt in automated or script-based environments.

scalafmt-cli/jvm-native · high confidence

The CLI has been refactored to use asynchronous execution for file I/O and formatting, allowing for a dedicated thread pool via the new --async-format option. It introduces a new --mode diff-base flag to format only files changed since a branch forked from its upstream, alongside existing modes like diff and changed. The --quiet flag now preserves requested output (such as formatted code) while suppressing progress and diagnostics, and a new --diff-config option allows users to compare their original configuration against the effective one after resolving aliases and deprecated parameters.

scalafmt-cli/shared/src/main/scala · high confidence

The dynamic scalafmt module now caches resolved dependency classpaths to disk, allowing subsequent runs of the same scalafmt version to skip the expensive dependency resolution step performed by Coursier. This optimization is implemented via a new \ClasspathCache\ object and a dedicated \CoursierDependencyDownloader\ that checks the cache before fetching, with the downloader factory registered via the standard Java services mechanism.

scalafmt-dynamic/src/main · high confidence

The documentation site now applies a custom visual theme using colors from the scalafmt logo, specifically utilizing red (\#eb4d54) and dark red (\#af2442) for the navigation menu, selected states, and links. The layout includes specific styles for code examples, introducing 'pair' and 'rows' views to display before/after formatting comparisons, as well as a collapsible configuration block that users can toggle open and closed. Additionally, warning boxes are styled with a distinct yellow theme, and a Google site verification file has been added to support search engine indexing.

readme/resources · high confidence

The documentation site has been migrated to Docusaurus v3, introducing new mdoc modifiers to enhance the user experience. The \scalafmt\ modifier now renders code examples with a side-by-side 'Before' and 'After' view, allowing users to easily compare original and formatted code. A new \defaults\ modifier automatically generates a self-contained properties block showing configuration defaults, while the \file\ modifier enables embedding external files directly into the documentation. The build process now includes link hygiene checks to prevent broken links.

scalafmt-docs · high confidence

The formatter now supports Scala 3's optional braces syntax, including formatting for \then\/\do\ blocks, \match\ types, \opaque\ types, and \derives\ clauses. It also introduces new configuration options for controlling newlines, such as \trailingCommas\ (with \always\, \never\, and \preserve\ modes) and \spaces.inInterpolatedStringCurlyBraces\. Additionally, the \optionalBraces\ rewrite settings have been renamed to \optionalBraces\ and \optionalBraces\ now supports inserting end markers.

scalafmt-core/shared · high confidence

The scalafmt-core/jvm module now includes a JVM-specific implementation of the internal PriorityQueue that delegates to java.util.PriorityQueue instead of the standard Scala mutable collection. This change enables the formatter to run under GraalVM native-image, which currently cannot process scala.collection.mutable.PriorityQueue. The implementation ensures correct ordering by passing a reversed implicit Ordering to the Java queue constructor.

scalafmt-core/jvm · high confidence

This change adds the core platform-implementation files for the JVM and Native targets within the scalafmt-sysops module. It introduces asynchronous file reading and writing capabilities, a granular file-walking mechanism that allows users to stop, skip, or continue traversal during directory scans, and a path matcher that validates patterns and throws descriptive errors for invalid inputs. Additionally, it provides a dedicated thread pool for formatting operations and ensures that the input execution context is properly initialized, improving concurrency handling and error reporting for file and process operations.

scalafmt-sysops/jvm-native/src/main · high confidence

The JVM implementation of the system operations layer now uses Java NIO asynchronous file channels for reading and writing files, replacing previous synchronous or parallel-execution approaches to improve I/O performance. Additionally, new platform-specific implementations for Scala Native have been added, providing the necessary async file operations (wrapping synchronous calls via futures) and platform compatibility checks, enabling the tool to compile and run on Scala Native targets.

scalafmt-sysops/jvm · high confidence

This change adds new compatibility files in the scalafmt-sysops module to support both Scala 2.12 and 2.13. For Scala 2.12, it provides a wrapper for \scala.collection.JavaConverters\ and a custom parasitic execution context implementation, while for Scala 2.13, it uses the standard \scala.jdk.CollectionConverters\ and the built-in \ExecutionContext.parasitic\. These additions ensure consistent behavior across different Scala versions without requiring conditional logic in the core formatting code.

scalafmt-sysops/shared/src/main/scala-2.12 · high confidence

The JVM-specific CLI layer has been restructured by introducing dedicated utility traits: \CliOptionsUtils\ for console access, \CliUtils\ for Nailgun integration and input reading, \ScalafmtDynamicRunner\ for asynchronous formatting execution via \Future\, and \TermUtils\ for terminal display helpers. This change isolates JVM-specific concerns (such as \java.io.PrintWriter\, \scala.io.Source\, and Nailgun's \NGContext\) from the core CLI logic, enabling the rest of the codebase to remain platform-agnostic.

scalafmt-cli/jvm/src/main · high confidence

The configuration parsing logic has been moved into a new \ConfParsed\ class in the shared module. This class wraps the underlying configuration and provides specific accessors for settings such as Git status, warning behaviors, test failure handling, encoding, and version. The implementation includes error handling to catch non-fatal exceptions during parsing, ensuring that errors are wrapped rather than masked, which improves the robustness of configuration retrieval.

scalafmt-config/shared · high confidence

The build now includes Scala 3 sources, introducing Scala 3-specific implementations for dialect configuration macros (DialectMacro) and compatibility utilities (CompatCollections, GranularDialectAsyncOps) alongside the existing Scala 2 versions.

scalafmt-macros/shared, scalafmt-sysops/shared/src/main/scala-3 · high confidence

The scalafmt-dynamic-core module has been restructured to improve modularity and resource management. A new META-INF/services registration now explicitly wires the dynamic implementation to the Scalafmt interface, enabling standard Java ServiceLoader discovery. Classloader ownership has been reworked so that ScalafmtReflect only closes a classloader if it was the one that created it, preventing premature closure of shared resources. Additionally, the module now includes a ConsoleScalafmtReporter for standard error output, a Dependency resolver that correctly handles Scala 3 artifacts, and a ScalafmtVersion parser to manage version-specific reflection logic.

scalafmt-dynamic-core · high confidence

The documentation website has been rebuilt using Docusaurus v3, introducing a new landing page that highlights Scalafmt's key benefits and provides a 'Get started' link to installation instructions. The migration includes a restored before/after code comparison toggle for formatting examples, which now uses progressive enhancement to collapse side-by-side views into an interactive toggle by default. Additionally, the site enforces broken link detection during builds, sizes the footer logo to prevent layout flash, and adds local search functionality. The navigation structure has been updated to include dedicated sections for Documentation and Contributing, with links to installation, configuration, and community resources.

website · high confidence

Add JVM-specific property-based tests and platform compatibility utilities; Add community regression tests for Scala 3.2 and 3.3; Added CLI configuration and execution tests; Added MUnit-based benchmark tests for Scala 2.12; Added Scala 3 formatting test cases; Added Scala.js formatting test cases; Added community build test infrastructure; Added community regression tests for Scala 2.12 and 2.13; Added community test suites for Akka, Munit, Play Framework, Scala CLI, Scala.js, Scalaz, and Zio; Added community test suites for Apache Spark 3.4 and 3.5; Added community test suites for IntelliJ Scala 2024.2 and 2024.3; Added comprehensive dynamic version testing suite; Added comprehensive formatting test resources for default style; Added platform-specific test utilities for Scala.js and Native; Added test cases for alignment formatting rules; Added test cases for formatting configurations; Added test cases for various spacing rules; Added test cases for vertical multiline formatting rules; Added test coverage for trailing comma formatting policies; Added test infrastructure and formatting test cases; Added test resources for literal formatting and rewriting rules; Added test resources for rewrite rules; Added test suite for comment whitespace handling and formatting infrastructure; Added tests for CLI stdin/stdout info output behavior; Added tests for DeleteTree file deletion logic; Added tests for FileOps and GitOps utilities; Added tests for newlines formatting rules; Added unit tests for configuration parsing and Scala 3 rewrite settings; New test infrastructure for formatting assertions and reporting; Removed obsolete procedure syntax test; Test coverage for bin-packing formatting rules; Unit test suite for formatting rules and edge cases.

The project now includes Prettier 2.0.4 as a development dependency to format documentation files, ensuring consistent styling across the docs. Additionally, the website has been upgraded to Docusaurus 3.10.1 (along with React 19.2.7 and local search plugin 0.55.2), providing a modernized documentation site experience.

(dependencies) · high confidence

The build system has been upgraded from sbt 0.13.7 to sbt 2.0.9, enabling the use of modern sbt features like \projectMatrix\ for cross-building across Scala 2.12, 2.13, and 3.3 on JVM, JS, and Native platforms. Dependency versions have been centralized in \project/Dependencies.scala\, updating core libraries such as Scalameta to 4.17.4, Metaconfig to 0.18.8, and MUnit to 1.3.6. The build also introduces new sbt plugins including \sbt-matrix-sources\ (0.1.0) and \sbt-native-image\ (0.5.0), while removing older plugins like \sbt-ghpages\ and \sbt-docusaurus\. Binary compatibility checks are now configured via \Mima.scala\ with specific filters for internal configuration classes.

project · high confidence

The documentation now includes concrete code examples demonstrating how to format multi-line arrays (such as identity matrices) and how to use the \stripMargin\ method with both default and custom delimiter characters in Scala string interpolations.

readme · high confidence

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

• CAI 41 → 59 (+18.0)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 78 (-22.2)
• Architecture 69 → 95 (+26.2)
• Maturity 46 → 43 (-3.2)
• Readiness 30 → 68 (+37.9)
• Security 39 → 75 (+35.4)

• Dimension evaluation failed
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 19 more

• AlignBlock.tryAppendToBlock (cognitive 45) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/FormatWriter.scala)
• AlignBlock.tryAppendToBlock (cyclomatic 35) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/FormatWriter.scala)
• AvoidInfix.rewriteImpl (cognitive 32) (scalafmt-core/shared/src/main/scala/org/scalafmt/rewrite/AvoidInfix.scala)
• AvoidInfix.rewriteImpl (cyclomatic 24) (scalafmt-core/shared/src/main/scala/org/scalafmt/rewrite/AvoidInfix.scala)
• Base.getImporteesToKeep (cognitive 21) (scalafmt-core/shared/src/main/scala/org/scalafmt/rewrite/Imports.scala)
• BaseLinker.linkInternal (cognitive 20) (scalafmt-benchmarks/src/resources/scala-js/BaseLinker.scala)
• BaseLinker.linkedClassDef (cognitive 20) (scalafmt-benchmarks/src/resources/scala-js/BaseLinker.scala)
• BaseLinker.linkedClassDef (cyclomatic 20) (scalafmt-benchmarks/src/resources/scala-js/BaseLinker.scala)
• BestFirstSearch.getActiveSplits (cognitive 16) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/BestFirstSearch.scala)
• BestFirstSearch.processOptimalToken (cognitive 18) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/BestFirstSearch.scala)
• BestFirstSearch.shortestPath (cognitive 115) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/BestFirstSearch.scala)
• BestFirstSearch.shortestPath (cyclomatic 43) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/BestFirstSearch.scala)
• BinPackOneline.policyOnRightDelim (cognitive 26) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/FormatOps.scala)
• BinPackOneline.policyOnRightDelim (cyclomatic 20) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/FormatOps.scala)
• Builder.processForStatements (cognitive 28) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/OptimizationEntities.scala)
• Builder.processForStatements (cyclomatic 35) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/OptimizationEntities.scala)
• CatchImpl.create (cognitive 18) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/OptionalBraces.scala)
• Change coupling: Router.scala ↔ TokenClasses.scala (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/Router.scala)
• ClassInfo.instantiated (cognitive 19) (scalafmt-benchmarks/src/resources/scala-js/Analyzer.scala)
• ClassTooLong: GenJSCode (scalafmt-benchmarks/src/resources/scala-js/GenJSCode.scala)
• …and 334 more

• 84 commits — 83 feature/other, 1 fixes

• scalafmt-tests/shared — 28 commits
• (root) — 14 commits
• scalafmt-core/shared — 9 commits
• project/Extensions.scala — 6 commits
• project/Dependencies.scala — 5 commits
• project/plugins.sbt — 5 commits
• docs/contributing-scalafmt.md — 4 commits
• docs/configuration.md — 3 commits
• project/build.properties — 3 commits
• .github/release-drafter.yml — 1 commit
• .github/release.yml — 1 commit
• .github/workflows — 1 commit
• scalafmt-cli/shared — 1 commit
• scalafmt-dynamic-core/src — 1 commit
• scalafmt-dynamic/src — 1 commit
• scalafmt-sysops/jvm-native — 1 commit

• fix: SBT: fix deprecation warnings
• change: Add -Yfuture-lazy-vals option
• change: Add AGENTS.md, with CLAUDE.md and GEMINI.md
• change: Align: add atLineStart
• change: Align: add multiline values none and skip
• change: Align: implement align.atLineStart
• change: Align: implement multiline values none and skip
• change: Align: turn multiline into an enum
• change: Build: stream the community tests' output
• change: Bump actions/setup-java from 5 to 6
• change: Config: extract a list type for tree patterns
• change: CtrlBodySplits: honor newlines.beforeBody
• change: CtrlBodySplits: honor newlines.ignoreInSyntax
• change: Extensions: decide the IDE filter where the row is made
• change: Extensions: emit Java 17 bytecode for Scala 3
• change: Extensions: let a build name its default platforms
• change: Extensions: let the IDE import one Scala version
• change: Extensions: narrow the import with bspEnabled
• change: Extensions: read the crossproject layout from sbt-matrix-sources
• change: FormatOps: align a lambda's parameters under the first
• …and 64 more

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

scalameta/scalafmt 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.