Skip to content
CAI
Software that uses CAICheck a score

scalameta/scalafmt

61.8

Adequate · 14 November 2026

42.2k

lines of production code

Scala

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Scalafmt is a fast, configurable 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 granular control over style rules and dialects. The system features extensive rewrite capabilities, performance benchmarking, and comprehensive testing against major Scala ecosystems to ensure correctness and stability.

How it got here

2015–2018 — scalafmt 3.0 modernization and refactoring

21 changes.

This period focused on a comprehensive refactoring of the Scalafmt core engine to support Scala 3, featuring a new token-based rewrite system, modular configuration objects, and file-specific dialect handling. The project simultaneously modernized its build infrastructure by migrating to sbt 2.0 and GitHub Actions, while adding initial Scala.js platform support and GraalVM native-image compatibility. Documentation and developer experience were significantly enhanced through a migration to Docusaurus v3, the introduction of CLI diff modes, and the addition of ZSH tab-completion and benchmarking tools.

2019–2024 — multi-platform support and test expansion

34 changes.

This period focused on extending Scalafmt's compatibility to Scala Native and GraalVM native images by introducing platform-specific abstraction layers for system operations, configuration, and interfaces. Concurrently, the project significantly expanded its test coverage with comprehensive suites for formatting rules, dialects, and configuration parsing to ensure stability across the new platforms.

2025–2026 — JavaScript platform support and community testing

18 changes.

This period focused on extending Scalafmt to the JavaScript platform via Scala.js, introducing platform-specific implementations for system operations and CLI interfaces. Concurrently, the project significantly expanded its test coverage by establishing a comprehensive community testing infrastructure to validate formatting against major Scala libraries, frameworks, and official language versions.

Features

Add JavaScript platform implementation for Scalafmt interfaces

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

Add JavaScript platform support to scalafmt-sysops

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-sysops/js · high confidence

Add Scala Native compatibility stubs for CLI utilities

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

Add Scala Native interface definitions for Scalafmt

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

Add Scala Native support for regex pattern matching

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

Add Scala.js benchmark resources

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

Add Scala.js platform support to scalafmt-core

This change introduces the initial scaffolding for Scala.js support in the core formatting library. It adds a new \Platform.config\ file and a \RegexCompat\ implementation that utilizes \java.util.regex.Pattern\ to handle regular expressions in the JavaScript environment. This enables the core formatting logic to run in Scala.js, laying the groundwork for browser-based or Node.js usage of scalafmt.

scalafmt-core/js · high confidence

Add adopters list and CLI diff-base mode

The repository now includes a documented list of adopters (scalafmt, sbt, scala-native, HERE, Letgo, Seventh Sense, Teralytics, Venatus Media, http4s, Mendix, Foursquare, Codacy, and ZyseMe) in the readme module. Additionally, the CLI gains a new \diff-base\ file-fetch mode, allowing users to format only files changed since a branch forked from a specified base (defaulting to the upstream), alongside existing modes like \diff\, \changed\, and \git-tracked\.

repository · high confidence

Added GraalVM native-image configuration for scalafmt-cli

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

Added macro benchmark for Scalafmt formatting performance

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

Introduce new @warning formatting and configuration display helpers

The readme generation tooling now supports a new \@warning\ formatting style for documentation, implemented via a dedicated \warning\ helper method in \Readme.scala\. Additionally, the tooling now renders the specific configuration values used for formatting examples directly within the documentation, allowing users to see the exact settings applied to the code snippets shown.

readme/src · high confidence

Introduce scalafmt-sysops module for shared system operations

A new \scalafmt-sysops\ module has been added to centralize cross-platform system operations previously scattered across the codebase. This module introduces \AbsoluteFile\ as a wrapper for absolute paths, \GitOps\ for standardized Git interactions (status, diff, ls-tree), \BatchPathFinder\ for efficient file discovery with subtree pruning, and \PathMatcher\ for regex-based path filtering. It also includes \OsSpecific\ utilities for handling OS-specific path separators and \FileStat\ for file attribute checks, providing a unified foundation for file and Git operations used by the CLI and formatting engine.

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

Introduce stable JVM interface for Scalafmt integration

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

New benchmark suite for formatting styles, dynamic overhead, and CLI wrapper costs

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

New shell integration and native image tooling scripts

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

Platform-specific configuration parsers for Scala.js and JVM

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

Removals

Removal of ScalaFmt procedure syntax transformer

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

Behavioural changes

Add Scala 2.12-specific compatibility shims for Map and Iterator

To support Scala 2.12, this change introduces two new package objects in the \scalafmt-core/shared/src/main/scala-2.12\ directory. The first provides an \ImplicitIterator\ extension with a \nextOption\ method to safely retrieve the next element or return None. The second provides an \ImplicitMap\ extension that implements \updateWith\, replicating the behavior of Scala 2.13's \Map.updateWith\ to allow atomic update or removal of map entries based on a remapping function.

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

CI migration to GitHub Actions and Drone, plus Scalafmt 3.11.5 upgrade

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

CLI progress display no longer prevents JVM shutdown

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

CLI rewritten with async execution, new diff modes, and explicit progress control

The CLI entry point and argument parser have been refactored to support asynchronous formatting via dedicated thread pools (--async-format), new file-fetching modes including --mode diff-base to format only files changed since a fork, and a --diff-config option to compare original and effective configurations. Progress reporting is now more explicit, with --no-progress-bar and --non-interactive modes, while --quiet suppresses progress and diagnostics without hiding requested output. Error handling has been improved to report failures per file, avoid stopping on the first error, and ensure proper exit codes even when tolerated errors occur.

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

Cached resolved classpaths to speed up dynamic scalafmt loading

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

Configuration schema restructured into dedicated config objects

The configuration system has been refactored to replace the monolithic \ScalafmtConfig\ with a set of dedicated, modular case classes for each formatting aspect. This change introduces new configuration objects including \Align\, \BinPack\, \DanglingParentheses\, \Docstrings\, \Comments\, \ImportSelectors\, \IndentOperator\, \Indents\, \Literals\, \Newlines\, and \AvoidInfixSettings\. Users will now configure these specific areas (such as alignment tokens, bin-packing sites, and newline handling) through these distinct types, which are integrated into the main configuration via \metaconfig\ codecs. This structure supports more granular control and clearer separation of concerns for formatting rules.

scalafmt-core/shared/src/main/scala/org/scalafmt/config · high confidence

Custom styling and interactivity for the Scalafmt documentation site

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

Docs site migrated to Docusaurus with new mdoc modifiers

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

GraalVM native-image compatibility via JVM-specific PriorityQueue

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

Introduce JVM/Native platform-specific system operations

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

Introduce asynchronous file operations and Scala Native support

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

Introduces Scala version-specific compatibility layers for collections and execution contexts

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

JVM CLI implementation refactored into platform-specific utility traits

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

Refactor configuration parsing into a new ConfParsed class

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

Refactor formatting engine with new internal components and split-based routing

The internal formatting engine has been restructured to improve performance and maintainability. The Router now delegates split generation to a new Splits trait-based system, replacing the previous monolithic logic. New classes have been introduced to handle specific concerns: InfixSplits manages infix expression formatting, MissingBraces handles brace insertion logic, and OptionalBraces manages Scala 3's optional braces. The formatting state is now tracked using a new ModExt class that bundles modifications with indentation policies, and PolicySummary has been refactored to use a rank-based sorting system for more efficient policy expiration. Additionally, FormatTokens has been expanded with new methods for token traversal and matching, and a new Constants object centralizes formatting penalty values.

scalafmt-core/shared/src/main/scala/org/scalafmt/internal · high confidence

Refactor internal formatting utilities and add Markdown support

The internal utility package has been reorganized and expanded: new modules handle literal formatting (LiteralOps), structured logging (LoggerOps, LogLevel), Markdown code-fence formatting via mdoc (MarkdownParser), policy operations (PolicyOps), style mapping (StyleMap), token classification (TokenClasses), token operations (TokenOps), token traversal (TokenTraverser), tree extraction (TreeExtractors), and validation (ValidationOps). These changes improve how scalafmt processes literals, logs debug information, formats embedded Markdown code, manages formatting policies and style overrides, and traverses/analyzes tokens and trees.

scalafmt-core/shared/src/main/scala/org/scalafmt/util · high confidence

Refactored core formatting API and added per-file dialect support

The core \Scalafmt\ object has been restructured to support file-specific configuration and improved error reporting. Users integrating with the library will notice that the main \format\ method now accepts an optional \filename\ parameter, enabling the formatter to automatically apply the correct Scala dialect (such as Sbt dialect for \.sbt\ files) based on the file path. Additionally, the API now returns the configuration actually used for formatting within the result object, and parse errors are enhanced with dialect context to aid debugging. The internal implementation also introduces a \MarkdownParser\ for handling markdown code blocks and uses \java.nio.file.Path\ for configuration file loading.

scalafmt-core/shared/src/main/scala/org/scalafmt · high confidence

Rewrite engine refactored to FormatTokensRewrite with new rule implementations

The rewrite system has been migrated from the legacy Rewrite/RewriteSession model to a token-based FormatTokensRewrite engine. This change introduces new rewrite rules including AvoidInfix (converting infix operators to dot notation), ConvertToNewScala3Syntax (upgrading Scala 2 syntax to Scala 3), ProcedureSyntax (adding explicit return types), RemoveEmptyDocstrings, RemoveSemicolons, and RewriteLiterals. The core FormatTokensRewrite class now manages token replacement, removal, and patching, while the old RewriteFactory and RewriteCtx abstractions have been replaced by FormatTokensRewrite.Rule and RewriteCtx built on FormatTokens.

scalafmt-core/shared/src/main/scala/org/scalafmt/rewrite · high confidence

Scala 3 support added to build

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

Scalafmt dynamic core restructured with new service provider and classloader ownership

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

Website migrated to Docusaurus v3 with new landing page and improved documentation experience

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

Test coverage

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.

Dependencies

Add Prettier for documentation formatting and upgrade Docusaurus for the website

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

Migrate build infrastructure to sbt 2.0 and modernize dependency management

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

Housekeeping

Added code examples for matrix formatting and strip margin usage

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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 58 → 62 (+3.3)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 67 → 67 (-0.3)
  • Architecture 88 → 88 (+0.0)
  • Maturity 47 → 53 (+5.4)
  • Readiness 63 → 66 (+3.5)
  • Security 77 → 70 (-7.3)
  • Performance 80 → 91 (+11.9)

Resolved (2)

  • No ADRs found
  • Off-boarding risk: anonymized user #1

New (15)

  • Edited copy of a member (11 corresponding lines) (scalafmt-core/shared/src/main/scala/org/scalafmt/util/TokenOps.scala)
  • Edited copy of a member (12 corresponding lines) (scalafmt-benchmarks/src/resources/scala-js/GenJSCode.scala)
  • Edited copy of a member (12 corresponding lines) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/Splits.scala)
  • Edited copy of a member (12 corresponding lines) (scalafmt-core/shared/src/main/scala/org/scalafmt/util/TreeOps.scala)
  • Edited copy of a member (17 corresponding lines) (scalafmt-benchmarks/src/resources/scala-js/GenJSCode.scala)
  • Edited copy of a member (18 corresponding lines) (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/OptionalBraces.scala)
  • Edited copy of a member (26 corresponding lines) (scalafmt-benchmarks/src/resources/scala-js/GenJSCode.scala)
  • Edited copy of a member (34 corresponding lines) (scalafmt-benchmarks/src/resources/scala-js/Division.scala)
  • Edited copy of a member (39 corresponding lines) (scalafmt-benchmarks/src/resources/scala-js/OptimizerCore.scala)
  • Edited copy of a member (44 corresponding lines) (scalafmt-benchmarks/src/resources/scala-js/GenJSCode.scala)
  • Edited copy of a member (9 corresponding lines) (scalafmt-benchmarks/src/resources/scala-js/JSDependency.scala)
  • No ADRs found (build.sbt)
  • Off-boarding risk: anonymized user #1
  • Outdated: com.typesafe:config
  • addStmtFT spells FT where 14 names in the project spell it Ft (scalafmt-core/shared/src/main/scala/org/scalafmt/internal/OptimizationEntities.scala)

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit e1f0c2dcdcc5649c424264ca5b88b6b0322ae30a — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.