com-lihaoyi/mill
49.5
Weak · 14 November 2026
96.5k
lines of production code
Scala
with Java
6
measurements over time
What this system is
Features
Add API support for Play Framework 2.9 and 3.0
The Play library API now includes explicit version constants for Play Framework 2.9 and 3.0, alongside existing 2.6, 2.7, and 2.8 support. This update introduces a new \RouteCompilerType\ enum to distinguish between \InjectedGenerator\ and \StaticGenerator\ strategies, and updates the \RouteCompilerWorkerApi\ to accept this generator type, enabling users to compile routes using the appropriate strategy for their specific Play version.
contrib/playlib/api · high confidence
Add AWS CodeArtifact publishing support
Introduces a new contrib module that enables publishing Mill artifacts to AWS CodeArtifact. Users can now extend \CodeartifactPublishModule\ to configure release and snapshot repository URIs, authenticate via AWS authorization tokens, and execute the \publishCodeartifact\ command to upload artifacts and metadata.
contrib/codeartifact · high confidence
Add Android app-bundle example with Hello World activity
The example/androidlib/java/2-app-bundle/bundle location now includes a complete Android application structure, featuring an AndroidManifest.xml that defines MainActivity as the launcher, a Java activity that displays a centered "Hello, World Bundle!" text, and resource files for colors and strings. This provides a concrete example of an Android app bundle setup within the example project.
example/androidlib/java/2-app-bundle/bundle · high confidence
Add Arrow Kotlin library example
Introduces a new build configuration for the Arrow Kotlin library in the \example/thirdparty/arrow\ directory. This setup defines a multiplatform module structure supporting JVM and JS targets, integrates key dependencies such as kotlinx-coroutines, kotest, and kotlinx-serialization, and configures testing and code coverage via Kover.
example/thirdparty/arrow · high confidence
Add Compose screenshot testing example for Android
The \3-compose-screenshot-tests\ example now includes a complete Android application setup for demonstrating Jetpack Compose screenshot testing. This addition provides the necessary source files, including \MainActivity\, Compose theme definitions, and resource assets, alongside a screenshot test module that validates UI components like the \messageCard\ composable across different screen sizes.
example/androidlib/kotlin/3-compose-screenshot-tests · high confidence
Add CycloneDX SBOM generation with Package URL support and Dependency Track upload
The SBOM contributor module now generates Software Bill of Materials in the CycloneDX format, including Package URL (purl) identifiers for each dependency component. Users can also upload the generated SBOM directly to a Dependency Track instance via a new command that requires configuration of the target URL, project ID, and API key.
contrib/sbom/src · high confidence
Add Dagger/KSP dependency injection example module
A new example module at example/kotlinlib/module/10-dependency-injection demonstrates using the Kotlin Symbol Processing (KSP) API with the Dagger dependency injection framework. The module is configured via build.mill.yaml to use Kotlin 2.2.20 and KSP 2.0.2, and includes source files that define a Dagger component, modules, and providers to generate a random number. It also includes a test configuration using JUnit 5 and Kotest to verify the injection setup.
example/kotlinlib/module/10-dependency-injection · high confidence
Add Fansi cross-build example using new build.mill format
Added a new example at example/thirdparty/fansi/build.mill demonstrating how to configure a small library (Fansi) for cross-compilation across Scala 2.12, 2.13, and 3.3 on JVM, JS, and Native platforms. The build file uses the new build.mill format, defines the FansiModule and FansiTestModule traits, and sets up the cross-build matrix with specific Scala and platform versions.
example/thirdparty/fansi · high confidence
Add GitLab plugin for publishing and dependency resolution
Introduces a new \mill-contrib-gitlab\ plugin that enables publishing artifacts to and resolving dependencies from GitLab Package Registry. The plugin provides \GitlabPublishModule\ for publishing, which automatically detects GitLab CI/CD pipelines and supports personal, deploy, and CI job tokens via a configurable lookup mechanism. It also includes \GitlabMavenRepository\ to securely fetch dependencies from GitLab without hardcoding secrets in build files, supporting project, group, and instance-level Maven repositories.
contrib/gitlab · high confidence
Add JMH benchmarking support via contrib module
Users can now integrate JMH benchmarking into Mill projects by mixing in the new \contrib.jmh.JmhModule\. This module automatically manages JMH core and bytecode generator dependencies, generates benchmark sources, and exposes \runJmh\ and \listJmhBenchmarks\ tasks for executing and inspecting benchmarks. The implementation runs benchmarks in exclusive mode and forwards JVM arguments via \forkArgs\.
contrib/jmh · high confidence
Add JNI example demonstrating Java-C integration with Mill
A new example project at \example/javalib/module/15-jni\ demonstrates how to compile C code alongside Java using Mill's JNI support. The example defines custom \nativeSources\, \nativeHeaders\, and \nativeCompiled\ tasks to generate JNI headers via \javac\ and compile C sources with \clang\, allowing Java applications to load native libraries via \System.load\.
example/javalib/module/15-jni · high confidence
Add Java dependencies example with Jetty servlet and nanojson parsing
The javalib dependencies example now includes a runnable Java module that demonstrates managing compile-time and runtime Maven dependencies (javax.servlet, Jetty, nanojson) as well as unmanaged classpath JARs. Users can run the example to start a local Jetty HTTP server serving a simple servlet and to parse JSON input using the nanojson library.
example/javalib/dependencies/1-dependencies · high confidence
Add Java example demonstrating RootModule usage
Added a new example in \example/fundamentals/modules/7-root-module\ that illustrates how to define a \RootModule\ using \object \package\ extends JavaModule\. The example includes a \build.mill\ file configuring dependencies (argparse4j, thymeleaf, slf4j-nop) and a test module (Guava, Junit4), along with Java source and test files for a simple HTML template application.
example/fundamentals/modules/7-root-module · high confidence
Add JavaScript library example with resource file access
A new TypeScript source file (src/foo.ts) has been added to the example JavaScript library module. This file defines a Foo class that reads a bundled resource file (file.txt) using the RESOURCES environment variable, providing a concrete example of how to access embedded resources in a JavaScript/TypeScript build.
example/javascriptlib/module/5-resources/foo · high confidence
Add JetLagged and JetNews Compose sample apps
The \example/thirdparty/android-compose-samples\ directory now includes build definitions for two Android Compose sample applications: JetLagged and JetNews. These samples demonstrate modern Android development using Kotlin 2.2.20, targeting API level 33 for compilation and API level 21 for minimum support. They utilize the AndroidX Compose BOM (version 2025.05.00) to manage dependencies for UI components, lifecycle, navigation, and window management, and include configurations for R8 minification and instrumented testing.
example/thirdparty/android-compose-samples · high confidence
Add Koin AndroidX sample project
A new Mill build configuration for the Koin AndroidX sample application has been added to the repository. This example project demonstrates the integration of Koin (version 4.1.1) with AndroidX components, including lifecycle, navigation, and work manager, using Kotlin 2.2.20. It is configured to compile against Android SDK 35 with a minimum SDK of 26 and includes unit tests via Robolectric and JUnit4 to verify module configuration and activity launching.
example/thirdparty/koin-androidx-samples · high confidence
Add Kotlin JNI example demonstrating native C integration
A new example project at example/kotlinlib/module/15-jni demonstrates how to compile Kotlin code alongside native C sources using Java Native Interface (JNI). The example includes a build configuration that compiles C code with clang into a shared library and passes the resulting binary path to the Kotlin application via an environment variable, allowing the Kotlin code to load and call native methods.
example/kotlinlib/module/15-jni · high confidence
Add Kotlin build examples
Added a new set of examples under \example/kotlinlib/basic\ demonstrating how to build Kotlin projects with Mill. The examples cover simple and multi-module setups using both YAML (\build.mill.yaml\) and programmable (\build.mill\) configurations, including Maven-compatible layouts, custom build logic, and publishing. They showcase the \KotlinModule\ and \KotlinMavenModule\ base types, dependency management via \mvnDeps\, and testing with JUnit 5 and Kotest.
example/kotlinlib/basic · high confidence
Add Kotlin linting, formatting, and coverage tooling
The \kotlinlib\ module now includes built-in support for code quality and coverage tools. Users can run Detekt for static analysis, Ktlint for linting and auto-formatting, and Ktfmt for code formatting, each with configurable arguments. Additionally, Kover integration allows generating HTML and XML test coverage reports for Kotlin projects, including aggregated reports across multi-module builds.
kotlinlib · high confidence
Add Kotlin/HTTP web server example using Ktor
A new example project has been added to demonstrate a Kotlin web server built with the Ktor framework. The example includes a server implementation that listens on a configurable port (defaulting to 8080) and exposes a POST endpoint at /reverse-string which returns the request body in reverse order. It is configured to use Ktor version 2.3.7 with the CIO engine, Kotlin version 2.2.20, and includes JUnit 5 tests for the server functionality.
example/kotlinlib/web/1-web-example · high confidence
Add Kotlin/Java dependencies example with Jetty and nanojson
The example/kotlinlib/dependencies/1-dependencies module now demonstrates how to configure and use external Maven dependencies in a Mill-based Kotlin project. It includes a build configuration that extends the KotlinModule, sets the Kotlin version to 2.2.20, and declares compile-time and runtime dependencies for Jetty (9.4.42) and servlet-api (2.5), along with an unmanaged classpath entry for nanojson (1.8). The example provides two Java source files: one showing how to set up a basic Jetty HTTP server with a servlet, and another demonstrating how to parse JSON using the nanojson library.
example/kotlinlib/dependencies/1-dependencies · high confidence
Add Kotlin/Spring Boot TodoMVC example with Thymeleaf and JPA
This location introduces a new TodoMVC reference implementation built with Kotlin and Spring Boot. It demonstrates a full-stack web application using Thymeleaf for server-side HTML rendering, Spring Data JPA with an H2 in-memory database for unit tests, and Testcontainers with PostgreSQL for integration tests. The example includes a RESTful-style controller for managing todo items, validation for form data, and WebJars for serving static assets.
example/kotlinlib/web/8-todo-spring-boot · high confidence
Add Micronaut Native AOT example
A new example project has been added to demonstrate configuring Mill for a Micronaut native application using Micronaut AOT. The example includes the necessary build configuration, source code, and resource files to generate and run a native image.
example/javalib/web/5-micronaut-native · high confidence
Add Micronaut example with Kotlin and KSP support
Introduces a new Micronaut-based example application in the \9-hello-micronaut\ directory, demonstrating integration with Kotlin 2.2.20 and KSP 2.3.3. The build configuration (\build.mill\) sets up dependencies for Micronaut 4.9.2 (including HTTP server, Jackson serialization, and data processing) and configures KSP processors for dependency injection. The example includes a standard application setup with \application.properties\ (defaulting to port 8080) and \logback.xml\ for console logging, along with a test configuration that disables the server port for unit testing.
example/kotlinlib/web/9-hello-micronaut · high confidence
Add Micronaut full-stack TodoMVC example with HTMX and JDBC
This location introduces a complete Micronaut-based TodoMVC example that demonstrates a full-stack web application using Thymeleaf for templating, HTMX for interactivity, and H2 via JDBC for data persistence. The example includes a controller handling CRUD operations, a repository for data access, and a mapper for form-to-entity conversion, along with build configuration for Micronaut 4.4.3 and a test suite verifying the application, controller, mapper, and static resource availability.
example/javalib/web/4-todo-micronaut · high confidence
Add Mill build configuration for Apache Commons IO example
The example/thirdparty/commons-io directory now includes a build.mill file that defines the build structure for the Apache Commons IO library. This configuration sets up the project to use Java 11 (Temurin), configures Maven publishing settings, and includes dependencies for JUnit 5, Mockito, and JMH benchmarks, enabling users to compile, test, and run benchmarks for this third-party library using Mill.
example/thirdparty/commons-io · high confidence
Add Mockito build definition using new Mill format
The example/thirdparty/mockito directory now includes a build.mill file that defines the Mockito project structure using the new Mill build syntax. This includes module definitions for the main library, Android support, Error Prone integration, and various JUnit test configurations (JUnit 4, JUnit Jupiter, and inline tests). The build specifies dependencies for ByteBuddy, JUnit, AssertJ, and other testing libraries, and configures specific JVM options and test frameworks for different submodules.
example/thirdparty/mockito · high confidence
Add Netty third-party build example using Mill
Introduces a new \build.mill\ file in the \example/thirdparty/netty\ directory that demonstrates how to build the Netty project using the Mill build tool. The configuration defines module hierarchies for Netty components (such as buffer, codec, and transport), configures Maven dependencies for compilation and testing, sets up JUnit 5 test execution with specific fork arguments, and includes logic for compiling native JNI libraries.
example/thirdparty/netty · high confidence
Add OWASP Dependency Check contrib module
Introduces a new contrib module that integrates OWASP Dependency Check into Mill builds. Users can now scan project dependencies for known vulnerabilities (CVEs) by extending OwaspDependencyCheckJavaModule for Java/Kotlin/Scala projects or using OwaspDependencyCheckModule for custom file sets. The module supports configuration via CLI arguments, allows overriding the worker version, and includes offline support and exclusive execution to prevent concurrency issues with the underlying tool.
contrib/owaspdependencycheck · high confidence
Add PySpark example with JDK 21 pinning
A new PySpark example has been added to the documentation, demonstrating a basic Spark application using PySpark 4.0.1. To ensure compatibility with PySpark and bundled Hadoop on newer Java versions, the build configuration explicitly pins the JVM version to 21, preventing runtime errors on JDK 24+.
example/scalalib/spark/2-hello-pyspark · high confidence
Add Python Flask web application examples
Introduced two new Python-based web examples using the Flask framework: a simple 'Hello World' application in the 1-hello-flask/foo directory and a fully functional Todo list application in the 2-todo-flask/todo directory. These examples demonstrate basic routing, template rendering, and state management in Python, providing users with reference implementations for building web services.
example/pythonlib/web/1-hello-flask/foo, example/pythonlib/web/2-todo-flask/todo · high confidence
Add Python web application examples for Flask and Django
New Mill build examples are now available in the \example/pythonlib/web\ directory, demonstrating how to manage Python web applications using the Mill build tool. The set includes a simple Flask app, a Flask-based TodoMVC application with unit and integration tests, a basic Django app, and a Django-based TodoMVC application featuring database migrations and CRUD operations. These examples provide reference implementations for setting up dependencies, running servers, and executing tests for both Flask and Django frameworks.
example/pythonlib/web · high confidence
Add Python web examples using Flask and Django
New example applications have been added to the Python web library, providing reference implementations for both Flask and Django. The Flask example (2-todo-flask) includes a basic todo app with integration tests covering add, list, toggle, edit, and delete operations. The Django examples (3-hello-django and 4-todo-django) provide a simple hello-world app and a full-featured todo app built with Django 5.1.4, including models, views, templates, static assets, and comprehensive unit tests for all CRUD and filtering operations.
(repo-wide) · high confidence
Add Quarkus getting-started example with Mill build support
This location introduces a new example project demonstrating how to build and run a Quarkus application using Mill. It includes the build configuration (build.mill and build.mill.yaml) specifying Quarkus 3.31.3 and GraalVM, a simple REST resource, and both standard and native integration tests, providing a reference for users adopting Quarkus with Mill.
example/javalib/web/6-quarkus-getting-started · high confidence
Add Quarkus-based Todo MVC example
A new example project has been added at example/javalib/web/7-quarkus-todo that demonstrates how to build a Todo MVC application using Quarkus, Mill, and GraalVM. The example includes a REST API for managing tasks, Qute for server-side HTML templating, and H2 with Hibernate ORM Panache for data persistence. It provides both standard JVM and native-image test configurations, allowing users to run and test the application locally or as a native binary.
example/javalib/web/7-quarkus-todo · high confidence
Add R8-enabled Android example with ProGuard configuration and tests
The \example/androidlib/java/5-R8\ location now provides a complete Android application example that uses the R8 code shrinker and obfuscator. This includes a \build.mill\ configuration defining an \AndroidR8AppModule\, ProGuard rule files (\proguard-rules.pro\ and \test-proguard-rules.pro\) to manage code shrinking for both the main app and instrumented tests, and Java source files for the app logic and UI. The example also incorporates unit and instrumented tests to verify functionality under R8 optimization.
example/androidlib/java/5-R8 · high confidence
Add React example with Mill build integration
Added a new example project at example/javascriptlib/basic/2-react that demonstrates how to build and serve a React application using Mill. The example includes a build configuration extending RsWithServeModule, standard React public assets (index.html, manifest.json, robots.txt), and instructions for running tests and bundling the application.
example/javascriptlib/basic/2-react · high confidence
Add Scala 3 support for Android library and application modules
New example projects in the \example/androidlib/scala\ directory demonstrate how to build Android applications and libraries using Scala 3 (version 3.3.4) with Mill. The \1-hello-scala\ example shows a standalone Android app configuration, including unit and instrumented tests, while \2-sum-lib-scala\ illustrates a multi-module setup where a Scala-based Android library is published and consumed by an Android app. These examples confirm that the \AndroidAppScalaModule\ and \AndroidScalaModule\ types are now available for defining Scala-based Android targets.
example/androidlib/scala · high confidence
Add Scala 3.8.2 native-image example with GraalVM and mainargs
A new example module at example/scalalib/packaging/2-native-image-libs/foo demonstrates building a Scala 3.8.2 application into a native image using GraalVM Community 23.0.1. The module extends ScalaModule and NativeImageModule, includes dependencies on scalatags 0.13.1 and mainargs 0.7.8, and configures native-image options (--no-fallback, -Os). It provides a simple CLI entry point via mainargs that generates HTML output using scalatags.
example/scalalib/packaging/2-native-image-libs/foo · high confidence
Add Scala 3.8.2 scalafmt example with Scala 2.13 formatting
A new example project at example/scalalib/linting/2-scalafmt demonstrates integrating Scalafmt with Mill. The example uses Scala 3.8.2 for the build configuration but configures Scalafmt version 3.7.15 to use the scala213 dialect, illustrating how to format code and check for style violations using Mill's built-in scalafmt module.
example/scalalib/linting/2-scalafmt · high confidence
Add Scala Native C interop example
Added a new example project demonstrating how to compile and link C code with Scala Native using Mill. The example includes a Scala module calling a C function to reverse a string, along with the necessary C source file and test configuration using uTest.
example/scalalib/native/2-interop · high confidence
Add Scala Native common configuration example
Added a new example project demonstrating how to configure common Scala Native module settings, including release mode, incremental compilation, linking options, and working directory.
example/scalalib/native/4-common-config · high confidence
Add Scala Native example demonstrating command-line argument parsing
A new example project (1-simple) has been added to the scalalib native examples, showcasing a Scala Native application that uses the mainargs library for command-line argument parsing and utest for testing. The example demonstrates how to configure a Scala Native module with specific versions of Scala (3.3.6) and Scala Native (0.5.8), define dependencies using mvnDeps, and structure a simple program that generates HTML output from user input.
example/scalalib/native/1-simple · high confidence
Add Scala Native multi-module example with C interop
A new example project at example/scalalib/native/3-multi-module demonstrates building a Scala Native application with multiple modules (foo and bar) using Mill. The example includes C source files (HelloWorldBar.c, HelloWorldFoo.c) and headers to show how to link native code, with the foo module calling functions defined in the bar module. It uses Scala 3.3.6, Scala Native 0.5.8, utest 0.8.9 for testing, and mainargs 0.7.8 for argument parsing.
example/scalalib/native/3-multi-module · high confidence
Add Scala Native multi-module example with inter-module C bindings
New example files have been added to the \example/scalalib/native/3-multi-module\ directory to demonstrate a multi-module Scala Native project structure. The \foo\ module (\Foo.scala\) acts as the main entry point, using \mainargs\ for argument parsing and calling into the \bar\ module (\Bar.scala\). Both modules utilize \scala.scalanative.unsafe\ and \scala.scalanative.libc\ to interact with external C functions (\vowelDensity\ in \foo\ and \stringLength\ in \bar\), illustrating how separate Scala Native modules can link and call each other's native interfaces.
example/scalalib/native/3-multi-module/foo · high confidence
Add Scala Spark example for computing summary statistics
A new semi-realistic example project has been added to demonstrate building and running a Scala application with Apache Spark 3.5.6. The example calculates summary statistics from transaction data, providing a \build.mill\ configuration, a \spark-submit.sh\ script that handles Spark installation and execution, and sample CSV resources for testing.
example/scalalib/spark/3-semi-realistic · high confidence
Add Scala Spark example for transaction summary statistics
A new Scala example has been added to the Spark documentation, demonstrating how to read a CSV file of transactions and compute summary statistics (total, average, and count) grouped by category using Spark SQL functions.
3-semi-realistic · high confidence
Add Scala example for reading resources via os-lib
A new Scala example file (Foo.scala) has been added to the 7-resources module, demonstrating how to read a resource file (file.txt) from the classpath using the os-lib library's os.resource path.
example/scalalib/module/7-resources/foo · high confidence
Add Scala scripting examples for web servers and database queries
New example scripts have been added to demonstrate running a simple web server and querying a local SQLite database using Scala. The web server example (3-web-server) uses the Cask framework to provide a single-file script that listens on a configurable port and exposes a /reverse-string endpoint. The database example (4-database) uses ScalaSql to populate and query a local SQLite database containing buyer, product, shipping, and purchase data.
example/scalalib/script/3-web-server · high confidence
Add Scala-based Android example app
A new Android example application written in Scala has been added to the 1-hello-scala location. The app demonstrates a basic Activity that parses a JSON greeting string using Gson and displays the message in a TextView.
1-hello-scala · high confidence
Add Scala-based Calculator example with separate library module
The example/androidlib/scala/2-sum-lib-scala directory now contains a complete Android application example using Scala. It includes a shared library module (com.example.lib) providing a basic integer addition function, and an app module (com.example.app) that consumes this library to perform calculations. Both modules include their respective Android manifests, string resources, and unit tests using ScalaTest.
example/androidlib/scala/2-sum-lib-scala · high confidence
Add ScalaPB integration module
Introduces the \contrib/scalapblib\ module, allowing Mill builds to compile \.proto\ files into Scala case classes using ScalaPB. Users can extend \ScalaPBModule\ to automatically generate sources from the \protobuf\ directory, with configurable options for ScalaPB version, gRPC stub generation, Java conversions, and custom compiler arguments. The module also supports searching for \.proto\ files in dependencies and resolves the \protoc\ binary via Coursier to avoid race conditions.
contrib/scalapblib · high confidence
Add Spark example demonstrating Mill integration with JDK 21
A new example project at example/scalalib/spark/1-hello-spark demonstrates how to run Apache Spark (3.5.4) using Mill. The build configuration pins the JVM to Zulu 21 to avoid compatibility issues with JDK 24+ and includes necessary JVM arguments for native access. It uses Scala 2.12.20 and includes a basic test suite using uTest 0.9.1.
example/scalalib/spark/1-hello-spark · high confidence
Add Spotless linting example with multi-dialect formatting
The example now demonstrates how to use Mill's Spotless plugin to enforce consistent code formatting across Java and Scala files. It introduces a build configuration that applies GoogleJavaFormat to Java sources and Scalafmt (version 3.8.5) to Scala sources, with separate configuration files (.scalafmt.conf for Scala 2.13 and .scalafmt3.conf for Scala 3) to handle dialect-specific syntax correctly. The example includes sample source files (A.java, B.scala for Scala 2, and B.scala for Scala 3) and shows how to run the spotless check and auto-fix commands.
example/scalalib/linting/5-spotless · high confidence
Add Spring Boot AOT example using Mill and Kotlin
This change introduces a new example demonstrating how to build a Spring Boot application with Kotlin, configured via Mill build tool. The example includes a basic REST controller serving a 'Hello, World!' endpoint, supports GraalVM Native Image compilation, and is set up to run tests and native images using Mill tasks.
example/kotlinlib/web/10-spring-boot-aot · high confidence
Add Spring Boot WebFlux WebSocket echo example
Introduces a new example application demonstrating how to implement a WebSocket echo service using Spring Boot WebFlux. The example includes a handler that echoes received text messages, a configuration class to map the WebSocket endpoint at /echo-websocket, and integration tests verifying the echo functionality on a random port.
example/javalib/springboot/5-web-socket-initializr · high confidence
Add Spring Boot configuration processor example
The example directory now includes a new Spring Boot application demonstrating how to use the configuration processor. It features a REST controller that exposes a message retrieved from a custom configuration properties class, illustrating the use of \@EnableConfigurationProperties\ and \@ConfigurationProperties\ for externalized configuration.
example/javalib/springboot/7-configuration-processor · high confidence
Add Spring Boot examples demonstrating declarative and programmable build configurations
The \example/javalib/springboot\ directory now includes a comprehensive set of examples showing how to build Spring Boot applications with Mill. These examples cover both declarative (\build.mill.yaml\) and programmable (\build.mill\) configuration styles, featuring a basic web server, a TodoMVC app with Thymeleaf and JPA, and projects generated via Spring Initializr. New additions include a WebSockets example using Spring Reactive Web, a GraalVM Native Image build, and a configuration processor example, providing users with complete, runnable templates for various Spring Boot use cases.
example/javalib/springboot · high confidence
Add Spring Boot web server example
A new example project has been added to demonstrate a Java web server built with Spring Boot. The example includes a REST controller that reverses a string sent via POST request, configured to use Spring Boot starter web version 3.5.6, and includes JUnit 5 tests using OkHttp for verification.
example/javalib/web/1-web-example · high confidence
Add TestNG integration support
Introduces a new TestNG framework integration for Mill, allowing users to run TestNG-based tests via the \mill.testng.TestNGFramework\ or the \TestModule.TestNg\ trait. The implementation includes a custom listener that bridges TestNG results to Mill's event system and supports a \mill.testng.printProgress\ system property to control console output verbosity.
contrib/testng · high confidence
Add Twirl template compilation support via TwirlModule
Users can now compile Twirl templates (e.g., .scala.html) in Mill by extending the new \mill.twirllib.TwirlModule\ trait alongside \ScalaModule\. This adds a \compileTwirl\ task that generates Scala code from templates, with configurable options for Twirl version, Scala version, custom imports, file formats, and codecs. The implementation uses an isolated classloader to load the Twirl compiler, ensuring compatibility and avoiding classpath conflicts.
contrib/twirllib · high confidence
Add TypeScript library example to Mill build tool
A new example project has been added at example/javascriptlib/basic/1-simple demonstrating how to use Mill's TypeScript support. This example defines a TypeScript module named 'foo' that includes npm dependencies (specifically immutable@4.3.7), Jest-based tests, and a bundling target, providing users with a reference implementation for integrating TypeScript into their Mill builds.
example/javascriptlib/basic/1-simple · high confidence
Add TypeScript module example demonstrating custom source, resource, and environment configuration
The example module at \example/javascriptlib/module/1-common-config\ now includes a \TypeScriptModule\ named \foo\ that demonstrates how to extend common JavaScript/TypeScript build configurations. Users can see how to define custom source directories (\custom-src\), include additional resource folders (\custom-resources\), generate source files dynamically using \Task.dest\, and inject custom environment variables (e.g., \MY\_CUSTOM\_ENV\) into the build environment. The example also shows how these custom sources and resources are bundled and accessed at runtime.
example/javascriptlib/module/1-common-config · high confidence
Add Vaadin contrib module for building Vaadin Flow applications
Introduces the \mill-contrib-vaadin\ module, enabling Mill to build Vaadin Flow web applications. This includes a \VaadinModule\ that supports Vaadin's development mode via \run\/\runBackground\, and a \VaadinProdModule\ for production builds that generates a Vite frontend bundle (equivalent to Maven's \prepare-frontend\ and \build-frontend\ goals). The implementation uses an isolated worker classloader to run Vaadin's \flow-plugin-base\ tooling, requiring JDK 21+ and automatically managing Node.js. A complete example demonstrating Spring Boot integration and executable JAR packaging is also added.
contrib/vaadin, contrib/vaadin/api, contrib/vaadin/worker · high confidence
Add Windows PowerShell wrapper and CI bootstrap/test scripts
This change introduces a new \ci/mill.ps1\ PowerShell wrapper script, enabling Mill to be bootstrapped and run on Windows environments with the same version-resolution logic (checking \.mill-version\, CLI args, or defaults) as the existing shell scripts. It also adds several new CI scripts: \ci/patch-mill-bootstrap.sh\ to apply build patches before bootstrapping, \ci/test-mill-bootstrap.sh\ to verify the bootstrap process and REPL functionality, \ci/test-dist-run.sh\ to test distribution runs on example projects, and \ci/publish-docs.sh\ to automate GitHub Pages deployment.
ci · high confidence
Add acyclic third-party example project
Added a new example project for the acyclic library, demonstrating how to build a Scala compiler plugin using Mill. The build file configures cross-compilation across Scala 2.12 and 2.13 versions, sets up publishing metadata, and includes test configuration using utest. It also handles resource copying for the test suite using BuildCtx.
example/thirdparty/acyclic · high confidence
Add basic Python module example with Jinja2 dependency
Added a new example project demonstrating a simple Python module build using Mill's pythonlib. The example defines a PythonModule that depends on Jinja2 (version 3.1.4) and includes a test suite using Unittest. It showcases typical usage including running the main script, type checking, testing, and bundling the Python application into a self-contained executable.
example/pythonlib/basic/1-simple · high confidence
Add basic compatibility module examples for Java, Kotlin, and Scala
New example modules have been added to demonstrate basic multi-language compatibility setups. The Java example provides a standard library with unit and integration tests using JUnit. The Kotlin example demonstrates interop with a Java dependency (Foo2) and uses Kotest for testing. The Scala example provides a basic library with unit and integration tests using utest. These examples serve as reference implementations for setting up compatible module structures across different JVM languages.
example/javalib/basic/3-compat-modules, example/kotlinlib/basic/3-compat-modules, example/scalalib/basic/3-compat-modules · high confidence
Add declarative and Compose Android example projects
Two new example projects are added to the \example/androidlib/kotlin\ directory. The \1-hello-kotlin-declarative\ example demonstrates configuring an Android Kotlin application using Mill's declarative build system (YAML configuration files) instead of Scala build scripts, including setup for local and instrumented tests. The \2-compose\ example provides a complete Jetpack Compose application scaffold, featuring a Material 3 theme, a counter UI component, and build configuration for running the app on an Android emulator via Mill tasks.
example/androidlib/kotlin/2-compose · high confidence
Add docjar example module demonstrating Javadoc generation
A new example module at example/javalib/module/3-docjar has been added to demonstrate generating a Javadoc JAR. It includes a build configuration (build.mill and build.mill.yaml) that extends JavaModule and passes the -quiet option to javadoc, along with a sample Java class (src/foo/Foo.java) containing Javadoc comments. Users can run ./mill show docJar to generate the JAR and inspect the resulting HTML documentation.
example/javalib/module/3-docjar · high confidence
Add example JSON API web crawler
Added a new example script in \example/scalalib/script/2-json-api-client\ that demonstrates how to crawl Wikipedia's JSON API using Mill's bundled Scala libraries. The example fetches article links recursively and saves the results to a file, providing a practical reference for building API clients and handling JSON responses in Mill scripts.
example/scalalib/script/2-json-api-client · high confidence
Add example for Acyclic circular dependency linting
Added a new example demonstrating how to use the Acyclic Scala compiler plugin to detect and resolve circular dependencies between source files. The example includes a Mill build configuration that enables the plugin via \scalacOptions\ and shows a scenario where \Foo\ and \Bar\ mutually depend on each other, resulting in a compilation error that is resolved by refactoring the code to remove the cycle.
example/scalalib/linting/4-acyclic · high confidence
Add example for Python linting with Ruff
The \example/pythonlib/linting/2-ruff-check\ directory now provides a concrete example of using Ruff as a linter within a Mill Python module. It demonstrates how to extend \RuffModule\ to run the \ruffCheck\ task, which identifies code smells such as unused imports and unnecessary f-strings, and shows how to automatically fix these issues using the \--fix\ flag.
example/pythonlib/linting/2-ruff-check · high confidence
Add example for building Android apps with native C++ libraries
This location introduces a new example demonstrating how to integrate native C++ libraries into an Android application using Mill. It includes the necessary build configuration (AndroidNativeAppModule), C++ source code via CMake, and an instrumented test that verifies the native library correctly returns a string to the Java/Kotlin layer.
example/androidlib/java/6-native-libs · high confidence
Add example for built-in CLI commands
Added a new example file (\example/cli/builtins/1-builtin-commands/build.mill\) that demonstrates the usage of Mill's built-in CLI commands such as \resolve\, \inspect\, \show\, and \showNamed\. The example includes a sample build structure with \JavaModule\ definitions and detailed usage comments showing how to query tasks, inspect task metadata, and view structured JSON output for debugging and external tool integration.
example/cli/builtins · high confidence
Add example for generating GraalVM native images with Mill
A new example project has been added to demonstrate packaging a Scala application as a native executable using GraalVM. The example configures a Scala 3.8.2 module extending both ScalaModule and NativeImageModule, specifies a GraalVM JDK 17.0.7, and applies the --no-fallback option to produce a smaller native binary.
example/scalalib/packaging/1-native-image · high confidence
Add example for packaging Kotlin libraries with GraalVM Native Image
A new example project has been added to demonstrate how to package Kotlin libraries into a GraalVM Native Image. This example configures the build to use Kotlin 2.2.20 and GraalVM Community JDK 23.0.2, includes specific Maven dependencies (Clikt and kotlinx-html), and applies native image options such as disabling fallback, optimizing for size, and initializing specific classes at build time.
example/kotlinlib/packaging/2-native-image-libs · high confidence
Add example for running Groovy via a persistent JVM classloader worker
The \3-worker\ example now demonstrates how to use a persistent \Task.Worker\ to host a JVM classloader for executing Groovy scripts, replacing the previous approach of spawning subprocesses. This allows the JVM to optimize the loaded code, reducing overhead for repeated invocations. The example includes a \build.mill\ file defining a \GroovyGenerateJavaModule\ that uses \Jvm.createClassLoader\ and \mill.api.ClassLoader.withContextClassLoader\ to run Groovy's \GroovyMain\, along with sample scripts for \foo\ and \bar\ modules.
example/extending/jvmcode/3-worker · high confidence
Add example for unmanaged JAR dependencies
A new example module has been added to demonstrate how to include unmanaged JAR files in a Mill build. The configuration specifies \lib/nanojson-1.8.jar\ in the \unmanagedClasspath\, and the accompanying Java source code shows how to use the nanojson library to parse JSON strings.
example/javalib/dependencies/3-unmanaged-jars · high confidence
Add example for unmanaged JAR dependencies in Kotlin library
This change introduces a new example located at \example/kotlinlib/dependencies/3-unmanaged-jars\ that demonstrates how to configure and use unmanaged JAR dependencies within a Kotlin Mill project. The example configures the build to extend \KotlinModule\ with Kotlin version 2.2.20 and includes the \nanojson-1.8.jar\ library in the unmanaged classpath. It provides a sample Kotlin source file (\src/foo/Foo.kt\) that imports and uses the \nanojson\ library to parse JSON strings, illustrating the practical usage of external, non-Maven dependencies in a Kotlin project.
example/kotlinlib/dependencies/3-unmanaged-jars · high confidence
Add example for using Scala 3 nightly releases
A new example project demonstrates how to configure Mill to resolve and run Scala 3 nightly builds. The example sets the Scala version to a specific nightly release (3.8.3-RC1) and adds the Scala nightly repository to the build configuration, allowing users to see how to integrate pre-release compiler versions into their projects.
example/scalalib/dependencies/6-scala-nightly · high confidence
Add example for using mill-contrib-buildinfo plugin
Added a new example demonstrating how to use the \mill-contrib-buildinfo\ plugin to generate build information, such as the Scala version, into a \BuildInfo\ object within a Mill project.
example/extending/imports/3-contrib-dep · high confidence
Add example module for custom Kotlin traits
Added a new example module (17-custom-trait) that demonstrates a custom Kotlin module configuration. The module extends the LineCountKotlinModule build definition, targets Kotlin version 2.2.20, and includes a sample Kotlin source file that reads and prints a line count from a resource file.
example/kotlinlib/module/17-custom-trait · high confidence
Add example plugin integration tests with example test support
This location introduces a complete test suite for the \LineCountJavaModule\ example plugin, including both standard integration tests and a new 'example test' mechanism. The integration tests verify the plugin's end-to-end behavior by launching a Mill subprocess, asserting compilation output, and checking generated resource files. Additionally, the new example tests allow plugin usage to be documented and validated directly within the \build.mill\ file via \/\\ Usage \*/\ comments, enabling users to see expected commands and output in a single file.
example/extending/plugins/2-plugin-integration-tests · high confidence
Add generator for Eclipse JDT project files
Mill now includes a new generator that creates Eclipse JDT project files (.project, .classpath, and related settings) for Java modules. This allows Java projects to be imported directly into Eclipse IDE. The generator aggregates Java modules and their test modules into combined Eclipse projects, handles linked resources for source folders outside the project directory, and configures Java source/target versions based on the running JVM. Note that Kotlin support is not yet included in this generator.
core/api/daemon/src/mill/api/daemon/internal/eclipse, runner/eclipse, eclipse · high confidence
Add in-memory classloader example for JVM code extension
A new example in the extending JVM code section demonstrates how to use \Jvm.withClassLoader\ to load dependencies (specifically Groovy) into an in-memory classloader and invoke methods via reflection, offering a lower-overhead alternative to spawning subprocesses.
example/extending/jvmcode/2-classloader · high confidence
Add mill build configuration for Android endless-tunnel example
Introduces a new \build.mill\ file for the \example/thirdparty/android-endless-tunnel\ directory, enabling the Android NDK sample to be built using the mill build tool. The configuration sets up an \AndroidNativeAppModule\ targeting API level 19 with compile SDK 35, configures the application ID and namespace, and includes specific CMake arguments for static C++ STL linking. It also provides default (insecure) release signing credentials for testing and overrides the default Android Virtual Device name to 'cpp-test'.
example/thirdparty/android-endless-tunnel, example/thirdparty/jimfs · high confidence
Add persistent tasks example
Added a new example demonstrating persistent tasks (\Task(persistent = true)\), which maintain state on disk across evaluations without clearing their destination folder. The example includes a simple counter and a realistic file compression cache scenario, showing how tasks can manage their own cache invalidation logic.
example/fundamentals/tasks/5-persistent-tasks, example/javalib/dependencies/4-downloading-unmanaged-jars · high confidence
Add realistic client-server example with Express and Jest testing
The example directory now includes a more complex client-server setup (\6-client-server-realistic\) that demonstrates a React web app running on an Express.js server, implementing a Todo-MVC demo. This example introduces server-side npm dependencies (Express, CORS) and server-side testing using Jest and Supertest, alongside the existing client-side React and Jest configuration.
example/javascriptlib/basic/6-client-server-realistic · high confidence
Add simple Scala script example with HTML generation
A new example file (Foo.scala) has been added to the 1-simple module, demonstrating a basic Scala application that uses mainargs for command-line argument parsing and scalatags to generate simple HTML output.
example/scalalib/basic/1-simple · high confidence
Add support for batch task mode in forked tests
Users can now enable batch task mode for forked tests by setting \testBatchFrameworkTasks = true\ in their Mill build configuration. This change introduces a new test framework (\BatchFramework\) that groups test tasks, ensuring that specific test suites (like \BatchSuiteTest\) are executed together with their required shared resources (like \SharedResource\) and that environment variables are correctly passed to the forked JVM process.
integration/feature/test-task-batch · high confidence
Added Android linting example with custom configuration
The example directory now includes a complete Android application setup demonstrating how to configure and run linting checks. It provides a \lint.xml\ file to suppress specific warnings (such as the missing application icon) and a Mill build script that configures the \AndroidAppModule\ to generate lint reports in both text and HTML formats. This allows users to see how linting integrates into the build process and how to customize severity levels and report outputs.
example/androidlib/java/3-linting · high confidence
Added Bar utility for file transformation
The Bar module now includes a Java utility that processes source files. When executed, it walks through specified directories, finds all .java files, replaces the text 'hello' with 'HELLO', and writes the modified content to a destination directory.
example/extending/jvmcode/6-module-cached-classloader/bar · high confidence
Added Groovy example library
Added a new example library under example/groovylib/basic that demonstrates Groovy usage, including simple scripts, declarative styles, module dependencies, Java-Groovy interoperability, and integration tests.
(repo-wide) · high confidence
Added HTML scraper example using JSoup
A new example script has been added to demonstrate web scraping capabilities using the JSoup library. The \HtmlScraper.scala\ file implements a crawler that fetches links from Wikipedia pages, allowing users to traverse article links to a specified depth. The example includes a \build.mill\ configuration file that declares the external JSoup dependency via the \mvnDeps\ header, illustrating how to integrate third-party Java libraries into Mill scripts.
example/scalalib/script/1-html-scraper · high confidence
Added JVM code extension examples
Added example source files for the JVM code extension module, including Java and Scala implementations for 'foo' and 'bar' modules that demonstrate basic classloader and run-task usage.
(repo-wide) · high confidence
Added Java classloader example code
New Java source files were added to the JVM code extending examples to demonstrate reading resources from the classpath. Specifically, \Foo.java\ was added to the \2-classloader\ example, and both \Foo.java\ and \Bar.java\ were added to the \3-worker\ example. These files implement a \groovyGeneratedHtml\ method that loads \groovy-generated.html\ via the class loader's resource stream.
example/extending/jvmcode/2-classloader/foo, example/extending/jvmcode/3-worker/bar, example/extending/jvmcode/3-worker/foo · high confidence
Added Java example classes for sandbox testing
New Java source files (Bar.java and Foo.java) were added to the example/depth/sandbox/2-test directory structure. These classes provide simple HTML generation methods (wrapping text in \<p\> and \<h1\> tags respectively) intended for use in sandboxing tests.
example/depth/sandbox/2-test/bar, example/depth/sandbox/2-test/foo · high confidence
Added Java examples for CLI builtin commands
Added Java source files for the 'foo' and 'bar' CLI builtin command examples. The 'bar' example demonstrates HTML generation using Thymeleaf, while the 'foo' example shows command-line argument parsing using argparse4j and integration with the 'bar' command.
example/cli/builtins/1-builtin-commands/bar, example/cli/builtins/1-builtin-commands/foo · high confidence
Added Java, Kotlin, and Scala packaging examples
New example projects have been added to demonstrate packaging strategies for JVM-based languages. These include native image setups, assembly configurations for loading resources, repackage configurations for multi-module dependencies, jlink module definitions, and jpackage examples featuring Swing GUIs with CI detection. The examples cover Java, Kotlin, and Scala implementations.
(repo-wide) · high confidence
Added JavaScript/TypeScript example projects to Mill
This change introduces new example projects demonstrating JavaScript and TypeScript support within the Mill build tool. The diff adds a multi-module TypeScript library example and two React-based client-server applications (a basic 'Hello World' setup and a realistic TodoMVC implementation), including their source code, styles, and associated unit tests.
(repo-wide) · high confidence
Added JavaScript/TypeScript example projects to the Mill build tool
The Mill build tool now includes example projects demonstrating JavaScript and TypeScript support. These examples, located under the \example/javascriptlib\ directory, showcase various configurations including common configuration, custom tasks, compilation and execution flags, and executable configurations, providing users with reference implementations for integrating JS/TS workflows into their Mill builds.
(repo-wide) · high confidence
Added JavaScript/TypeScript linting and code-coverage examples
The Mill build tool now includes example projects demonstrating JavaScript and TypeScript support, specifically focusing on linting and code coverage workflows. New example files have been added under \example/javascriptlib/linting/\ to illustrate how to lint TypeScript source files (including auto-formatting scenarios) and how to measure code coverage for TypeScript classes like \Calculator\ and \Foo\.
(repo-wide) · high confidence
Added JavaScript/TypeScript publishing examples
New example projects have been added to demonstrate how to publish JavaScript and TypeScript libraries and CLI tools using Mill. The '1-publish' example shows a simple Node.js tool configuration, while '2-realistic' demonstrates a more complex setup with TypeScript modules, multiple package exports, external dependencies, and Jest-based testing.
example/javascriptlib/publishing · high confidence
Added KAPT annotation processing example
A new example module has been added to demonstrate Kotlin annotation processing using KAPT and MapStruct. This example configures a Mill build with Kotlin 2.2.20 and MapStruct 1.6.3 to generate mapper implementations for both main and test sources, illustrating how to integrate KAPT within the project structure.
example/kotlinlib/module/11-annotation-processing-kapt · high confidence
Added Node.js HTTP server for serving static assets and API routes
The example project now includes a dedicated server component (\server.ts\) that runs on Node.js. This server handles API requests at the \/api/hello\ endpoint and serves static client-side build files, including a fallback to \index.html\ for client-side routing. It also manages content-type headers for various static file extensions.
example/javascriptlib/basic/5-client-server-hello/server · high confidence
Added Play Framework 2.9 and 3.0 route compiler workers
New RouteCompilerWorker implementations have been added for Play Framework versions 2.9 and 3.0, enabling route compilation support for these specific versions within the Mill build tool.
contrib/playlib/worker/2.9, contrib/playlib/worker/3.0 · high confidence
Added Python CLI entry point for the foo module
The foo module now includes a Python script (src/foo.py) that serves as a command-line interface. Users can run the module directly to process two text arguments, --foo-text and --bar-text, which are passed to the main logic. The script integrates with the bar module to generate HTML output for the bar text argument, combining both inputs into a formatted string result.
example/pythonlib/basic/3-multi-module/foo · high confidence
Added Python library example modules demonstrating common configurations and features
New example files have been added to the \example/pythonlib/module\ directory to demonstrate various Python library configurations and capabilities. These include examples for common configuration using Jinja2 templates, custom tasks with argument parsing and environment variables, resource loading via \importlib.resources\, and PEX configuration utilizing external libraries like \pyfiglet\ and \termcolor\ for ASCII art generation.
(repo-wide) · high confidence
Added Python library example with resource file access
The example now includes a Python module (foo.py) that demonstrates how to read text resources using the standard library's importlib.resources, specifically reading a line-count.txt file and printing the result.
example/pythonlib/basic/2-custom-build-logic/foo · high confidence
Added Quarkus Maven example build definition
A new build definition file has been added to the Quarkus Maven example directory, enabling users to initialize the project with Mill and compile specific Quarkus quickstarts such as the reactive and Kafka Avro schema examples.
example/migrating/javalib/6-maven-quarkus · high confidence
Added React TypeScript example application
The example directory now includes a complete React application scaffolded with TypeScript, featuring the standard entry points (index.tsx, App.tsx), styling (App.css, index.css), performance reporting (reportWebVitals.ts), testing setup (setupTests.ts, App.test.tsx), and assets (logo.svg).
example/javascriptlib/basic/2-react/foo · high confidence
Added React-based text analysis client with sentiment visualization
The client directory now includes a new React application that provides a user interface for submitting text to a local analysis API. Users can enter text into a form, which sends a POST request to the backend, and view the results in a container that visually indicates sentiment (positive, negative, or neutral) through color-coded backgrounds. The entry also includes the corresponding CSS styles for the interface and unit tests to verify the rendering and sentiment-display behavior.
example/large/multilang/14-multi-language/client · high confidence
Added Scala 3 assembly configuration example
A new example module demonstrates how to configure Mill's assembly task for Scala 3 projects. It shows how to define module dependencies, set the Scala version to 3.8.2, and customize the assembly process using rules to append configuration files, exclude specific patterns, and relocate packages. The example includes resource files to illustrate how multiple \application.conf\ files are merged into a single JAR.
example/scalalib/packaging/3-assembly-config · high confidence
Added Scala cross-version example modules
New example modules 'foo' and 'bar' have been added to the scalalib cross-version example directory. The 'bar' module provides a simple object with a value and main method, while the 'foo' module demonstrates cross-version compatibility by printing its own value, accessing the 'bar' module's value, and invoking version-specific text methods.
example/scalalib/module/14-cross-scala-version/bar, example/scalalib/module/14-cross-scala-version/foo · high confidence
Added Scala-based Android example application
A new example project demonstrating Scala support on Android has been added to the examples directory. This includes the main application code, unit and instrumentation tests written in Scala, and the necessary ProGuard configuration rules to ensure proper obfuscation and test execution.
example/androidlib/scala/1-hello-scala · high confidence
Added Scaladoc examples for Foo, Bar, and Qux classes
New example files have been added to the documentation site to demonstrate Scaladoc generation. Specifically, \Foo.scala\, \Bar.scala\, and \Qux.scala\ now include basic class definitions with corresponding Scaladoc comments, providing concrete examples for the \foo\, \foo.bar\, and \foo.qux\ packages within the \15-unidoc\ module.
example/scalalib/module/15-unidoc/foo, example/scalalib/module/15-unidoc/foo/bar, example/scalalib/module/15-unidoc/foo/qux · high confidence
Added Spark 'Hello World' example code in Scala and PySpark
New example files have been added to demonstrate basic Apache Spark usage. The Scala example (example/scalalib/spark/1-hello-spark/foo/src/foo/Foo.scala) and the PySpark example (example/scalalib/spark/2-hello-pyspark/foo/src/foo.py) both implement a simple application that creates a SparkSession, generates a DataFrame containing a single "Hello, World!" message, displays it, and then stops the session.
example/scalalib/spark/1-hello-spark/foo, example/scalalib/spark/2-hello-pyspark/foo · high confidence
Added Spark example code for blog post on fast assembly
A Scala source file demonstrating a Spark application that reads CSV data, computes summary statistics by category, and prints the results has been added to the blog post attachments. This code serves as the illustrative example for the 'Fast JVM Assembly Jars Creation with the Mill Build Tool' article.
fast-assembly · high confidence
Added Spring Boot web and native example applications
New example projects have been added for Spring Boot web (initializr) and native compilation. These examples provide a basic REST controller with a /hello endpoint and configure the server port via the PORT environment variable, allowing users to reference them for starting new Spring Boot applications.
example/javalib/springboot/4-web-initializr, example/javalib/springboot/6-native · high confidence
Added TypeScript example for basic JavaScript library usage
A new TypeScript source file (foo.ts) has been added to the example/javascriptlib/basic/1-simple/foo location, demonstrating a simple library structure that imports the 'immutable' library, defines a User interface, and exports functions for generating user objects and handling CLI arguments.
example/javascriptlib/basic/1-simple/foo · high confidence
Added TypeScript example module for multi-module builds
A new TypeScript source file (bar.ts) has been added to the foo/bar module within the JavaScript/TypeScript multi-module example. This file imports the 'immutable' library to define and export a default constant (defaultRoles) using an immutable Map, serving as a concrete example of TypeScript usage in this build configuration.
example/javascriptlib/basic/4-multi-modules/foo/bar · high confidence
Added TypeScript example projects for JavaScript publishing
Added example TypeScript projects under \example/javascriptlib/publishing\ to demonstrate JavaScript/TypeScript library publishing workflows. These examples include a simple CLI tool (\foo\), a realistic multi-module setup (\2-realistic\) featuring type definitions, dependency usage (immutable.js), and user generation logic, serving as reference implementations for users adopting TypeScript with the build tool.
(repo-wide) · high confidence
Added advanced Python module publishing example
A new example located at \example/pythonlib/publishing/2-publish-module-advanced\ demonstrates how to customize the Python packaging process in Mill. It shows how to extend \PythonModule\ with \PublishModule\ to override the \pyproject\ task for custom metadata (such as \source-include\ settings) and inject additional build files (like a generated \build-note.txt\) into the source distribution.
example/pythonlib/publishing/2-publish-module-advanced · high confidence
Added bar module with HTML generation utility
A new Python module (bar.py) has been added to the bar component, providing a generate\_html function that safely escapes input text and renders it using a Jinja2 template. This allows users to generate basic HTML output from command-line arguments within this specific multi-module example.
example/pythonlib/basic/3-multi-module/bar · high confidence
Added complete Maven migration example for javalib
A new example project at example/migrating/javalib/1-maven-complete demonstrates how to migrate an existing multi-module Maven-based Java project (using JUnit 4) to Mill. The included build.mill file serves as a reference implementation, showing the resulting configuration after running \mill init\ on the source repository, including compilation and test execution steps.
example/migrating/javalib/1-maven-complete · high confidence
Added example demonstrating SemanticDB version configuration
A new example module has been added to demonstrate how to explicitly configure SemanticDB plugin versions for Scala 2 and Java sources within a Mill build. The example sets specific versions for \semanticDbVersion\ (4.17.0) and \semanticDbJavaVersion\ (0.12.3) and includes source files to illustrate the setup.
example/scalalib/module/19-semanticdb-versions · high confidence
Added example demonstrating selectiveInputs configuration
Added a new example in the \selective\ section that demonstrates how to use the \selectiveInputs\ parameter to customize which inputs trigger task re-execution during selective runs. The example defines a command \qux\ that depends on two source files (\foo.txt\ and \bar.txt\) but is configured to only re-run when \foo.txt\ changes, ignoring changes to \bar.txt\.
example/large/selective/10-selective-inputs · high confidence
Added example for bare Python modules with uv integration
Added a new example (\4-bare-modules\) demonstrating how to use \PythonModule.Bare\ in Mill for Python projects that do not follow the standard \src/\ directory layout. This example shows how to configure source paths, integrate with Ruff for linting, and depend on external raw uv projects (like \raw-uv-project\) that are installed into the module's environment.
(repo-wide) · high confidence
Added example for building with Scala nightly versions
An example module has been added to demonstrate how to configure Mill to build against Scala nightly releases. This includes setting up the \ScalaLangNightlies\ repository in a dedicated \JvmWorker\ instance and specifying a nightly Scala version (3.8.0-RC1) in the build definition.
example/scalalib/module/16-scala-nightlies, example/scalalib/module/16-scala-nightlies/foo · high confidence
Added example for relative and workspace-relative script dependencies
An example script has been added to demonstrate how Mill single-file scripts can depend on each other using both relative paths (relative to the enclosing folder) and workspace-relative paths (prefixed with \//\). This serves as a usage reference for the relative dependency feature.
example/scalalib/script/8-relative-deps · high confidence
Added example implementations for programmable module dependencies
New example source files have been added to demonstrate programmable module dependencies in Java, Kotlin, and Scala. The Java example uses Thymeleaf for HTML generation, the Kotlin example uses kotlinx.html, and the Scala example uses scalatags, providing reference implementations for each language ecosystem.
(repo-wide) · high confidence
Added example modules for annotation processors, custom tasks, generated sources, and doc jars
New example modules have been added to demonstrate specific Mill capabilities: the javalib module now includes examples for Lombok annotation processors (GetterSetterExample), custom build tasks (including source generation and command-line arguments), and generated sources; the scalalib module includes an example for creating doc jars. These examples serve as documentation and reference implementations for users configuring these features.
(repo-wide) · high confidence
Added example modules for cached classloader behavior
Added three new example modules (foo1, foo2, and foo3) under the \extending/jvmcode/6-module-cached-classloader\ path. Each module contains a simple Java class (\Foo.java\) that prints a static string value, serving as a test case or demonstration for the cached classloader functionality.
example/extending/jvmcode/6-module-cached-classloader/foo1, example/extending/jvmcode/6-module-cached-classloader/foo2, example/extending/jvmcode/6-module-cached-classloader/foo3 · high confidence
Added example modules for custom traits and programmable dependencies
New example projects have been added to demonstrate advanced Mill build features. The '17-custom-trait' examples (for both Java and Kotlin) show how to define custom module traits that compute source line counts and generate resources. The '18-programmable-module-deps' examples illustrate how to structure modules with explicit dependencies, including a Java example using Thymeleaf for HTML generation and argument parsing, and a Kotlin example using kotlinx.html.
(repo-wide) · high confidence
Added example modules for dynamic cross-module demonstration
The example located at example/fundamentals/cross/9-dynamic-cross-modules now includes three new sub-modules (bar, foo, and qux), each containing a simple Scala object that prints a distinct greeting. These additions serve as concrete code examples for the dynamic cross-module functionality being introduced in this section of the fundamentals.
example/fundamentals/cross/9-dynamic-cross-modules/modules/bar, example/fundamentals/cross/9-dynamic-cross-modules/modules/foo, example/fundamentals/cross/9-dynamic-cross-modules/modules/qux · high confidence
Added example modules for selective execution testing
New example modules (bar, foo, and qux) have been added to demonstrate selective execution capabilities. The 'bar' and 'qux' modules provide utility methods for generating HTML snippets, while the 'foo' module serves as an entry point that utilizes these utilities, illustrating how different components interact within the selective execution framework.
example/large/selective/9-selective-execution/bar, example/large/selective/9-selective-execution/foo, example/large/selective/9-selective-execution/qux · high confidence
Added example projects demonstrating JavaScript/TypeScript dependency management
New example projects have been added to demonstrate how to manage JavaScript and TypeScript dependencies within the build tool. These examples include scenarios for handling npm dependencies, unmanaged packages, and downloading unmanaged packages, each containing a TypeScript source file that imports and uses the lodash library to sort command-line arguments.
example/javascriptlib/dependencies/1-npm-deps/foo, example/javascriptlib/dependencies/2-unmanaged-packages/foo, example/javascriptlib/dependencies/3-downloading-unmanaged-packages/foo · high confidence
Added example projects demonstrating Maven dependency imports and resource handling
New example projects have been added to demonstrate importing Maven dependencies and handling resources. The Java example (foo) shows how to read a resource file (snippet.txt) from the classpath, while the Scala examples (bar and foo) demonstrate similar resource reading and accessing build-time information (Scala version) via BuildInfo.
example/extending/imports/1-mvn-deps/foo, example/extending/imports/2-mvn-deps-scala/bar, example/extending/imports/3-contrib-dep/foo · high confidence
Added example projects for Java, Kotlin, and Scala libraries
Added example projects for Java, Kotlin, and Scala libraries, including basic, multi-module, and realistic configurations.
(repo-wide) · high confidence
Added example projects for JavaScript/TypeScript linting, auto-formatting, and code coverage
New example modules have been added to demonstrate Mill's first-class JavaScript and TypeScript support. The \1-linting\ example shows how to configure ESLint for TypeScript code checking via \mill \_.checkFormatAll\. The \2-autoformatting\ example demonstrates code formatting using both ESLint and Prettier, including configuration files and fallback behavior when one is missing. The \3-code-coverage\ example illustrates how to run tests with coverage reporting using Jest, Mocha, Vitest, and Jasmine test runners.
example/javascriptlib/linting · high confidence
Added example projects for migrating from sbt to Mill
Added two new example projects under \example/migrating/scalalib\ to demonstrate the \mill init\ migration workflow from sbt. The \1-sbt-complete\ example shows a successful conversion of the Scala 3 example project, while \2-sbt-incomplete\ illustrates a migration of the Refined library that requires manual tweaking of source roots for custom Scala version ranges.
example/migrating/scalalib · high confidence
Added example projects for unmanaged wheel downloads and custom repository configuration
Two new example projects have been added to demonstrate Python library dependency management. The 'downloading-unmanaged-wheels' example shows how to use the Jinja2 library, while the 'repository-config' example demonstrates importing a custom package (testpkg\_jodersky) from a configured repository.
example/pythonlib/dependencies/4-downloading-unmanaged-wheels, example/pythonlib/dependencies/5-repository-config/foo · high confidence
Added multi-language example projects for Scala and Java/Python integration
Added example projects demonstrating multi-language build capabilities, including a Scala example that reads environment variables for build metadata and a Java/Spring Boot server that executes a Python sentiment analysis script via a subprocess.
(repo-wide) · high confidence
Added publishing example stubs for Java, Kotlin, and Scala
Added new example source files for the Java, Kotlin, and Scala publishing workflows. These files provide basic 'Hello World' implementations for both VCS-versioned and packaged library structures, serving as reference code for users setting up publishing configurations.
(repo-wide) · high confidence
Added scratch/foo.scala with a basic main method
A new file scratch/foo.scala was added containing a simple main method that prints "Hello".
scratch · high confidence
Added selective execution example demonstrating task filtering
Added a new example build configuration that demonstrates how to use Mill's selective execution features to filter tests and tasks based on code changes. The example shows how to use \selective.prepare\, \selective.run\, and \selective.resolve\ commands to run only affected tests, along with debugging tools like \selective.resolveChanged\ and \selective.resolveTree\ to inspect the dependency graph and selected tasks.
example/large/selective/9-selective-execution · high confidence
Automatic implementation of abstract methods via Scala 3 compiler plugin
A new Scala 3 compiler plugin (\auto-override\) has been added to the \runner/autooverride/plugin\ module. This plugin automatically implements abstract methods for objects extending \AutoOverride\[T\]\ by generating method bodies that delegate to \autoOverrideImpl()\. The plugin runs between the typer and inlining phases to ensure generated macro calls are correctly expanded, reducing boilerplate for users defining auto-override behaviors.
runner/autooverride/plugin · high confidence
Blog content and example attachments consolidated under website/blog
The Mill build tool documentation and blog posts have been reorganized into a single \website/blog\ directory structure. This change consolidates previously separate \blog/\ and \docs/\ folders, introducing a new navigation layout (\nav.adoc\) and attaching example project files (such as \fast-assembly\ and benchmark scripts) directly alongside the blog posts. This provides a unified location for all Mill engineering insights, tutorials, and reference examples.
website/blog/modules/ROOT · high confidence
BuildInfo now generates Kotlin source files and supports static compilation for Scala.js/Scala Native
The BuildInfo module in contrib/buildinfo/src now supports generating source code in Kotlin (in addition to Java and Scala), automatically selecting the language based on the target module type. It also enables static compilation of build info values for Scala.js and Scala Native modules, ensuring compatibility with platforms that do not support JVM resources.
contrib/buildinfo/src · high confidence
Documentation example for custom output directory location
Added a new example (\2-custom-out\) demonstrating how to configure a custom output directory for Mill builds using the \MILL\_OUTPUT\_DIR\ environment variable, complementing the existing documentation on the default \out/\ structure.
example/fundamentals/out-dir · high confidence
Enhanced Gradle build import with Kotlin, framework detection, and Android support
The \mill init\ command now provides significantly improved support for importing Gradle-based projects. It automatically detects and handles Kotlin compilation settings, including compiler plugins and test dependencies. The importer also recognizes major Java frameworks such as Spring Boot, Quarkus, and Micronaut, extracting their specific configurations. Additionally, it now supports Android projects by capturing essential build parameters like namespace, SDK versions, and application ID. These changes ensure that the generated Mill build files more accurately reflect the structure and dependencies of the original Gradle projects.
init · high confidence
Example demonstrates bundling Python modules with external dependencies into a self-contained executable
The \4-python-libs-bundle\ example now shows how to extend \PythonModule\ to include external PyPI dependencies via a new \pythonDeps\ task and aggregate them transitively. It introduces a \bundle\ task that uses \pex\ and \uv\ to package the module, its dependencies, and a portable Python interpreter into a single self-contained PEX SCIE executable, allowing deployment without requiring a system Python installation.
example/extending/python/4-python-libs-bundle · high confidence
Example demonstrating JVM index version override
Added a new example in the CLI header section that illustrates how to override the default JVM index version using the \mill-jvm-index-version\ build header key. This example shows how specifying an older index version (0.0.4-88-f9ba3d) causes the resolved JDK version to be downgraded to match the index's available versions, rather than using the latest point release.
example/cli/header/4-jvm-index-version · high confidence
Example demonstrating JVM version configuration via Mill YAML build files
Added a new example under \example/cli/header/3-jvm-version-yaml\ that shows how to configure the JVM version using a \build.mill.yaml\ file. The example sets the JVM to \temurin:17.0.6\ and extends \JavaModule\, providing a simple Java application that prints the active Java version to verify the configuration.
example/cli/header/3-jvm-version-yaml · high confidence
Example demonstrating JVM version specification in Mill scripts
Added an example in the scalalib script section showing how to specify a custom JVM version (11.0.21) and compatible Scala version (3.7.4) via script headers in a Mill build.
example/scalalib/script/12-jvm-version · high confidence
Example demonstrating task overriding in Python modules
Added a new example build file showing how to override tasks like \sources\, \typeCheck\, and \run\ in a \PythonModule\, including patterns for replacing source folders versus adding generated sources using \super\.
example/pythonlib/module/3-override-tasks · high confidence
Example module 12 demonstrates DefaultTaskModule usage
A new example module at example/fundamentals/modules/12-default-tasks has been added to illustrate how to use DefaultTaskModule. This module shows how to define a default task (bar) that runs automatically when the module is invoked without arguments, while still allowing explicit invocation of other tasks like qux.
example/fundamentals/modules/12-default-tasks · high confidence
Example of aliasing external Mill modules
Added an example demonstrating how to define shorthand aliases for external Mill modules, such as mapping a long path like \mill.javalib.palantirformat.PalantirFormatModule\ to a simpler name (\myAutoformat\) for easier invocation.
example/fundamentals/modules/10-external-module-aliases · high confidence
Example of build header metadata in build.mill.yaml
Added an example project demonstrating how to configure build header metadata using the \mill-build\ key in a \build.mill.yaml\ file, specifically showing the inclusion of \scalacOptions\.
example/cli/header/2-tasks-yaml · high confidence
Example of custom Python build logic with generated resources
The example at example/pythonlib/basic/2-custom-build-logic now demonstrates how to override the resources task in a PythonModule to include a generated file. Specifically, it defines a custom lineCount task that counts lines in Python source files and uses that value to generate a line-count.txt resource file, illustrating how custom build tasks can be integrated with Python module resources.
example/pythonlib/basic/2-custom-build-logic · high confidence
Example of customizing single-file script modules with a custom base class
Added an example demonstrating how to create a custom single-file script module by inheriting from a user-defined class (LineCountScalaModule) instead of the default built-in module. This allows users to centralize custom behavior, such as generating and accessing resource files, across multiple scripts via the extends directive in the build header.
example/scalalib/script/10-custom-class · high confidence
Example of declarative modules depending on programmable modules
Added a new example demonstrating how a declarative module (defined in \package.mill.yaml\) can depend on programmable modules (defined in \build.mill\), including cross-modules. The example shows a \foo\ module depending on \bar\ and \qux\[1\]\, using Scala 3.8.2 and mainargs 0.7.8, illustrating the interoperability between declarative and programmatic build definitions.
example/scalalib/module/18-programmable-module-deps · high confidence
Example of invoking overridden tasks via \`.super\` in Mill
Added a new example file (1-super/build.mill) demonstrating how to use the \.super\ syntax in Mill to invoke overridden tasks. The example shows how to call the parent implementation of a task (like \compile\) either by using the \.super\ suffix directly or by specifying the class name (e.g., \.super.javalib.JavaModule\) to explicitly select the overridden task from a specific superclass.
example/cli/query · high confidence
Expanded example library with new linting, web, and module demos
The examples directory now includes new demonstration projects for Java, Kotlin, and Scala. Java examples cover linting with Error Prone, Checkstyle, Palantir, Spotless, and PMD. Kotlin examples demonstrate linting with Detekt, ktlint, ktfmt, and Spotless, as well as Kotlin/JS web applications (including a shared-code Todo app) and a Micronaut backend. Scala examples add a custom trait module, programmable module dependencies, and Scala.js web applications (including a shared-code Todo app).
(repo-wide) · high confidence
Expanded single-file script examples and capabilities
The \example/scalalib/script\ directory now includes a comprehensive suite of new examples demonstrating advanced single-file script features. Users can now see how to scrape HTML (1-html-scraper), consume JSON APIs (2-json-api-client), run web servers (3-web-server), query databases (4-database), generate static sites (5-static-site), and package scripts into assemblies or GraalVM native images (6-packaging). The examples also cover script-to-script dependencies (7-script-deps), relative and workspace-relative module dependencies (8-relative-deps), and dependencies on programmable modules (9-programmable-module-deps). Additionally, new examples illustrate custom script module classes (10-custom-class), classpath resource inclusion (11-resources), JVM version customization (12-jvm-version), and the use of the \Raw\ module to disable bundled libraries (13-raw). Also in this area: Paths in cache files now use symbolic root placeholders.
example/scalalib/script/11-resources · high confidence
Expanded web development examples with Scala.js and WebAssembly support
The \example/scalalib/web\ directory now includes new build configurations for compiling Scala to WebAssembly via Scala.js 1.20.2, alongside updated examples for Scala.js modules, shared client-server code, and cross-version/platform publishing. These additions demonstrate modern web development patterns using Scala 3.8.2, including cache-busting strategies and integration with frameworks like Cask and http4s.
example/scalalib/web · high confidence
Experimental Python support via uv
Mill now includes an experimental Python toolchain in the \libs/pythonlib\ module, powered by the \uv\ package manager. This introduces \PythonModule\ for managing virtual environments and dependencies, \BarePythonModule\ for projects without a \src/\ directory, and dedicated modules for testing (\TestModule\ with \unittest\ and \pytest\ support), linting/formatting (\RuffModule\), and code coverage (\CoverageModule\).
libs/pythonlib · high confidence
Experimental pre-compiled modules for build definitions
Users can now define build modules using \package.mill.yaml\ files that extend a pre-compiled Scala class (a subclass of \mill.api.PrecompiledModule\) by setting \mill-experimental-precompiled-module: true\. This allows build logic, such as the \LineCountJavaModule\ example, to be compiled once and reused across multiple modules (e.g., \foo\ and \bar\) without code generation, enabling shared configuration and dependencies like \moduleDeps\ and \mvnDeps\ to be declared declaratively. The feature is currently experimental and requires the specific configuration key to be enabled.
(repo-wide) · high confidence
Extends TypeScript example with transitive npm dependencies and bundling
The TypeScript module example in \example/extending/typescript/4-npm-deps-bundle\ is updated to support transitive npm dependencies and code bundling. A new \npmDeps\ task allows modules to declare specific npm packages, which are aggregated via \transitiveNpmDeps\ and installed during \npmInstall\. Additionally, the example now includes an \esbuild\-based \bundle\ task that combines the compiled TypeScript modules into a single \bundle.js\ file, and refactors the run logic into a shared \prepareRun\ task to avoid duplication between \run\ and \bundle\.
example/extending/typescript/4-npm-deps-bundle · high confidence
First-class Python multi-module example with dependency management
The example at example/pythonlib/basic/3-multi-module now demonstrates a multi-module Python build using Mill's first-class Python support. It shows how to define multiple modules (foo and bar) with inter-module dependencies via moduleDeps, configure per-module Python dependencies (such as Jinja2), and run tests using Python's unittest framework. The example also illustrates best practices like using traits to share common module configuration and leveraging Mill's task query syntax for running tasks across multiple modules.
example/pythonlib/basic/3-multi-module · high confidence
Incomplete Maven migration example for fastexcel
Added an example demonstrating the limitations of automatic migration from Maven to Mill, specifically showing how \mill init\ fails to handle custom Maven profiles (such as those for JPMS) and results in compilation errors due to missing module dependencies.
example/migrating/javalib/2-maven-incomplete · high confidence
Initial Groovy build support for Mill
Adds a new \groovylib\ module that enables building Groovy projects within Mill. This includes \GroovyModule\ for compiling Groovy sources (with support for mixed Java/Groovy projects, static compilation, and preview features), \GroovyMavenModule\ for standard Maven directory layouts, and \JavaMavenModuleWithGroovyTests\ for Java projects that use Groovy for tests. The implementation supports Groovy versions 4.x, 5.x, and 6.x (alpha), including integration with Spock and JUnit 5 for testing.
libs/groovylib · high confidence
Initial Groovy library support with declarative and programmatic build examples
This change introduces the \groovylib\ module to Mill, enabling users to build and test Groovy projects. It provides examples for setting up Groovy builds using both declarative YAML configuration (e.g., \build.mill.yaml\) and programmatic Scala build definitions. The examples cover basic script execution, module dependencies, Maven-compatible folder layouts for migration, and testing with JUnit 5 and Spock. Also in this area: Paths in cache files now use symbolic root placeholders.
example/groovylib · high confidence
Introduce Artifactory publishing plugin
Adds a new \mill.contrib.artifactory\ plugin that enables publishing artifacts to JFrog Artifactory repositories. Users can extend \ArtifactoryPublishModule\ to define release and snapshot URIs, then use the \publishArtifactory\ command to deploy artifacts. The plugin supports authentication via \ARTIFACTORY\_USERNAME\ and \ARTIFACTORY\_PASSWORD\ environment variables, explicit credentials passed as arguments, or credentials configured in Coursier credential files.
contrib/artifactory · high confidence
Introduce BSP server installation logic and configuration constants
This change adds the core implementation for the Mill BSP (Build Server Protocol) server installation process. The new \BSP.scala\ module provides an \install\ method that generates and writes a \mill-bsp.json\ connection file into the \.bsp\ directory, allowing IDE clients to connect to the Mill build server. The configuration includes the server name, supported languages (Java, Scala, Kotlin), BSP protocol version, and command-line arguments derived from the installation context (such as job count and debug mode). Supporting constants are centralized in \Constants.scala\ to define paths, versions, and server metadata.
runner/bsp · high confidence
Introduce CodeSig module with call graph analysis and JSON logging
The \runner/codesig\ area now includes the \CodeSig\ object, which provides a \compute\ method to analyze class files and generate a call graph, and a \Logger\ class that writes analysis results (such as local summaries, external summaries, and resolved method calls) as JSON files using uPickle. This adds the core infrastructure for code signature and call graph analysis within the Mill runner.
runner/codesig · high confidence
Introduce Flyway migration support for Mill builds
This change adds a new \contrib/flyway\ module that enables users to configure and run Flyway database migrations directly from their Mill build files. The \FlywayModule\ trait provides tasks for common operations such as \flywayMigrate\, \flywayClean\, \flywayBaseline\, and \flywayInfo\. Users can configure the database connection via \flywayUrl\, \flywayUser\, and \flywayPassword\, specify JDBC drivers with \flywayDriverDeps\, and include external database plugins (e.g., for PostgreSQL or MySQL) via \flywayPluginDeps\. The module also supports custom configuration through \flywayExtraConfig\ and placeholder substitution via \flywayPlaceholders\, with migration files automatically detected in \db/migration\ within resource folders.
contrib/flyway · high confidence
Introduce Play Framework integration module
Adds a new \mill-contrib-playlib\ module that provides first-class support for building Play Framework applications in Mill. It includes \PlayModule\ and \PlayApiModule\ traits that configure the default Play directory layout, integrate the Play routes compiler, and automatically resolve core dependencies (Play, Guice, Server, Logback). The module also supports the Twirl template engine, static asset and WebJar handling, and allows users to select between Akka HTTP or Pekko HTTP servers based on the Play version.
contrib/playlib · high confidence
Introduce RpcThrowable for serializing RPC transport failures
Added RpcThrowable, a new serializable case class in the RPC library that captures exception details (class name, message, and stack trace) for transmission over the RPC transport. This enables proper serialization and deserialization of failure information between client and server, ensuring that exception chains are preserved and communicated accurately during remote procedure calls.
rpc · high confidence
Introduce Scala Native support for Mill
Mill now includes a new \scalanativelib\ module that enables building and running Scala Native projects. This addition provides the \ScalaNativeModule\ trait for configuring the Scala Native toolchain (including Clang discovery, GC selection, and linking options), a dedicated worker implementation to handle native compilation and linking, and support for running tests via the uTest framework. Users can now define Scala Native modules, compile them to native binaries, and execute them or run their test suites directly within Mill.
libs/scalanativelib · high confidence
Introduce Scoverage 2.x support with coverage validation and Cobertura reports
The \contrib/scoverage\ module has been updated to support Scoverage 2.x, dropping support for Scoverage 1.x and requiring Scala 3.2+ for Scala 3 projects. This change introduces new build-time coverage validation capabilities via the \validateCoverageMinimums\ task, allowing users to enforce \branchCoverageMin\ and \statementCoverageMin\ thresholds that fail the build if not met. Additionally, a new \xmlCoberturaReport\ task (and \xmlCoberturaReportAll\ for multi-module projects) has been added to generate Cobertura-compatible XML reports, alongside the existing HTML, XML, and console report options.
contrib/scoverage · high confidence
Introduce core API daemon module for shared types
A new \core/api/daemon\ module has been added to house the core data types shared between Mill's internal code and user-land build scripts. This module, named \mill.api.daemon\, is designed to have minimal dependencies to ensure compatibility between the internal and user codebases, and it includes build information for SemanticDB versions along with binary compatibility filters for internal BSP APIs.
core/api/daemon · high confidence
Introduce dedicated BSP worker module for protocol handling
Mill now includes a new \runner/bsp/worker\ module that centralizes the BSP server implementation. This change adds specialized components for managing compilation diagnostics (\BspCompileProblemReporter\), test execution reporting (\BspTestReporter\), and task progress logging (\BspLogger\). It also introduces client-specific handling for IntelliJ IDEA via \ClientType\ and implements the full suite of BSP protocol endpoints (\EndpointsScala\, \EndpointsJvm\, \EndpointsJava\) along with the core server infrastructure (\MillBuildServer\, \BspWorkerImpl\).
runner/bsp/worker · high confidence
Introduce dedicated Bash and Zsh tab-completion support
Mill now includes a new \libs/tabcomplete\ module that provides native tab-completion for Bash and Zsh shells. This feature adds shell-specific completion scripts (\complete.sh\) and Scala logic (\TabCompleteModule\) to automatically suggest tasks, flags, modules, and file paths as you type, significantly improving the interactive command-line experience.
libs/tabcomplete · high confidence
Introduce experimental JavaScript and TypeScript build support
Adds a new \javascriptlib\ module to Mill, providing an experimental toolchain for building JavaScript and TypeScript applications. This includes a base \TypeScriptModule\ for compilation and bundling, a \ReactScriptsModule\ for creating React applications using \create-react-app\, and a \RsWithServeModule\ for serving static HTML pages. The library also integrates Jest for testing, supports Istanbul/nyc for code coverage, and includes a \PublishModule\ to generate \package.json\ files and publish to npm.
libs/javascriptlib · high confidence
Introduce selective execution implementation
Adds the core implementation for selective execution in Mill, enabling the build system to track task dependencies and compute downstream changes based on input hashes, code signatures, and build overrides. This allows for more efficient builds by re-evaluating only the tasks affected by recent changes rather than running the entire graph.
eval · high confidence
Introduce standalone Graphviz visualization worker
Mill now includes a dedicated \libs/graphviz\ module that provides a standalone worker for rendering task dependency graphs. This new component uses the Javet library to execute Graphviz JavaScript engines within the JVM, allowing users to generate visualizations (DOT, SVG, PNG, etc.) of build graphs without requiring external system dependencies like a local Graphviz installation. The implementation includes a \VisualizeWorkerMain\ entry point that processes JSON payloads of task dependencies and renders them, along with comprehensive tests covering transitive reduction and error handling for missing font configurations.
libs/graphviz · high confidence
Introduce test discovery model for Zinc-based test running
The testrunner now supports discovering test classes via Zinc. A new \Model.scala\ file defines the \TestArgs\ data structure, which includes a \discoveredTestClasses\ field and \globSelectors\ logic to handle how test classes are located and executed, enabling users to leverage Zinc for test discovery rather than relying solely on explicit class lists.
testrunner · high confidence
New Android build modules and tooling libraries
This change introduces the \mill.androidlib\ module, providing a complete build system for Android applications and libraries. It adds support for building Android Apps (APKs and App Bundles) and Libraries (AARs) for both Scala and Kotlin, including integration with Jetpack Compose, ViewBinding, and DataBinding. The update also includes new utility modules for Hilt dependency injection transformation, keystore and certificate management, and standardized ProGuard rules.
libs/androidlib · high confidence
New BuildCtx API and Windows environment case-insensitivity
Mill introduces a new \BuildCtx\ object in the core API to provide global build-time context, including a reliable \workspaceRoot\ accessor (preferred over \os.pwd\ for BSP/LSP scenarios), a \rootModule\ handle for traversing the module tree, and access to global \millRepositories\. Additionally, environment variable lookups via \TaskCtx.env\ are now case-insensitive on Windows to match platform conventions, and new JSON formatters are added for \os.Path\, \Regex\, and other types to support daemon serialization.
core/api/java11/src/mill/api · high confidence
New Docker build support via Jib and Dockerfile backends
Users can now build container images directly from Mill projects using the \mill-contrib-docker\ module. The default backend is Google Jib, which builds optimized images without requiring a local Docker daemon, while a \ClassicDockerConfig\ is available for traditional Dockerfile-based builds. The module supports configuring image tags, base images, JVM options, environment variables, exposed ports, and labels, and includes credential helpers for registries (including Google ADC and Docker config).
contrib/docker · high confidence
New GitLab plugin for publishing artifacts
Added a new GitLab plugin that enables publishing artifacts to GitLab's Maven repository. The implementation includes authentication logic supporting Personal Access Tokens, Deploy Tokens, and CI Job Tokens, which can be sourced from environment variables, system properties, or local files.
contrib/gitlab/src · high confidence
New Java linting and formatting examples
Added a series of example modules in \example/javalib/linting\ demonstrating Mill's Java linting and formatting capabilities. These include configurations for ErrorProne (1-linting, 2-error-prone), Checkstyle (3-checkstyle), Palantir Java Format (4-palantirformat), Spotless (5-spotless), Spotless ratchet for incremental formatting (6-spotless-ratchet), and PMD (7-pmd). Each example provides a \build.mill\ and \build.mill.yaml\ showing how to extend the respective Mill modules (e.g., \ErrorProneModule\, \CheckstyleModule\, \SpotlessModule\) and configure tools like Checkstyle 9.3 and PMD 7.15.0.
example/javalib/linting · high confidence
New Java scripting examples for web, data, and packaging
The example/javalib/script directory now includes a comprehensive set of Java scripting examples demonstrating key capabilities: an HTML scraper using Jsoup, a JSON API client using Jackson and Unirest, a Spring Boot web server, a JOOQ-based SQLite database query, a Markdown-to-HTML static site generator, GraalVM native image packaging, and various module dependency patterns (including relative and programmable deps).
example/javalib/script · high confidence
New Java-based Android example with instrumented testing
The \1-hello-world\ example now provides a complete Java Android application setup, including a \MainActivity\ that displays a styled text view, resource definitions, and a Mill build configuration (\build.mill\) that manages the Android SDK and APK signing. It introduces local unit tests and instrumented tests (running on an emulator) to verify application logic and context, demonstrating how to configure and run Android-specific test suites within the Mill build system.
example/androidlib/java/1-hello-world · high confidence
New Java-based Android library and app example
Added a new example demonstrating an Android library module written in Java (\sumlib-java\) and a corresponding Android app (\Calculator\). The example includes the library source code, unit tests, and a build configuration using Mill's \AndroidLibModule\ and \AndroidAppModule\, illustrating how to build, test, and locally publish a Java-based Android AAR artifact.
example/androidlib/java/4-sum-lib-java · high confidence
New JavaScript library example using TypeScriptModule
Added a new example demonstrating how to configure a JavaScript library build using Mill's TypeScriptModule. This example shows how to define a module name, specify npm dependencies (such as immutable), and run tests using Jest, providing a concrete reference for users setting up TypeScript-based JavaScript libraries.
example/javascriptlib/module/7-root-module · high confidence
New Jetty web server example
Added a new example in the javalib/web/2-hello-jetty directory that demonstrates how to set up a simple Jetty web server. The example includes a Java handler that responds to HTTP requests at the root path with a 'Hello, World!' message, along with the necessary build configuration files (build.mill and build.mill.yaml) and application properties to run the server on a configurable port.
example/javalib/web/2-hello-jetty · high confidence
New Kotlin Android example with instrumented testing and ProGuard configuration
The \1-hello-kotlin\ example now includes a complete Android application structure, featuring a \MainActivity\ that displays a text view, alongside both local unit tests and instrumented tests (running on an emulator) to verify application logic. The example also introduces ProGuard configuration files (\proguard-rules.pro\ and \test-proguard-rules.pro\) to manage code shrinking and keep necessary annotations for testing frameworks, demonstrating how to configure build optimizations and test integrity in a Mill-based Android project.
example/androidlib/kotlin/1-hello-kotlin · high confidence
New Kotlin Android library and app example
Added a new example project demonstrating an Android library module written in Kotlin. The example includes a library module (\lib\) that builds an AAR artifact and an application module (\app\) that consumes it, along with corresponding unit tests and build configuration using Mill's Android and Kotlin modules.
example/androidlib/kotlin/4-sum-lib-kotlin · high confidence
New Kotlin TodoMVC example using Ktor, Thymeleaf, and Exposed
Added a new example application in \example/kotlinlib/web/3-todo-ktor\ that implements the TodoMVC standard using Kotlin and Ktor. This example demonstrates serving HTML templates via Thymeleaf, managing static assets with Webjars, and persisting data using the Exposed library with an H2 in-memory database. It includes the full application structure, including build configuration, routing, repository implementation, and test setup.
example/kotlinlib/web/3-todo-ktor · high confidence
New Kotlin example for reading classpath resources
Added a new Kotlin example file (Foo.kt) in the 7-resources module that demonstrates how to read a text file (file.txt) from the classpath using the class loader and convert it to a UTF-8 string.
example/kotlinlib/module/7-resources/foo · high confidence
New Kotlin library example demonstrating YAML-based configuration
Added a new example module (\1-basic-config\) that showcases configuring a Kotlin library using the \.mill.yaml\ format. The example demonstrates setting the Kotlin version, adding Maven dependencies, specifying a main class, pinning a JVM version, and configuring custom source and resource directories using the \!append\ tag. It also illustrates passing custom JVM arguments and environment variables to the forked process.
example/kotlinlib/module/1-basic-config · high confidence
New Kotlin linting and formatting examples
Added example configurations for integrating static analysis and code formatting into Kotlin Mill builds. The new examples demonstrate how to use Detekt for linting (including nested block depth checks), KtLint for style checking and auto-formatting, KtFmt for code formatting, and Spotless for applying multiple formatters (ScalaFmt, GoogleJavaFormat, Ktfmt) with license headers across different file types. Additionally, an example for Kover is included to show how to generate code coverage reports in HTML format.
example/kotlinlib/linting · high confidence
New Kotlin module example demonstrating resource handling and test configuration
Added a new example module (\example/kotlinlib/module/7-resources\) that demonstrates how to configure a Kotlin library with JUnit 5 tests, including the use of \mvnDeps\ for dependencies like Kotest, custom fork environment variables for test resources, and the inclusion of resource files in both main and test source sets.
example/kotlinlib/module/7-resources · high confidence
New Kotlin module examples for custom tasks and source generation
Added two new example modules under \example/kotlinlib/module\ to demonstrate advanced build capabilities. The \5-custom-tasks\ module shows how to define custom Mill tasks, including generating source files from Maven dependencies and passing computed values (like line counts) as JVM arguments. The \6-generated-sources\ module provides a simpler example of generating Kotlin source files during the build process.
example/kotlinlib/module/5-custom-tasks, example/kotlinlib/module/6-generated-sources · high confidence
New Kotlin publishing examples for Mill
Added example configurations in the \example/kotlinlib/publishing\ directory demonstrating how to publish Kotlin libraries using Mill. These examples cover basic YAML-based publishing (\1-publishing-yaml\), VCS-based versioning (\2-vcs-version\), and programmatic build definition (\3-publishing\), all configured to use Kotlin version 2.2.20.
example/kotlinlib/publishing · high confidence
New Kotlin scripting examples for web, database, and packaging
The example/kotlinlib/script directory now includes a comprehensive set of new Kotlin scripting examples demonstrating practical use cases. These include an HTML scraper using Jsoup, a JSON API client, a Ktor-based web server, a database example using JetBrains Exposed with SQLite, a static site generator, and scripts for packaging (including GraalVM native images). The examples also cover advanced scripting features such as custom module dependencies, relative path resolution for module imports, resource file handling, and specifying JVM versions.
example/kotlinlib/script · high confidence
New Kotlin support library for Mill builds
This change introduces the \mill.kotlinlib\ module, providing first-class support for compiling Kotlin projects within Mill. It includes a core \KotlinModule\ for JVM and JS targets, along with experimental integrations for KSP (Kotlin Symbol Processing) and KAPT (annotation processing), as well as tools for code formatting (Ktfmt), linting (Detekt), and coverage (Kover). The library also handles IDE integration for IntelliJ IDEA and supports Maven-compatible directory layouts.
libs/kotlinlib · high confidence
New Kotlin web application examples for Ktor and Spring Boot
Added new example projects in the \example/kotlinlib/web\ directory demonstrating Kotlin web development with Mill. The \2-hello-ktor\ example shows a basic Ktor server setup, while \5-webapp-kotlinjs\ and \6-webapp-kotlinjs-shared\ provide progressively more complex Ktor applications with Kotlin/JS frontends, including shared code between client and server. Additionally, \7-hello-spring-boot\ demonstrates a simple Spring Boot web application. All examples use Kotlin 2.2.20 and Ktor 2.3.12 (where applicable) and are configured to respect the \PORT\ environment variable.
(repo-wide) · high confidence
New Mill Fundamentals examples for OS-Lib, uPickle, Requests-Scala, and MainArgs
Added four new build.mill example files in the fundamentals/libraries section that demonstrate how to use Mill's bundled libraries: OS-Lib for sandboxed file system and subprocess operations, uPickle for JSON serialization of task outputs, Requests-Scala for downloading and caching remote files, and MainArgs for parsing command-line arguments in Task.Command definitions.
example/fundamentals/libraries/4-mainargs · high confidence
New Mill Fundamentals examples for OS-Lib, uPickle, Requests-Scala, and MainArgs
Added four new build.mill example files in the fundamentals/libraries section that demonstrate how to use Mill's bundled libraries: OS-Lib for sandboxed file system and subprocess operations, uPickle for JSON serialization of task outputs, Requests-Scala for downloading and caching remote files, and MainArgs for parsing command-line arguments in Task.Command definitions. Also in this area: Paths in cache files now use symbolic root placeholders.
example/fundamentals/libraries/2-upickle · high confidence
New Mill Fundamentals examples for cross-building
Added a new set of documentation examples in \example/fundamentals/cross\ that demonstrate Mill's cross-building capabilities. These examples cover basic cross-module definitions, customizing source paths, referencing cross-modules from external tasks, cross-dependencies between modules, multiple cross-axes, extending cross modules, nested cross modules, custom resolvers, and dynamic cross-module discovery based on filesystem changes.
example/fundamentals/cross · high confidence
New Mill daemon client library with robust file tailing and locking
This change introduces a new \libs/daemon/client\ module that provides the Mill-specific TCP client implementation. It includes a \FileToStreamTailer\ that safely tails log files, specifically handling cases where the file is missing, appears later, or lacks a final newline, which prevents excessive \NoSuchFileException\ errors. The module also adds a locking subsystem (\mill.client.lock\) supporting both file-based and in-memory locks, along with utilities for reading option files and debugging I/O streams.
libs/daemon · high confidence
New Mill fundamentals examples for OS-Lib sandboxing and backticked module names
Added two new example modules to the Mill fundamentals documentation: one demonstrating how Mill uses OS-Lib to sandbox working directories (preventing file collisions between tasks), and another showing how to define and invoke modules and tasks with hyphenated names using backticks. These examples illustrate specific Mill behaviors regarding file system operations and naming conventions.
example/fundamentals/libraries/1-oslib, example/fundamentals/modules/9-backticked-names · high confidence
New Mill publishing and API-compatibility examples
Added example projects demonstrating Mill's publishing and API-compatibility features. The new \1-publishing-yaml\ example shows how to configure publishing metadata using a declarative YAML file, while \3-publishing\ provides the equivalent Scala build definition. The \2-vcs-version\ example illustrates integrating the \VcsVersionModule\ for versioning. Additionally, \4-revapi\ demonstrates using the \RevapiModule\ to detect binary incompatibilities, including configuration for Revapi's text reporter and logback logging.
example/javalib/publishing · high confidence
New Mill publishing examples for Scala 3.8.2
Added three new example configurations in the publishing documentation to demonstrate how to set up a Mill project for publishing to Maven Central or local repositories. The examples cover basic publishing metadata, automatic versioning via Git tags, and programmatic build configuration, all updated to use Scala 3.8.2.
example/scalalib/publishing · high confidence
New ProGuard contrib plugin for Java module shrinking and obfuscation
The \contrib/proguard\ module is now available, allowing Mill users to integrate ProGuard for shrinking, optimizing, obfuscating, and preverifying Java class files. By mixing in the \Proguard\ trait to a \JavaModule\, the build automatically runs ProGuard on the output of the \assembly\ task, producing a processed jar in the \dest/\ folder. The plugin provides sensible defaults for all four ProGuard steps and allows configuration via task overrides such as \proguardVersion\, \shrink\, \optimize\, \obfuscate\, \preverify\, \entryPoint\, and \additionalOptions\. It also handles Java 9+ runtime JAR extraction and resolves ProGuard dependencies via Maven.
contrib/proguard · high confidence
New Python coverage example module
An example module has been added to demonstrate how to integrate code coverage analysis for Python projects using Mill. By extending the \CoverageTests\ trait in a test module, users can generate coverage reports via the \coverageReport\ task, which supports standard \coverage.py\ arguments such as \--fail-under\ to enforce minimum coverage thresholds. The example also illustrates the availability of various report formats, including HTML, JSON, XML, and Lcov.
example/pythonlib/linting/3-coverage · high confidence
New Python dependency management examples
Added a series of example modules in the \example/pythonlib/dependencies\ directory that demonstrate how to manage Python dependencies using Mill's integration with uv. These examples cover declaring dependencies via \pythonDeps\ (including version constraints and direct wheel URLs), reading from \requirements.txt\ files, handling unmanaged wheels from local directories or arbitrary URLs, configuring custom package indexes (including private repositories with authentication), debugging dependency installation arguments, and linking local Python projects via \pythonProjectDeps\.
example/pythonlib/dependencies · high confidence
New Python example using uv for virtual environment management
Added a new introductory example (\1-hello-python\) that demonstrates how to extend Mill with Python support by leveraging \uv\ to create and manage a Python virtual environment. The example defines tasks to specify the Python version, locate the interpreter, run type checking with \ty\, and execute a main script, providing a concrete starting point for users building custom Python modules.
example/extending/python/1-hello-python · high confidence
New Python module example using uv
Added a new build example in \example/extending/python/2-python-modules\ that demonstrates how to define and reuse a \PythonModule\ trait for managing Python scripts. The example uses the \uv\ toolchain (via \UvModule\) to create virtual environments, run type checking with \ty\, and execute scripts, showing how to structure multiple independent Python modules within a single Mill build.
example/extending/python/2-python-modules · high confidence
New Python module examples for common configuration and PEX bundling
Added two new example modules under \example/pythonlib/module/\ to demonstrate Python build configurations. The \1-common-config\ example shows how to customize a \PythonModule\ by specifying the \uv\ and \python\ versions, managing third-party dependencies, defining custom source and resource directories, generating sources at build time, and passing environment variables or Python options. The \6-pex-config\ example demonstrates creating a self-contained PEX SCIE bundle, including configuration for bundle compression, compilation, and fixed arguments.
example/pythonlib/module/1-common-config · high confidence
New RPC library for client-server communication
Added a new \libs/rpc\ module providing the core infrastructure for Mill's daemon and client-server communication. This includes \MillRpcClient\ and \MillRpcServer\ for managing RPC sessions, \MillRpcWireTransport\ for serializing messages via upickle, and dedicated \RpcLogger\ and \RpcConsole\ components to stream logs and console output from the server to the client. The \RpcConsole\ implementation features a \Utf8OutputStream\ that buffers incomplete UTF-8 byte sequences to prevent character corruption when output is split across network packets.
libs/rpc · high confidence
New SBOM generation plugin for JVM projects
A new contrib module is introduced that generates Software Bill of Materials (SBOM) in CycloneDX JSON format for JVM-based Mill projects. Users can extend the \CycloneDXJavaModule\ trait to produce an \sbomJsonFile\ task containing dependency and license information. The implementation currently supports only the JVM ecosystem and the CycloneDX JSON format, and includes optional integration for uploading the generated SBOM to Dependency Track.
contrib/sbom · high confidence
New Scala Native API definitions for build configuration and debugging
The \libs/scalanativelib\ module now includes \ScalaNativeApi.scala\, which defines the core data structures and serialization formats for Scala Native build configurations. This adds support for configuring Link-Time Optimization (LTO) modes (None, Thin, Full), Release modes (including the new ReleaseSize for optimized binary size), Build Targets (Application, Dynamic Library, Static Library), and Native Log Levels. Crucially, it introduces \SourceLevelDebuggingConfig\, allowing users to enable source-level debugging with options to generate function source positions and local variable metadata, which aids in debugging with tools like LLDB.
scalanativelib · high confidence
New Scala.js configuration module with advanced linker and Playwright support
Mill introduces a new \ScalaJSConfigModule\ in the \libs/scalajslib/config\ area that allows users to fully customize the Scala.js linker configuration, including ES version targets (up to ES2024), WebAssembly backend support with JavaScript Promise Integration (JSPI), and custom output directories. This module also adds support for Playwright as a test execution environment alongside existing options like Node.js, JsDom, and Selenium, and includes version guards to ensure compatibility between Scala.js versions and features like ES2022+ or WebAssembly.
libs/scalajslib · high confidence
New Scoverage report worker API with coverage validation
The Scoverage module introduces a new Java API interface, ScoverageReportWorkerApi2, which defines the contract for generating coverage reports and validating coverage thresholds. This interface supports multiple report formats including Console, HTML, XML, and Cobertura XML, and adds a new validateCoverageMinimums method that allows users to enforce minimum statement and branch coverage levels at build time. The API also includes a Logger interface for structured logging and ensures proper resource management by extending AutoCloseable.
contrib/scoverage/api · high confidence
New TypeScript and ESLint/Prettier linting modules
The \javascriptlib\ module now includes \TypeScriptModule\ and \TsLintModule\, providing built-in support for TypeScript compilation and code formatting. \TypeScriptModule\ manages dependencies for TypeScript, esbuild, and related tools, handling source copying and dependency resolution. \TsLintModule\ automatically detects whether a project uses ESLint or Prettier based on configuration files (e.g., \eslint.config.mjs\, \.prettierrc\) and exposes commands to check and reformat code using the detected tool, installing necessary npm dependencies on demand.
javascriptlib · high confidence
New TypeScript build examples for Mill
Added two new example modules under the JavaScript/TypeScript library (\mill.javascriptlib\) to demonstrate configuring TypeScript compilation and bundling. The \4-compilation-execution-flags\ example shows how to set specific compiler options (such as \skipLibCheck\, \module\, and \target\) and define Node.js execution flags (like \inspect\ and \max-old-space-size\) for a \TypeScriptModule\. The \6-executable-config\ example demonstrates how to configure bundle flags, including setting the platform to Node, specifying entry points, and enabling minification, resulting in a bundled output file.
example/javascriptlib/module/4-compilation-execution-flags, example/javascriptlib/module/6-executable-config · high confidence
New TypeScript integration example for Mill builds
Added a new example demonstrating how to integrate TypeScript compilation into a Mill build from first principles. The example includes a \build.mill\ script that defines tasks for installing TypeScript via npm, compiling \.ts\ source files to JavaScript, and running the resulting Node.js application, along with a sample \hello.ts\ source file.
example/extending/typescript/1-hello-typescript · high confidence
New TypeScript module example demonstrating reusable build logic
Added a new example in \example/extending/typescript/2-typescript-modules\ that shows how to encapsulate a TypeScript build pipeline into a reusable \TypeScriptModule\. The example defines a module trait with tasks for installing dependencies (TypeScript 5.6.3 and @types/node 22.7.8), compiling sources, and running the output, and demonstrates instantiating this module multiple times (including nested modules) to build independent TypeScript projects.
example/extending/typescript/2-typescript-modules · high confidence
New UnidocModule example for combined Scaladoc generation
Added a new example (\example/scalalib/module/15-unidoc\) demonstrating the \UnidocModule\, which allows users to generate a combined Scaladoc site for a Scala module and all its transitive dependencies. The example shows how to configure the module with a custom document title, version, and source URL, and illustrates the usage of the \.unidocLocal\ and \.unidocSite\ tasks for generating browsable documentation.
example/scalalib/module/15-unidoc · high confidence
New VersionFile module for managing project versions
The contrib/versionfile module introduces a new VersionFileModule that automates version file management and Git operations. Users can now read, write, and bump version numbers (major, minor, patch) via tasks like setReleaseVersion, setNextVersion, and setVersion, with the module automatically handling file updates and generating Git commit messages. It also provides built-in Git tagging and pushing capabilities through the tag and push tasks, and exposes an exec task to run arbitrary Git processes, streamlining the release workflow.
contrib/versionfile · high confidence
New VersionFile module for managing semantic versioning
A new \VersionFile\ module has been added to the Mill contrib library, introducing a \Version\ trait with \Release\ and \Snapshot\ case classes to handle semantic versioning. This module provides utilities to parse version strings, convert between release and snapshot states, and bump version numbers by major, minor, or patch segments. It integrates with uPickle for serialization and mainargs for CLI argument parsing, enabling users to programmatically manage and manipulate version identifiers within their build scripts.
contrib/versionfile/src · high confidence
New \`mill.api.opt\` API for structured configuration data
A new \mill.api.opt\ package has been introduced to provide structured types for handling configuration data that includes paths. This API adds \Opt\, \OptGroup\, \Opts\, and \OptMap\ classes, along with an \opt\ string interpolation syntax, allowing users to define and manipulate option sequences that can contain both strings and \os.Path\ objects. The implementation includes JSON serialization support via \upickle\ and marks the API as experimental.
core/api/src/mill/api/opt · high confidence
New abstract Server implementation for Mill daemon connections
The Mill daemon now uses a new abstract \Server\ class in \libs/daemon/server/src/mill/server/Server.scala\ to manage client connections. This implementation binds to a random port, writes the port to a socket file, and handles concurrent client connections via separate threads. It includes logic for locking the daemon state, tracking active connections, writing daemon state files, and handling timeouts and process ID watching, providing a structured foundation for the daemon's client-server communication.
libs/daemon/server · high confidence
New and updated build examples for Java, Kotlin, JavaScript, Python, and Spring Boot
The examples directory now includes new executable build definitions and source code for several language ecosystems. Java examples now cover resource handling, Spring Boot integration, and backticked module names. Kotlin examples have been added for basic builds, modules, dependencies, testing, linting, packaging, publishing, scripts, and web applications. JavaScript/TypeScript examples demonstrate dependency management with repository configuration. Python examples cover basic builds, dependencies, linting, publishing, modules, web, and testing. Groovy examples are also introduced for basic builds and testing. The \package.mill\ build file has been restructured to organize these new cross-module examples under specific language libraries (javalib, kotlinlib, javascriptlib, pythonlib, groovylib) and other categories like fundamentals, depth, and extending.
example · high confidence
New basic Scala module example with YAML configuration and custom sources
Added a new example module demonstrating how to configure a Scala project using the \build.mill.yaml\ format. This example shows how to specify dependencies, set a main class, pin JVM versions, and configure compiler options. It also introduces the \!append\ tag for extending source and resource folders, and includes custom source and resource files to illustrate these configurations in action.
example/scalalib/module/1-basic-config · high confidence
New buildgen API and Gradle migration tooling
The \libs/init\ area introduces a new \buildgen\ API (ModuleSpec, PackageSpec, BuildGen) that serves as the shared foundation for generating Mill build files, supporting both Scala-based and YAML-based output formats. This API is utilized by the new Gradle migration tool (\MillGradleBuildGenMain\), which allows users to convert existing Gradle projects into Mill builds. The migration tool includes a Gradle export plugin to extract build models, handles version-agnostic Gradle API interactions, and supports declarative (YAML) or programmatic (Scala) generation, including specific handling for Android modules and Maven BOM dependencies.
libs/init · high confidence
New contrib package definition with plugin modules
The \contrib/package.mill\ file introduces the \build.contrib\ package, defining a \ContribModule\ base trait and specific plugin implementations including \testng\, \twirllib\, \playlib\, \scalapblib\, \scoverage\, \buildinfo\, \proguard\, \flyway\, and \docker\. This establishes the structural foundation for user-contributed Mill plugins, configuring their respective dependencies (such as TestNG, Play, Scoverage 2.0, Jib, and Flyway) and module relationships within the build system.
contrib · high confidence
New core/exec module for task graph planning and execution
Mill introduces a new \core/exec\ module that centralizes the logic for planning and executing the task graph after resolution. This change adds \PlanImpl\ for computing transitive dependencies and topological ordering, \ExecutionContexts\ for managing thread pools and async execution contexts, \TaskLockCoordinator\ for fine-grained task-level concurrency and locking, and \ExecutionLogs\ for writing dependency and invalidation trees. It also includes supporting utilities like \LazyDest\ for deferred destination folder creation and \TaskThreadContext\ for managing thread-local state such as working directory and logging streams during task execution.
core/exec · high confidence
New daemon client infrastructure with robust locking and config-aware restarts
The Mill daemon client now includes a new \ServerLauncher\ that manages long-lived background daemons by checking for configuration mismatches (Mill version, Java version, JVM options, and repositories) and automatically restarting the daemon when settings change. This change introduces a new \PidLock\ mechanism for cross-platform file locking that uses atomic file creation and PID/timestamp verification to safely handle race conditions, particularly on filesystems like Docker-on-mac that lack native file locking support. Additionally, a new \ServerLaunchOutputs\ class is added to capture and display daemon stdout and stderr for debugging purposes.
client · high confidence
New declarative YAML and single-file script examples for Scala builds
The \example/scalalib/basic\ directory now includes new examples demonstrating Mill's declarative YAML configuration (\build.mill.yaml\ and \package.mill.yaml\) and single-file script execution. Users can now see how to define modules using \mvnDeps\ (replacing the older \ivyDeps\), configure test suites with \utest\ 0.9.1, and run Scala scripts directly via \./mill Foo.scala\. These examples also cover multi-module setups, SBT-compatible folder layouts, and cross-compilation against Scala 2.13 and 3.3.6.
example/scalalib/basic · high confidence
New educational example for building custom Java modules in Mill
Added a new 'DiyJavaModule' example in the Mill Fundamentals documentation that demonstrates how to implement a minimal Java module from first principles. This example walks users through defining custom tasks for source collection, compilation, classpath management, and assembly, illustrating key concepts like module dependencies, task traversal, and incremental build caching without relying on Mill's built-in JavaModule.
example/fundamentals/modules/8-diy-java-modules · high confidence
New example demonstrating Java module configuration with custom sources and YAML settings
The 1-basic-config example now includes a \build.mill.yaml\ file that demonstrates configuring a Java module with custom Maven dependencies (Thymeleaf, SLF4J), a specific JVM version (11), custom source and resource directories using the \!append\ tag, and runtime options like fork arguments and environment variables. The example also provides corresponding Java source files (\Foo.java\, \Foo2.java\) and resource files to illustrate how these configurations are applied.
example/javalib/module/1-basic-config · high confidence
New example demonstrating Kotlin module assembly configuration
Added a new example in the \example/kotlinlib/packaging/3-assembly-config\ directory that illustrates how to configure assembly rules for Kotlin modules using Mill. The example defines two modules, \foo\ and \bar\, where \foo\ depends on \bar\ and specifies assembly rules to concatenate \application.conf\ files, include all \.conf\ files, exclude \.temp\ files, and relocate the \shapeless\ package. This serves as a reference for users configuring similar packaging behaviors in their own projects.
example/kotlinlib/packaging/3-assembly-config · high confidence
New example demonstrating Maven dependency imports via YAML header
Added a new example (\example/extending/imports/1-mvn-deps\) that shows how to import Maven dependencies into a Mill build using a YAML header comment syntax. The example configures \mill-jvm-version: 17\ and imports \thymeleaf\ and \slf4j-nop\ via \//\| mvnDeps\, demonstrating how to use these libraries at build time to generate HTML snippets as resources.
example/extending/imports/1-mvn-deps · high confidence
New example demonstrating Python compilation and execution flags
Added a new example module (\4-compilation-execution-flags\) that illustrates how to configure Python-specific build behaviors in Mill. The example shows how to pass interpreter flags via \pythonOptions\ (e.g., \-Wall\, \-Xdev\) and how to inject environment variables into the subprocess using \forkEnv\.
example/pythonlib/module/4-compilation-execution-flags · high confidence
New example demonstrating Scala linting and formatting workflows
Added a new example in \example/scalalib/linting/1-linting\ that demonstrates how to configure autoformatting with ScalaFmt and linting with ScalaFix in a Mill project. The example includes configuration files (\.scalafmt.conf\, \.scalafix.conf\) and build definitions (\build.mill\, \build.mill.yaml\) showing how to extend \ScalafixModule\ and use the \mill-scalafix\ plugin to automatically remove unused code, alongside a sample Scala file illustrating the before-and-after of the linting process.
example/scalalib/linting/1-linting · high confidence
New example demonstrating a manual Java build task graph
Added a new self-contained example in \example/fundamentals/tasks/1-task-graph\ that shows how to define a simple build graph from scratch using Mill's core \Task\, \Task.Source\, and \Task.Command\ types. The example compiles a Java file, packages it into a JAR, and runs it, illustrating data-flow dependencies, caching behavior for cached tasks, and the non-cached nature of commands.
example/fundamentals/tasks/1-task-graph · high confidence
New example demonstrating abstract module references with ModuleRef
Added a new example in \example/fundamentals/modules/11-abstract-module-ref\ that illustrates how to use \ModuleRef\ to wrap abstract module definitions. This allows referencing existing modules in a build hierarchy without creating aliases that interfere with task query resolution, as demonstrated by the \MyTestModule\ trait and its usage in \footest\ and \bartest\.
example/fundamentals/modules/11-abstract-module-ref · high confidence
New example demonstrating anonymous tasks
Added a new example in the Mill Fundamentals section that demonstrates how to define and use anonymous tasks (Task.Anon) to share common code between regular tasks and commands. The example shows that anonymous tasks are not directly runnable from the command line, do not have cached outputs, and can accept arguments, serving as reusable internal logic within other task definitions.
example/fundamentals/tasks/3-anonymous-tasks · high confidence
New example demonstrating async future forking in Mill tasks
Added a new Mill Fundamentals example (7-forking-futures) that demonstrates how to use the \Task.fork.async\ and \Task.fork.await\ APIs to spawn and aggregate results from asynchronous futures within a task. The example illustrates key parameters such as \dest\, \key\, \message\, and \priority\, and explains how these futures integrate with Mill's concurrency limits and logging systems.
example/fundamentals/tasks/7-forking-futures · high confidence
New example demonstrating build header task overrides
Added a new example file at example/cli/header/1-tasks/build.mill that illustrates how to use the build header to override tasks in the meta-build, specifically showing how to enable fatal warnings for unused private members via scalacOptions.
example/cli/header/1-tasks · high confidence
New example demonstrating cross-building across Scala 2 and 3 versions
Added a new example module (\14-cross-scala-version\) that demonstrates how to configure a Mill build to cross-compile Scala libraries across multiple versions, specifically Scala 2.12, 2.13, and 3.2. The example shows how to use \Cross\ modules with \CrossScalaModule\ to share source code while also supporting version-specific sources in \src-2\, \src-2.12\, \src-3\, and \src-3.2\ directories, allowing users to see how to handle major and minor version differences in a cross-build setup.
example/scalalib/module/14-cross-scala-version · high confidence
New example demonstrating custom Mill tasks and mainargs integration
Added a new example module (5-custom-tasks) that illustrates how to define custom Mill tasks, such as generating source files from Maven dependencies and calculating line counts, and how to integrate the mainargs library (version 0.7.8) for command-line argument parsing in Scala 3.8.2.
example/scalalib/module/5-custom-tasks · high confidence
New example demonstrating custom repository configuration in Scala modules
Added a new example project at \example/scalalib/dependencies/5-repository-config\ that illustrates how to override the \repositories\ task in a \ScalaModule\ to resolve dependencies from a custom URL (specifically Sonatype releases). The example uses Scala 3.8.2 and demonstrates dependency declarations via \mvnDeps\ with \scalatags\ 0.13.1 and \mainargs\ 0.7.8, providing a concrete reference for users needing to configure non-default Maven repositories.
example/scalalib/dependencies/5-repository-config · high confidence
New example demonstrating custom resource handling in TypeScript tests
Added a new example module (\example/javascriptlib/module/5-resources\) that illustrates how to configure custom resource folders for TypeScript tests in Mill. The example shows how to define a \Task.Source\ for additional test files (like \other-files\) and pass them to the test environment via \forkEnv\, complementing the standard \resources/\ directory and \MILL\_TEST\_RESOURCE\_DIR\ environment variable approaches.
example/javascriptlib/module/5-resources · high confidence
New example demonstrating custom tasks in TypeScript modules
Added a new build example in the JavaScript/TypeScript module documentation that shows how to define and use custom cached tasks within a TypeScriptModule. The example illustrates defining a custom task to count source lines, generating source files, passing environment variables to forked processes, and creating command tasks, providing users with a concrete reference for extending Mill's task graph in JavaScript/TypeScript projects.
example/javascriptlib/basic/3-custom-build-logic, example/javascriptlib/module/2-custom-tasks · high confidence
New example demonstrating custom test resource directories
Added a new example module (7-resources) that shows how to pass additional resource folders to test suites via environment variables. The example defines a custom \otherFiles\ source task and injects its path into the test environment using \forkEnv\, allowing tests to access files outside the standard classpath resources.
example/scalalib/module/7-resources · high confidence
New example demonstrating custom test resource directories and environment variables
Added a new example module (example/javalib/module/7-resources) that shows how to configure a Java test module to include resources from a custom directory (other-files) and pass that directory's path to the test process via a custom environment variable (OTHER\_FILES\_DIR). The example includes the necessary build configuration and sample resource files to illustrate this setup.
example/javalib/module/7-resources · high confidence
New example demonstrating custom test resource handling
Added a new example module (\example/pythonlib/module/5-resources\) that illustrates how to configure custom resource folders for Python tests. The example shows how to define additional \Task.Source\ inputs (such as \otherFiles\) and pass their paths to the test environment via \forkEnv\, enabling tests to access specific directories on disk while respecting Mill's sandboxing rules.
example/pythonlib/module/5-resources · high confidence
New example demonstrating custom trait inheritance in Mill modules
Added a new example module (17-custom-trait) that demonstrates how declarative Mill modules can inherit from user-defined traits via the \extends\ configuration, rather than being limited to built-in traits. The example includes a \build.mill.yaml\ file extending \millbuild.LineCountScalaModule\ and a Scala source file (\Qux.scala\) that counts lines in a resource file, illustrating the practical usage of this feature.
example/scalalib/module/17-custom-trait · high confidence
New example demonstrating in-memory worker caching and compression
Added a new example in \example/fundamentals/tasks/6-workers\ that illustrates how to use \Task.Worker\ for in-memory state persistence, specifically showing a counter example and a two-level compression cache (in-memory and disk) using \GZIPOutputStream\. The example includes supporting data files (\hello.txt\, \world.txt\, \input.txt\) and documentation on worker lifecycle, concurrency safety, and resource cleanup via \AutoCloseable\.
example/fundamentals/tasks/6-workers · high confidence
New example demonstrating primary task definitions and dependencies
Added a new Mill build example in \example/fundamentals/tasks/2-primary-tasks\ that illustrates the three primary task types: \Task.Source\ for defining input paths, \Task\ for defining cached computations with dependencies, and \Task.Command\ (referenced in comments). The example includes a \build.mill\ file showing how to define sources, aggregate them, compute derived values like line counts, and produce outputs such as class files and JARs using \Task.dest\. It also includes sample Java source code and resource files to demonstrate a complete, runnable build scenario.
example/fundamentals/tasks/2-primary-tasks · high confidence
New example demonstrating programmable Mill module configuration
Added a new example module (\4-programmable-config\) that illustrates how to customize a Mill Java module's build behavior. The example shows how to define custom source and resource directories, generate sources at build time, set specific main classes, and pass custom JVM arguments and environment variables during execution.
example/javalib/module/4-programmable-config · high confidence
New example demonstrating programmable build configuration
Added a new example module (\4-programmable-config\) that showcases how to customize a Kotlin module's build process. This example demonstrates configuring custom source and resource directories, generating source files at build time, setting JVM fork arguments and environment variables, and specifying a main class, providing a concrete reference for users implementing similar build customizations.
example/kotlinlib/module/4-programmable-config · high confidence
New example demonstrating programmable module dependencies in Kotlinlib
Added a new example module (18-programmable-module-deps) that illustrates how to configure Kotlinlib modules with specific dependencies. The example defines a base module 'bar' using Kotlin version 2.2.20 and a cross-compiled module 'qux' across versions 1, 2, and 3, also using Kotlin 2.2.20. It further demonstrates how a consuming module 'foo' can extend KotlinModule, specify module dependencies (including cross-module selection via 'qux\[1\]'), and declare Maven dependencies like clikt 4.4.0.
example/kotlinlib/module/18-programmable-module-deps · high confidence
New example demonstrating relative module dependencies in Scala scripts
Added a new example under \example/scalalib/script/8-relative-deps\ that illustrates how to reference sibling modules using relative paths in Mill Scala scripts. The \foo\ module now imports \bar\ via the \//bar/Bar.scala\ syntax, and both modules are configured to use Scala 3.9.0, with \bar\ including a basic Utest test suite.
example/scalalib/script/8-relative-deps/bar · high confidence
New example demonstrating runtime and compile-time dependency management
Added a new example under \example/scalalib/dependencies/1-dependencies\ that illustrates how to configure runtime (\runMvnDeps\) and compile-time (\compileMvnDeps\) dependencies in Mill. The example uses Scala 3.8.2 and Jetty to serve a web page, while also parsing JSON input using the nanojson library, showing how these dependencies are declared and used in a build.
example/scalalib/dependencies/1-dependencies · high confidence
New example demonstrating shared dependency management between build and application code
Added a new example in \example/extending/metabuild/4-meta-build\ that illustrates how to use the \mill-build/\ folder to avoid duplicating dependency versions between the build script and the application. The example shows a \build.mill\ file using the new \//\| mill-jvm-version: 17\ header and \mvnDeps\ syntax, which defines a \DepVersions\ object to share the Scalatags version with the application code in \src/Foo.scala\.
example/extending/metabuild/4-meta-build · high confidence
New example demonstrating shared sources between build and application code
Added a new example in \example/extending/metabuild/5-meta-shared-sources\ that shows how to share Scala source files between the Mill meta-build (\mill-build/src/\) and the application code (\src/\). The example configures \build.mill\ to include \mill-build/src\ in its sources, allowing definitions like \ScalaVersion\ to be reused in both build-time logic and the application's runtime code.
example/extending/metabuild/5-meta-shared-sources · high confidence
New example demonstrating single-file script dependencies on programmable modules
Added a new example in \example/scalalib/script/9-programmable-module-deps\ that shows how to write a single-file Scala script (\Foo.scala\) that depends on a programmable Mill module (\bar\). The example includes a \build.mill\ file defining the \bar\ module with Scala 3.8.2 and a dependency on \scalatags\, allowing the script to import and use classes from the module (e.g., \bar.Bar.generateHtml\).
example/scalalib/script/9-programmable-module-deps · high confidence
New example demonstrating task overriding in TypeScript modules
Added a new example in the JavaScript/TypeScript library module that shows how to override build tasks like \compile\, \run\, and \sources\ within a \TypeScriptModule\. The example illustrates using \super\ to extend original task behavior and generating source files on-the-fly, providing a concrete reference for users customizing Mill's TypeScript build process.
example/javascriptlib/module/3-override-tasks · high confidence
New example demonstrating test sandboxing behavior
Added a new example (\example/depth/sandbox/2-test\) that illustrates how Mill isolates test execution in separate working directories to prevent race conditions during parallel runs. The example explains the default sandboxing behavior, shows how to access the workspace root via the \MILL\_WORKSPACE\_ROOT\ environment variable, and documents how to disable sandboxing by setting \testSandboxWorkingDir = false\ for compatibility with existing test suites.
example/depth/sandbox/2-test · high confidence
New example demonstrating uncached input tasks
Added a new example in \example/fundamentals/tasks/4-inputs\ that illustrates how to use \Task.Input\ to handle external state changes, such as git commits, system properties, and environment variables. The example shows how wrapping external calls in \Task.Input\ ensures that cached tasks re-evaluate when underlying external conditions change, while also noting that input tasks cannot have task dependencies.
example/fundamentals/tasks/4-inputs · high confidence
New example for Spring Boot-based repackaging
Added a new build configuration example in \example/scalalib/packaging/4-repackage-config\ that demonstrates using \RepackageModule\ with Spring Boot Tools (version 2.7.18) to create self-executable JARs. This approach embeds dependencies as-is in \BOOT-INF/lib\ rather than merging them into a flat JAR, which simplifies introspection and helps avoid ZIP entry limits encountered with the standard \assembly\ task. The example is configured for Scala 3.8.2 and includes Thymeleaf as a sample dependency.
example/scalalib/packaging/4-repackage-config · high confidence
New example for debugging meta-build tasks
Added a new example at \example/extending/metabuild/3-meta-tasks\ that demonstrates how to use the \--meta-level 1\ flag to inspect, visualize, and debug the meta-build pipeline. The example shows how to run commands like \inspect\, \visualizePlan\, and \show runClasspath\ on the \millBuildRootModuleResult\ to troubleshoot issues with \build.mill\ file compilation and dependency resolution.
example/extending/metabuild/3-meta-tasks · high confidence
New example for defining custom Python tasks with dependencies
Added a new example build file (\build.mill\) in the \2-custom-tasks\ module that demonstrates how to define custom Mill tasks for Python projects. The example shows how to override \generatedSources\ to depend on \pythonDeps\ and how to create a new \lineCount\ task that depends on \sources\, including how to pass task outputs to the runtime environment via \forkEnv\.
example/pythonlib/module/2-custom-tasks · high confidence
New example for dependency version update checking
Added a new example in \example/fundamentals/dependencies/3-search-updates\ demonstrating how to use Mill's dependency update search feature. The example includes a \build.mill\ file with documentation and usage instructions for the \mill.javalib.Dependency/showUpdates\ command, along with \foo\ and \bar\ module definitions using \mvnDeps\ to illustrate checking for newer versions of Maven dependencies.
example/fundamentals/dependencies/3-search-updates · high confidence
New example for downloading unmanaged JARs in Kotlin projects
Added a new example demonstrating how to download and include unmanaged JAR dependencies in a Kotlin module using Mill. The example shows a \build.mill\ script that fetches the \fastjavaio.jar\ from GitHub at build time and adds it to the classpath, along with a Kotlin source file that uses the library to read a text file.
example/kotlinlib/dependencies/4-downloading-unmanaged-jars · high confidence
New example for downloading unmanaged JARs via Mill
Added a new example project demonstrating how to download unmanaged JARs from arbitrary URLs using Mill's \unmanagedClasspath\ task and the bundled Requests-Scala library. The example shows how to fetch the FastJavaIO library at build time, handles offline mode checks, and includes a source file and text resource to verify the downloaded dependency works correctly.
example/scalalib/dependencies/4-downloading-unmanaged-jars · high confidence
New example for integrating Scoverage with Mill
Added a new example demonstrating how to integrate the \mill-contrib-scoverage\ plugin into a Mill build. The example shows a Scala 3.8.2 project that extends \ScoverageModule\ to generate coverage reports (console, HTML, XML) and validates minimum coverage thresholds (10% statements, 90% branches). It also illustrates the use of \mainargs\ for command-line argument parsing in the example application.
example/scalalib/linting/3-contrib-scoverage · high confidence
New example for packaging Scala scripts into assemblies and native images
Added a new example demonstrating how to package Scala scripts into executable assemblies or GraalVM native images using Mill. The example includes a \Bar.scala\ script targeting Scala 3.9.0 and GraalVM 17, along with a \build.mill\ file that documents usage for generating both JAR assemblies and native executables.
example/scalalib/script/6-packaging · high confidence
New example for packaging native images with third-party libraries
Added a new example demonstrating how to generate GraalVM native images for projects that depend on third-party libraries like Scalatags and Mainargs. The example includes configuration to optimize for binary size using the \-Os\ flag and shows how to inspect the native-image tool path. It is based on Scala 3.8.2.
example/scalalib/packaging/2-native-image-libs · high confidence
New example for publishing Python modules with Mill
Added a new example in \example/pythonlib/publishing/1-publish-module\ that demonstrates how to configure and publish a Python package using Mill's \PublishModule\. The example includes a \build.mill\ file showing how to define metadata (name, description, license, authors), specify Python dependencies (jinja2), set the publish version, and override the module name. It also provides a simple Python package (\testpkg\) with a \greet\ module that uses Jinja2, along with a README explaining how to build source distributions and wheels, and how to publish them to PyPI using \uv publish\ via Mill tasks.
example/pythonlib/publishing/1-publish-module · high confidence
New example for thread-safe cached classloader reuse
Added a new example demonstrating how to use \mill.api.CachedFactory\ to safely cache and reuse expensive \URLClassLoader\ instances across multiple tasks. This example illustrates a thread-safe pattern for managing classloader state, specifically addressing scenarios where sharing a single classloader across concurrent tasks is not safe, by leveraging \CachedFactory\ to handle setup, caching, and teardown of the classloaders.
example/extending/jvmcode/6-module-cached-classloader · high confidence
New example for using Maven dependencies with Scala libraries in Mill
Added a new example (\example/extending/imports/2-mvn-deps-scala\) demonstrating how to use the \//\| mvnDeps\ YAML header comment syntax to include Scala libraries (specifically \com.lihaoyi::os-lib\) in a Mill build. The example shows a \ScalaModule\ that uses Scalatags to generate an HTML snippet at build time and writes it to a resource file, illustrating the correct double-colon (\::\) syntax required for Scala organization/artifact coordinates in Maven dependencies.
example/extending/imports/2-mvn-deps-scala · high confidence
New example for using Scala modules as build tasks
Added a new example demonstrating how to use Mill ScalaModules as build tasks, specifically showing how to build code within a 'bar' module and use it to preprocess sources for a 'foo' module, including details on runner configuration and dependency management.
example/extending/jvmcode/5-module-run-task · high confidence
New example for using unmanaged JARs in Mill
Added a new example project demonstrating how to include local, unmanaged JAR files in a Mill build via the \unmanagedClasspath\ setting. The example configures a Scala 3.8.2 module to load \nanojson-1.8.jar\ from a local \lib/\ directory and provides source code showing how to use the library to parse JSON strings passed as command-line arguments.
example/scalalib/dependencies/3-unmanaged-jars · high confidence
New example for writing and publishing Mill plugins
Added a new example demonstrating how to create, test, and publish a custom Mill plugin. The example includes a \build.mill\ file configured for Scala 3.7.4 and Java 11, a \LineCountJavaModule\ trait that extends \JavaModule\ to add a line-counting task and override resource generation, and unit tests using \mill-testkit\ to verify the plugin's behavior.
example/extending/plugins/1-writing-mill-plugins · high confidence
New example modules for annotation processors, Kotlin compiler plugins, and documentation generation
Added three new example modules to demonstrate specific build capabilities: the \2-annotation-processors\ module shows how to configure Java annotation processors (using Project Lombok) with explicit dependency and Javac option settings; the \2-kotlin-compiler-plugins\ module demonstrates configuring Kotlin compiler plugins (specifically the serialization plugin) and updating the Kotlin version to 2.2.20; and the \3-docjar\ module provides a working example of generating documentation JARs using Dokka for both Kotlin and Java sources.
example/javalib/module/2-annotation-processors, example/kotlinlib/module/2-kotlin-compiler-plugins, example/kotlinlib/module/3-docjar · high confidence
New examples for Scala compiler plugins and Scala 3 documentation generation
Added example modules demonstrating how to configure Scala compiler plugins (using the acyclic plugin) and how to generate API documentation with \docJar\ and Scala 3's static site features, including configuration of \scalaDocOptions\ and source links.
example/scalalib/module/3-docjar · high confidence
New examples for custom traits and programmable module dependencies
Added two new example modules demonstrating advanced Mill configuration: \17-custom-trait\ shows how to extend a custom Java module trait (\LineCountJavaModule\) via YAML, and \18-programmable-module-deps\ illustrates defining cross-compiled modules and managing dependencies programmatically in \build.mill\ while referencing them from YAML.
example/javalib/module/17-custom-trait, example/javalib/module/18-programmable-module-deps · high confidence
New examples for dependency management and BOM usage
Added example files in \example/fundamentals/dependencies/1-external-bom\ and \2-managed\ demonstrating how to use \bomMvnDeps\ for external Bill of Materials, \depManagement\ for centralized version control and exclusions, and \BomModule\ for defining and publishing custom BOMs within Mill builds.
example/fundamentals/dependencies/2-managed · high confidence
New examples for multi-file builds, helper scripts, and nested build support
Added three new example projects in \example/large/multifile\ demonstrating advanced build organization. The \10-multi-file-builds\ example shows how to split a build into \package.mill\ files within subdirectories to co-locate module definitions with their source code. The \11-helper-files\ example illustrates using adjacent \\*.mill\ files to share configuration and logic across the build. The \12-import-subdir\ and \13-subdir-with-helper\ examples demonstrate the new capability to allow nested \build.mill\ files in subdirectories (enabled via the \//\| mill-allow-nested-build-mill: true\ header), allowing sub-builds to use simple \package build\ declarations while remaining accessible via hierarchical paths from the root.
example/large/multifile · high confidence
New examples for programmable build configuration and source generation
Added two new Mill example modules under \example/scalalib/module\ to demonstrate advanced build customization. The \4-programmable-config\ example shows how to override standard \ScalaModule\ tasks in a \build.mill\ file, including custom source and resource directories, JVM fork arguments, environment variables, and Scala compiler options (such as fatal warnings). The \6-generated-sources\ example demonstrates how to implement the \generatedSources\ task to create source files at build time. Both examples are configured to use Scala 3.8.2.
example/scalalib/module/4-programmable-config · high confidence
New examples for running JVM code in subprocesses and isolated classloaders
Added two new build examples demonstrating how to execute JVM code during the build process: one using \Jvm.callProcess\ to run a third-party library (Groovy) in a subprocess with a resolved classpath, and another using \Jvm.withClassLoader\ to run custom code in an in-process isolated classloader.
example/extending/jvmcode/1-subprocess · high confidence
New internal core module for build infrastructure and logging
Mill introduces a new \core/internal\ module that consolidates internal build infrastructure, including a new \AnsiNav\ utility for terminal control, a \BspLogger\ for BSP-specific logging, and a \FileLogger\ for file-based output. The module also adds \BuildFileDiscovery\ for locating build files, \CodeSigUtils\ and \InvalidationForest\ for code signature and invalidation tree management, and \LauncherLockRegistry\ with \LauncherLockingImpl\ to coordinate fine-grained locking across multiple launchers. Additionally, it provides \LauncherOutFilesImpl\ for managing launcher output files and \LineBufferingOutputStream\ for buffered line output.
core/internal · high confidence
New internal utilities for Scala 3 mirrors and error parsing
Added new internal Scala 3-specific utilities in the java11 module: Mirrors.scala provides a macro-based system for synthesizing and retrieving Scala 3 Mirrors for sealed hierarchies and products, enabling more efficient runtime type reflection; NamedParameterOnlyDummy.scala introduces a marker class to support named-only parameter semantics; and Util.scala adds helper functions including scrapeColoredLineContent, which extracts code snippets from Dotty/Zinc error output by parsing colored line patterns, improving error message readability for users.
core/api/java11/src/mill/api/internal · high confidence
New metabuild example demonstrating generated sources and dependency management
The example at \example/extending/metabuild/4-meta-build/mill-build\ now includes a \build.mill\ file that illustrates how to define a \MillBuildRootModule\ to manage build-time dependencies (specifically \scalatags\ version 0.13.1) and generate source files (such as \DepVersions.scala\) during the build process.
example/extending/metabuild/4-meta-build/mill-build · high confidence
New multi-language example demonstrating Java, Python, and React integration
Added a new example project (\14-multi-language\) that demonstrates building a multi-language application using Mill's Java, Python, and JavaScript toolchains. The example features a React client, a Python sentiment analysis module, and a Spring Boot Java server, illustrating how Mill can manage dependencies, build, and test across different languages within a single project structure.
example/large/multilang · high confidence
New multi-module dependency examples for Java, Kotlin, and Scala
Added example projects demonstrating how to structure and build multi-module dependencies in Java, Kotlin, and Scala. The Java example uses Thymeleaf for HTML generation and argparse4j for CLI argument parsing, while the Kotlin and Scala examples showcase kotlinx.html and scalatags respectively, providing users with reference implementations for common library integrations across these JVM languages.
(repo-wide) · high confidence
New packaging examples for native images, assembly, repackaging, jlink, and jpackage
Added six new example projects under \example/javalib/packaging\ demonstrating advanced Java packaging capabilities in Mill. These include configurations for GraalVM Native Image (\1-native-image\, \2-native-image-libs\), custom assembly rules for merging resources and relocating packages (\3-assembly-config\), executable JAR repackaging with embedded dependencies (\4-repackage-config\), runtime image generation via \jlink\ (\5-jlink\), and native installer creation using \jpackage\ (\6-jpackage\).
example/javalib/packaging · high confidence
New sandboxing example demonstrating task filesystem restrictions and os.pwd redirection
Added a new example (\example/depth/sandbox/1-task\) that illustrates Mill's task sandboxing features. It shows how tasks are restricted to writing only to their \.dest\ folder and reading only from upstream \PathRef\s, with examples of banned read/write operations. It also demonstrates how to bypass these checks using \BuildCtx.withFilesystemCheckerDisabled\ or the \--no-filesystem-checker\ flag, and explains how \os.pwd\ is redirected to the task's destination folder during execution and to a sandbox directory when called outside a task.
example/depth/sandbox/1-task · high confidence
New static site generator example using Scala scripting
Added a new example in the \example/scalalib/script/5-static-site\ directory that demonstrates a static site generator implemented as a single-file Scala script. The \StaticSite.scala\ script uses \scalatags\ for HTML generation and \commonmark-java\ to convert Markdown files from a \post/\ directory into HTML, outputting the result to a \site-out/\ folder. The example includes a \build.mill\ configuration and sample Markdown posts to illustrate how to leverage Mill's scripting capabilities for file processing and external library integration.
example/scalalib/script/5-static-site · high confidence
New testkit module for Mill plugin and integration testing
Mill introduces a new \testkit\ module that provides a suite of helpers for writing unit, integration, and example tests for Mill plugins and builds. This includes \UnitTester\ for in-process evaluation of Mill modules, \IntegrationTester\ for running Mill commands in subprocesses (with support for daemon and no-daemon modes), and \ExampleTester\ which parses usage examples from \build.mill\ comments to validate build documentation. The module also provides base traits like \IntegrationTestSuite\ and \UtestIntegrationTestSuite\ to simplify test setup, along with utilities for stream handling and test assertions.
testkit · high confidence
New web application examples for Micronaut, Cask, and http4s
Added new example projects demonstrating web development across multiple frameworks. The Java example (\3-hello-micronaut\) shows a simple Micronaut service using Micronaut 4.6.1, Netty, and JUnit 5. The Scala examples include a basic Cask web server, a TodoMVC-style application built with Cask and Scalatags, a version with cache-busting for static resources, a TodoMVC implementation using http4s and Cats Effect, and two Scala.js variants (one standalone, one sharing code via a \shared\ module). All examples are configured to read the server port from the \PORT\ environment variable, defaulting to 8080.
(repo-wide) · high confidence
Realistic Todo API server implementation
The server example now includes a functional Express-based API for managing todos, featuring endpoints to list, create, toggle, delete, and clear completed items, along with a static file server that serves the client application.
example/javascriptlib/basic/6-client-server-realistic/server · high confidence
Shared Play routes compiler worker base class
A new shared base class for Play workers has been introduced to handle route compilation. This component supports both the InjectedGenerator and StaticGenerator types, though it explicitly notes that the StaticGenerator was deprecated in Play 2.6.0 and removed in 2.7.x, returning a specific error message for that case. The implementation is designed to compile with Scala 2.12 and 2.13 to maintain compatibility with older Play versions.
contrib/playlib/worker · high confidence
Support applying Cross to RootModule
Mill now allows the \Cross\ modifier to be applied to root-level modules (objects extending \RootModule\ or the root \package\ object). This enables users to define cross-compilation targets directly at the root level, as demonstrated by the new integration tests verifying that root-level cross modules and their nested sub-modules can be evaluated successfully across specified Scala versions.
integration/feature/root-cross-module · high confidence
Support for @nonBootstrapped commands that bypass build compilation
Users can now annotate specific commands with the @nonBootstrapped annotation, allowing them to execute even when the root build.mill file contains compile errors. This capability enables essential utility commands (such as version, shutdown, clean, or init) to function independently of the main build's compilation status, provided the meta-build level compiles successfully. Regular commands without this annotation will still fail if the build definition is broken.
integration/feature/non-bootstrapped-task · high confidence
Support for YAML !append tag in Mill build configuration
Users can now use the \!append\ tag in Mill YAML configuration files to merge values with existing defaults rather than replacing them. This change introduces the \AppendableFromYaml\ trait, allowing custom case classes (like \MyConfig\) to define how their fields should be combined when overridden in YAML. For example, applying \!append\ to a sequence or map in a child module's configuration will concatenate or merge the new values with the parent's default values, enabling more flexible and incremental configuration overrides.
example/fundamentals/yaml, example/fundamentals/yaml/1-yaml-config/mill-build · high confidence
Support for custom repository configuration via mill-repositories header
Users can now customize repository configuration globally by adding a \mill-repositories\ header to their build files, allowing them to specify custom repository locations (e.g., local repos) that will be used for resolving dependencies across the daemon classpath, meta-build classpath, and individual module classpaths.
integration/feature/mill-repositories · high confidence
Support for nested build files under a flag
The build system now allows nested \build.mill\ files to be used when enabled via a specific flag. This change is demonstrated by the addition of example projects (\12-import-subdir\ and \13-subdir-with-helper\) that utilize this capability, allowing for more modular project structures.
example/large/multifile/12-import-subdir/deps/foo, example/large/multifile/13-subdir-with-helper/deps/foo · medium confidence
Support for precompiled module dependency overrides and nested relationships
Users can now programmatically override module dependencies in precompiled modules by walking \BuildCtx.rootModule\ to discover sibling modules, and precompiled modules can correctly reference compiled siblings across nested package boundaries. This change introduces integration tests verifying that precompiled modules can dynamically resolve dependencies based on segment names and that cross-shape dependencies (precompiled YAML referencing compiled codegen modules) are correctly resolved in the compile classpath.
integration/feature/precompiled-moduledeps-override, integration/feature/precompiled-nested-relationships · high confidence
Synthetic main classes for @main methods in Scala scripts
Mill now generates synthetic main classes for scripts containing \@main\ (or \@mainargs.main\) annotations, enabling compatibility with tools like IntelliJ's run configuration. For scripts with multiple \@main\ methods, separate forwarder classes are created so that \runMain\ can target specific methods by name, while single-method scripts continue to work as before. This change also ensures that explicit \@scala.main\ annotations and standard \def main(args: Array\[String\])\ signatures take priority over the synthetic forwarders, and supports \.sc\ extensions and shebang lines in these scripts.
integration/feature/script-main-forwarder-classes · high confidence
Architecture
Consolidate Mill runtime libraries under libs/ subfolder
The various Mill libraries available on the user build.mill classpath (such as support for Kotlin, Groovy, Android, Scala.js, Scala Native, JavaScript, Python, and utility tasks) are now organized under a dedicated libs/ subfolder. This change introduces a package.mill file that aggregates these modules, separating them from the core Mill evaluation engine and clarifying the project structure for users and contributors.
libs · high confidence
Core evaluator logic moved to dedicated core/eval module
The core evaluation logic for resolving, planning, and executing Mill tasks has been extracted into a new \core/eval\ module. This change introduces \EvaluatorImpl\ as the primary API for the evaluation process and \ScriptModuleInit\ to handle the initialization and caching of script-based modules. By isolating this logic, the build tool can now resolve and execute tasks without depending on user-land build helpers, providing a cleaner separation between the build engine and the projects it builds.
core/eval · high confidence
Daemon architecture refactored with new entry points and concurrency controls
The runner/daemon module has been restructured to improve stability and separation of concerns. New entry points (MillDaemonMain, MillNoDaemonMain, MillBspMain) now delegate to internal implementations (MillDaemonMain0, MillMain0) and enforce a Java 17 minimum requirement via VersionCheck. Concurrency and state management are handled by new components: MetaBuildAccess coordinates read/write locks for meta-builds, SharedOutLockManager synchronizes access to the output directory across processes, and IdeWorkerSupport enables dynamic classloading for IDE and BSP workers. Additionally, logging is improved with RotatingConsoleLogOutputStream to prevent unbounded log growth and TailManager to stream daemon output.
runner/daemon · high confidence
Introduce dedicated worker processes for compilation, publishing, and native builds
Mill now offloads heavy JVM tasks—such as Java/Scala compilation, Maven publishing, PGP signing, GraalVM native metadata handling, Quarkus code generation, and Spring Boot repackaging—into separate, long-lived worker processes. This architectural change isolates these operations from the main build daemon, improving stability and performance by preventing classloader leaks and reducing memory pressure. Users benefit from more reliable incremental compilation and faster build times, especially in large projects, as workers can be reused across multiple build invocations without restarting the entire build environment. Also in this area: 1 commit (0 fixes) modifying javalib; Paths in cache files now use symbolic root placeholders; Mill javalib module restructured with new internal APIs and dependency resolution features.
javalib, libs/javalib · low confidence
Introduce new \`mill.exec\` package for core task execution logic
The core task evaluation and execution logic has been moved into a new \mill.exec\ package, containing \Execution.scala\, \GroupExecution.scala\, and \TaskCacheEntry.scala\. This refactoring centralizes the implementation of task planning, execution, and caching within the \mill.exec\ namespace, separating it from previous locations and establishing the structural foundation for the build's execution engine.
exec · high confidence
Reorganized runner into modular subcomponents
The runner module has been restructured into distinct submodules (autooverride, bsp, codesig, daemon, eclipse, idea, launcher, meta, server) to improve separation of concerns. This change introduces a new AutoOverride compiler plugin for Scala 3 to automatically implement abstract methods, refactors the daemon and launcher logic into separate modules, and updates build configurations for BSP, Eclipse, and IntelliJ integration.
runner · high confidence
Scala library code is split out from javalib into a dedicated scalalib module
The Scala-specific build logic (including ScalaModule, cross-compilation support, SbtModule layout, Unidoc, BSP, and IntelliJ integration) has been moved from the mill.javalib package into a new mill.scalalib package. This structural change isolates Scala tooling from general Java functionality, with javalib now providing the base Java modules and scalalib extending them for Scala compilation and publishing. The scalalib module also introduces a dedicated scalafmt-worker component to manage the Scalafmt daemon and its caches, and provides alias exports for publishing modules to maintain backward compatibility.
libs/scalalib · high confidence
Behavioural changes
1 commit (0 fixes) modifying (repo-wide)
A change to existing behaviour in (repo-wide) — 1 commit, 4 files: “Docs polish (\#6695)” (refs \#6695).
(repo-wide) · low confidence · unverified
1 commit (0 fixes) modifying (repo-wide)
A change to existing behaviour in (repo-wide) — 1 commit, 7 files: “Make \.shared\ integration and example tests use an in-process \MillLauncherMain\, use \.shared\ in \.feature\ tests (\#6636)” (refs \#6636).
(repo-wide) · low confidence · unverified
1 commit (0 fixes) modifying example/androidlib/kotlin/5-multiplatform, example/androidlib/kotlin/5-multiplatform/androidApp, example/androidlib/kotlin/5-multiplatform/shared
A change to existing behaviour in example/androidlib/kotlin/5-multiplatform, example/androidlib/kotlin/5-multiplatform/androidApp, example/androidlib/kotlin/5-multiplatform/shared — 1 commit, 13 files: “KMP: Initial support for Android targets (\#7863)” (refs \#7863).
example/androidlib/kotlin/5-multiplatform, example/androidlib/kotlin/5-multiplatform/androidApp, example/androidlib/kotlin/5-multiplatform/shared · medium confidence · unverified
1 commit (0 fixes) modifying example/kotlinlib/multiplatform/1-hello-kmp/foo
A change to existing behaviour in example/kotlinlib/multiplatform/1-hello-kmp/foo — 1 commit, 7 files: “New experimental \KotlinMultiplatformModule\ with a JVM + JS example (\#7071)” (refs \#7071).
example/kotlinlib/multiplatform/1-hello-kmp/foo · medium confidence · unverified
1 commit (0 fixes) modifying example/reproduce/issue/workspace-relative-paths/fooKotlin19, example/reproduce/issue/workspace-relative-paths/fooKotlin24
A change to existing behaviour in example/reproduce/issue/workspace-relative-paths/fooKotlin19, example/reproduce/issue/workspace-relative-paths/fooKotlin24 — 1 commit, 2 files: “Kotlin: Render paths in compiler messages relative to the workspace (\#7890)” (refs \#7890).
example/reproduce/issue/workspace-relative-paths/fooKotlin19, example/reproduce/issue/workspace-relative-paths/fooKotlin24 · medium confidence · unverified
1 commit (0 fixes) modifying integration/feature/header-meta-build-mvn-deps
A change to existing behaviour in integration/feature/header-meta-build-mvn-deps — 1 commit, 3 files: “Honor YAML header config in mill-build/build.mill (\#7816)” (refs \#7816).
integration/feature/header-meta-build-mvn-deps · medium confidence · unverified
12 commits (2 fixes) modifying spark-app
A change to existing behaviour in spark-app — 12 commits (2 fixs), 14 files: “Split \declarative.adoc\ examples into individual example pages (\#6392)”; “KMP: Initial support for Android targets (\#7863)”; “Lint Kotlin examples (\#3923)”; and 9 more (refs \#6392, \#7863, \#3923, \#6715, \#6394, …).
spark-app · medium confidence · unverified
15 commits (2 fixes) modifying sbom-example-reference
A change to existing behaviour in sbom-example-reference — 15 commits (2 fixs), 4 files: “Clean up daemon/server launching retry logic to try and stabilize it (\#5865)”; “Option to make TestNG framework less verbose (mill.testng.printProgress) (\#1112)”; “Fix TestNg test runner (\#3813)”; and 12 more (refs \#5865, \#1112, \#3813, \#6938, \#4506, …).
sbom-example-reference · medium confidence · unverified
2 commits (0 fixes) modifying example/kotlinlib/multiplatform
A change to existing behaviour in example/kotlinlib/multiplatform — 2 commits, 1 file: “KMP: Initial support for Android targets (\#7863)”; “New experimental \KotlinMultiplatformModule\ with a JVM + JS example (\#7071)” (refs \#7863, \#7071).
example/kotlinlib/multiplatform · medium confidence · unverified
2 commits (0 fixes) modifying example/kotlinlib/web/4-hello-kotlinjs
A change to existing behaviour in example/kotlinlib/web/4-hello-kotlinjs — 2 commits, 2 files: “Split \declarative.adoc\ examples into individual example pages (\#6392)”; “Log all compilation starts via ticker (\#7858)” (refs \#6392, \#7858).
example/kotlinlib/web/4-hello-kotlinjs · medium confidence · unverified
2 commits (0 fixes) modifying example/reproduce
A change to existing behaviour in example/reproduce — 2 commits, 3 files: “GenIdea: Handle empty and very long module file names (\#7868)”; “Kotlin: Render paths in compiler messages relative to the workspace (\#7890)” (refs \#7868, \#7890).
example/reproduce · medium confidence · unverified
3 commits (0 fixes) modifying example/androidlib/kotlin/1-hello-kotlin-declarative
A change to existing behaviour in example/androidlib/kotlin/1-hello-kotlin-declarative — 3 commits, 16 files: “Dynamically map known root paths in cache files (\#7725)”; “Android: Support Declarative Builds (backport \#7461) (\#7626)”; “Log all compilation starts via ticker (\#7858)” (refs \#7725, \#7461, \#7626, \#7858).
example/androidlib/kotlin/1-hello-kotlin-declarative · medium confidence · unverified
3 commits (0 fixes) modifying example/fundamentals/javahome/1-builtin-jvm
A change to existing behaviour in example/fundamentals/javahome/1-builtin-jvm — 3 commits, 1 file: “Use \import foo.\\ rather than \import foo.\\ throughout Mill (\#6502)”; “Streamline using Mill as sole source of Java installation (\#6493)”; “Use Java 25 by default (\#7076)” (refs \#6502, \#6493, \#7076).
example/fundamentals/javahome/1-builtin-jvm · medium confidence · unverified
4 commits (0 fixes) modifying example/javascriptlib/dependencies/3-downloading-unmanaged-packages
A change to existing behaviour in example/javascriptlib/dependencies/3-downloading-unmanaged-packages — 4 commits, 1 file: “Documentation Review (\#5313)”; “Use \import foo.\\ rather than \foo.\\ in examples and docs (\#5412)”; “Doc Review \Java Library Dependencies\ to \Java Web Project Examples\ (\#4420)”; and 1 more (refs \#5313, \#5412, \#4420, \#4127, \#4187).
example/javascriptlib/dependencies/3-downloading-unmanaged-packages · medium confidence · unverified
5 commits (0 fixes) modifying example/javascriptlib/dependencies/4-repository-config
A change to existing behaviour in example/javascriptlib/dependencies/4-repository-config — 5 commits, 2 files: “Documentation Review (\#5313)”; “Use \import foo.\\ rather than \foo.\\ in examples and docs (\#5412)”; “Log all compilation starts via ticker (\#7858)”; and 2 more (refs \#5313, \#5412, \#7858, \#4127, \#4187, …).
example/javascriptlib/dependencies/4-repository-config · medium confidence · unverified
5 commits (0 fixes) modifying example/migrating/javalib/4-gradle-complete
A change to existing behaviour in example/migrating/javalib/4-gradle-complete — 5 commits, 1 file: “Remove unnecessary \rm build.mill\ from migration docs (\#6163)”; “Improvements to maven project importer (\#5530)”; “Log all compilation starts via ticker (\#7858)”; and 2 more (refs \#6163, \#5530, \#7858, \#5627, \#5428).
example/migrating/javalib/4-gradle-complete · medium confidence · unverified
5 commits (1 fix) modifying runner/meta
A change to existing behaviour in runner/meta — 5 commits (1 fix), 2 files: “Use a lightweight \BootstrapRootModule\ for dummy build when no \build.mill\ is found (\#6649)”; “Support .sc files as Scala scripts (backport \#7512)”; “Fix \bspScriptIgnore\ handling in the absence of a root \build.mill\/\build.mill.yaml\ file (\#6953)”; and 2 more (refs \#6649, \#7512, \#6953, \#5062, \#6643).
runner/meta · medium confidence · unverified
6 commits (0 fixes) modifying example/javascriptlib/dependencies/2-unmanaged-packages
A change to existing behaviour in example/javascriptlib/dependencies/2-unmanaged-packages — 6 commits, 1 file: “Documentation Review (\#5313)”; “Use \import foo.\\ rather than \foo.\\ in examples and docs (\#5412)”; “Cleanup \mill.define.Module\ and \mill.define.Ctx\ (\#4518)”; and 3 more (refs \#5313, \#5412, \#4518, \#6479, \#4127, …).
example/javascriptlib/dependencies/2-unmanaged-packages · medium confidence · unverified
Align source file locations with package structure
The RouteCompilerWorker source files in the Play 2.7 and 2.8 worker modules have been moved to align their physical locations with their package declarations. This change ensures that the file paths match the mill.playlib.worker package structure, improving consistency and maintainability of the codebase layout.
contrib/playlib/worker/2.7, contrib/playlib/worker/2.8 · high confidence
Android Todo app example updated to Kotlin 2.2, KSP 2, and Compose BOM
The Android Todo app example has been updated to use Kotlin 2.2.20 and KSP 2.0.2, with the KSP JVM target set to 17. It now leverages the AndroidX Compose BOM (2024.12.01) for managing Compose dependency versions and includes Hilt support for dependency injection. The build configuration also sets the compile SDK to 35 and min SDK to 26, and enables Compose UI components.
example/thirdparty/androidtodo · high confidence
Android build module restructured with new configuration models and instrumentation parsing
The \androidlib\ module has been significantly restructured to support modern Android build features. A new \AndroidAppModule\ trait centralizes the build logic, introducing explicit configuration for application namespaces, IDs, and Lint report formats (HTML, XML, Text, SARIF). The module now supports build variants via \AndroidBuildTypeSettings\ (enabling minification and desugaring) and provides a dedicated \AndroidVirtualDevice\ model for configuring emulator instances. Additionally, data binding and resource processing are now driven by explicit argument case classes (\GenerateBindingSourcesArgs\, \ProcessResourcesArgs\), and instrumentation test results are parsed using a new \InstrumentationOutput\ parser that correctly handles test class/method tracking and status reporting.
androidlib · high confidence
BSP module API refactored into internal daemon package
The BSP-specific module APIs have been moved from the public \MainModule\ trait into the internal \mill.api.daemon.internal.bsp\ package. This change introduces dedicated traits such as \BspModuleApi\, \BspJavaModuleApi\, and \BspRunModuleApi\ to handle build target data, source reporting, and run/test environments, while also adding a \BspBootstrapBridge\ to manage the daemon-side hook for BSP requests. Users relying on the previous public API surface for BSP integration will need to adjust to this internal restructuring, which isolates BSP logic within the daemon module.
core/api/daemon/src/mill/api/daemon/internal/bsp · high confidence
Bootstrap scripts now detect and enforce GLIBC version requirements on Linux
The mill bootstrap scripts (mill.sh and mill.bat) now check the system's GLIBC version on Linux before attempting to download and run the native launcher. If the detected GLIBC version is older than the required version (defaulting to 2.34), the script falls back to using the JVM-based launcher instead of the native binary, preventing runtime failures on older Linux distributions. This change ensures compatibility with a wider range of Linux environments by automatically selecting the appropriate launcher variant based on system capabilities.
dist/scripts · high confidence
Centralized build constants and output directory management
Mill now consolidates build-time constants, environment variables, and output file paths into the \core/constants\ module. This introduces \ConfigConstants\ for build configuration keys (such as \mill-version\ and \mill-repositories\), \EnvVars\ for environment variables like \MILL\_OUTPUT\_DIR\ and \MILL\_BSP\_OUTPUT\_DIR\, and \OutFiles\ to manage the \out/\ directory structure, including support for separate BSP output directories. The change also defines \CodeGenConstants\ for build file naming conventions (e.g., \build.mill.yaml\) and \DaemonFiles\ for daemon-specific files, providing a single source of truth for these paths and settings across the client, server, and build logic.
core/constants · high confidence
Consolidate Mill API and Define modules into a single package
The Mill build system has merged the previously separate \mill.define\ and \mill.api\ namespaces into a unified \mill.api\ package. This change simplifies the public API surface for users defining builds, as tasks, modules, and helper data structures are now exported from a single location. The module configuration also reflects this consolidation by depending on the \daemon\ module and applying specific binary compatibility filters for internal implementation details.
core/api · high confidence
Example now uses Thymeleaf for HTML template rendering
The \1-simple\ example has been updated to use Thymeleaf instead of Apache Commons Text for generating HTML output. The \Foo\ class now includes a \generateHtml\ method that utilizes Thymeleaf's \TemplateEngine\ to process a simple HTML template, making the example more realistic for users learning how to integrate template engines in Java applications.
example/javalib/basic/1-simple · high confidence
Example now uses Thymeleaf for text rendering
The Java example in the repository configuration demo has been updated to replace the previous Apache Commons Text dependency with Thymeleaf. The code now imports Thymeleaf classes and uses its TemplateEngine to process a simple HTML template, making the example more realistic by demonstrating a common template engine integration rather than simple string manipulation.
example/javalib/dependencies/5-repository-config/foo · high confidence
Expanded documentation for Mill's managed JVM configuration
The \example/fundamentals/javahome\ directory now provides comprehensive examples for configuring Mill's built-in JVM management. Users can see how to use the default JVM, specify versions via \build.mill.yaml\ or build headers, and set module-specific JVMs using \jvmVersion\ in \package.mill.yaml\. The examples also demonstrate advanced configurations, including selecting specific JVM index versions, providing explicit download URLs for custom distributions, pointing to locally installed JVMs, and passing JVM-level options to the compiler worker using the \-J\ prefix in \javacOptions\. Also in this area: Paths in cache files now use symbolic root placeholders.
example/fundamentals/javahome/4-custom-module-jvm · high confidence
Improved call-graph precision in code signature analysis
The code signature analysis in the \codesig\ runner now uses precise operand stack types from ASM bytecode analysis to narrow virtual dispatch targets and expand external type searches. This change improves the accuracy of the call graph by distinguishing specific argument and receiver types at call sites, leading to more precise reachability analysis and method hash computation for build invalidation.
codesig · high confidence
Improved linker cache hit rate and log reliability in server-client mode
The Scala.js worker implementation now correctly caches linker instances by using a structural fingerprint of the configuration instead of reference equality, ensuring that incremental optimizer and emitter state is preserved across build invocations. Additionally, the worker's logger captures the correct thread-local error stream at instantiation, fixing issues where link logs were lost or misdirected when running in server-client mode.
scalajslib · high confidence
Improved task resolution error messages with typo suggestions
When a user specifies a task or module that cannot be resolved, Mill now provides clearer error messages. If the input is close to an existing name, the error suggests the correct spelling using a Levenshtein distance algorithm. Additionally, the error message now includes hints on how to list available tasks or run all tasks of a certain type, helping users recover from typos or discover available options more easily.
core/resolve · high confidence
Inspect output now includes sub-module details and updated dependency naming
The \inspect\ command now displays direct sub-modules and inherited module information for modules, providing a clearer view of the build structure. Additionally, the output reflects the migration from \ivyDeps\ to \mvnDeps\ for dependency declarations, and the \mvnDepsTree\ command has been renamed to \showMvnDepsTree\ in the inspect metadata.
integration/feature/inspect · high confidence
Internal API restructuring for declarative builds and task execution
The internal API package has been reorganized to support declarative YAML builds and improved task caching. New internal components include \Applicative\ for macro-based task composition, \Cacher\ for lock-free task definition caching, and \ModuleDepsResolver\ for resolving module dependencies from YAML configurations at runtime. The \HeaderData\ and \Located\ classes now handle YAML header parsing with source location tracking, while \PrecompiledModuleRef\ manages the instantiation and caching of precompiled modules. Additionally, \EnvSignature\ and \Cached\ classes now include classloader signature hashing to improve cache invalidation accuracy.
core/api/src/mill/api/internal · high confidence
Internal refactoring and concurrency improvements
This change introduces several internal components to improve concurrency handling and logging. A new CrossThreadRwLock allows read-write locks to be acquired and released on separate threads, supporting more flexible locking patterns in the launcher. The JsonArrayLogger is refactored to use a background thread for writing JSON entries, with synchronization to prevent race conditions during shutdown. Additionally, new internal utilities include Colors for terminal styling, LauncherOutFilesRecordStore for managing launcher process records, OutputDirectoryLayout for resolving output directories, PromptLoggerUtil for rendering status prompts, and SpanningForest for computing minimal spanning forests in dependency graphs.
internal · high confidence
Introduce lightweight bootstrap module for script-only projects
When no \build.mill\ file is present, Mill now uses a new \BootstrapRootModule\ to handle the project root. This lightweight module manages non-build-specific configuration such as BSP script ignores, CLI imports, and runtime dependencies, while providing an empty compilation result since no sources are compiled in this scenario. A companion \MillBuildRootModule\ handles the pre-processing, parsing, and compilation of actual \build.mill\ scripts when they do exist, ensuring that script-only projects can still leverage Mill's infrastructure without requiring a full build definition.
meta · high confidence
Introduces RPC-based launcher-daemon communication protocol
The launcher now communicates with the Mill daemon using a structured RPC protocol defined in \DaemonRpc.scala\. This change replaces previous mechanisms with a typed message system that supports initializing the daemon with client environment details, executing commands, and managing interactive features like stdin polling and terminal dimension retrieval. Users benefit from a more robust and standardized interaction model between the launcher and the background daemon process.
launcher · high confidence
Introduction of internal CLI configuration module
The build system now includes a new internal module at core/internal/cli that centralizes the definition of command-line arguments for Mill. This change introduces the MillCliConfig case class, which explicitly defines supported flags such as --no-daemon, --version, --ticker, --jobs, --color, --meta-level (with short form -L), and --replay-logs, along with their documentation and default values. This structural change consolidates CLI argument handling into a dedicated package, separating internal CLI utilities from user-facing build definitions.
core/internal/cli · high confidence
Kotlin incremental compilation now tracks compiler argument changes
The Kotlin incremental compilation engine now correctly invalidates its state when compiler options are modified. This ensures that changes to flags, such as enabling \-Werror\, are properly detected and trigger recompilation, preventing stale build artifacts from persisting across incremental builds.
integration/feature/kotlin-incremental-compilation · high confidence
Launcher rewritten in Scala with RPC-based daemon protocol
The Mill launcher infrastructure has been converted from Java to Scala, introducing a new RPC-based communication protocol between the client and the daemon. This change replaces the previous subprocess-based interaction with a socket-based RPC model, moving console, REPL, and JShell subprocesses into the main launcher process. The new \MillLauncherMain\ entry point handles configuration loading, repository resolution via a new \CoursierClient\, and manages daemon lifecycle with improved error logging and retry logic. Additionally, native library loading for JLine is now handled by a dedicated \JLineNativeLoader\ that caches native binaries for faster startup.
runner/launcher · high confidence
Major restructuring of the core API package with new module and execution abstractions
The \core/api/src/mill/api\ package has been significantly reorganized and expanded. New abstractions have been introduced to support advanced build features: \Cross\ and \CrossVersion\ enable multi-parameter cross-compilation and Scala version handling; \PrecompiledModule\ and \ScriptModule\ provide the foundation for YAML-backed and single-file script modules; \DefaultTaskModule\ allows specifying default CLI commands; and \DynamicModule\ supports runtime child module overriding. The \Evaluator\ and \SelectiveExecution\ traits now expose detailed APIs for task resolution, planning, and selective invalidation based on code hashes and build overrides. Additionally, utility classes like \Args\ for command-line arguments, \Debug\ for logging, \MultiBiMap\ for graph operations, and \ExecutionPaths\ for output directory management have been added or refined to support these capabilities.
core/api/src/mill/api · high confidence
Meta-level build evaluation stops at specified level
Mill now respects the --meta-level flag to halt evaluation after processing the specified meta-build level, preventing compilation errors in deeper build definitions from affecting the current operation. This allows users to resolve dependencies or inspect tasks in a meta-build without triggering errors in subsequent levels that have not yet been evaluated.
integration/feature/meta-skip-compile · high confidence
Migrate daemon server communication to RPC protocol
The Mill daemon server now uses the new RPC infrastructure for client connections, replacing the previous mechanism. This change introduces a new \MillDaemonServer\ implementation that handles connection setup, heartbeat checks, and command execution via \MillRpcWireTransport\. It supports config mismatch detection to trigger server restarts when client settings change, tracks running commands for concurrent launcher coordination, and improves shutdown handling by deferring server stops to send proper responses to clients. The migration also includes better error messaging for external shutdowns, ensuring clients receive friendly explanations instead of cryptic 'Worker wire broken' errors.
runner/server · high confidence
Mill 1.3.0 release and native launcher defaults
Mill has been updated to version 1.3.0, with the default JVM version for the build tool itself bumped to Zulu 25. The wrapper scripts (\./mill\ and \./mill.bat\) now default to downloading the native binary launcher for versions 1.0.0 and above, while retaining the \-jvm\ suffix to force the JVM launcher. Additionally, the project has standardized on the \.mill\ file extension, removed support for \.shared\ and \.sc\ extensions, and introduced an \.editorconfig\ to enforce consistent formatting across Java, Scala, and Kotlin files.
(repo-wide) · high confidence
Mill build system restructured with centralized dependency management and new module traits
The Mill build system has been restructured to use a centralized dependency management object (Deps.scala) and a hierarchy of base module traits (MillJavaModule, MillScalaModule, MillPublishJavaModule, etc.) for consistent configuration. This change introduces support for Scala 3.9.0 as the primary version, while maintaining Java 11 compatibility for specific modules. It also adds a new ExampleParser for parsing build file examples and enhances the publishing process with SNAPSHOT version handling for local test repositories.
mill-build · high confidence
MillURLClassLoader now loads classes missing from the shared classloader
The Mill classloader has been updated to resolve classes that are not present in the shared classloader, ensuring that dependencies like scalameta are correctly loaded during build evaluation. This change is verified by an integration test that successfully parses and evaluates a build script requiring external libraries.
integration/feature/mill-classloader · high confidence
New ASM-based synthetic main class generation for Scala scripts
The \libs/script\ module now uses a dedicated \asm-worker\ library to generate synthetic main classes for Scala scripts, improving compatibility with IntelliJ and the \@mainarg.main\ annotation. This change introduces new \AsmWorkerImpl\ logic and template classes to handle single and multiple main methods, ensuring that synthetic classes are correctly prefixed with \Mill\ to avoid collisions and are easily identifiable in process listings. Additionally, the Scala script module now enforces a minimum Scala version of 3.7.3 and applies the \-Ymagic-offset-header\ compiler flag to preserve line numbers when shebang lines are present.
libs/script · high confidence
New GenIdea implementation for IDEA project generation
The \runner/idea\ module now uses a new \GenIdeaImpl\ class to generate IntelliJ IDEA project files. This implementation resolves modules via internal API tasks, cleans obsolete configuration files (such as \libraries\ and \scala\_compiler.xml\), and writes the resulting XML layout to the \.idea\ directory, ensuring proper JDK detection and module resolution.
idea · high confidence
New dist/package.mill module for building and installing Mill binaries
The build system now uses a dedicated \dist/package.mill\ module to assemble and install the Mill launcher. This module generates self-executing JARs by prepending platform-specific shell scripts (Bash for Unix, batch for Windows) to the assembly JAR, handling JDK version detection (including JDK 23+ compatibility flags) and executable permissions. It also provides tasks to install these binaries locally into the user's cache (\\~/.cache/mill/download\) and local Ivy repository, ensuring the local launcher uses the correct repository configuration via environment variables.
dist · high confidence
Paths in cache files now use symbolic root placeholders
Mill now encodes known root paths (such as the output directory, workspace, and home) as symbolic placeholders (e.g., $MILL\_OUT, $WORKSPACE) in serialized cache files and JSON formatters. This change makes cache files relocatable, allowing them to be shared or moved between different machines or directory structures without breaking. The implementation introduces a \MappedRoots\ system to manage these mappings and updates \PathRef\ serialization to use these encoded paths, while ensuring local-only communications (like test runner arguments) remain as absolute paths. Also in this area: New Kotlin packaging examples for native images, assembly, and repackaging.
example/javalib/web/8-vaadin, example/kotlinlib/packaging/4-repackage-config, example/pythonlib/basic/4-bare-modules · high confidence
Play 2.6 route compiler worker deprecates static generator
The new RouteCompilerWorker for Play 2.6 now prints a deprecation warning when the static routes generator is used, indicating it will be removed in version 2.7.0, while continuing to support the injected routes generator.
contrib/playlib/worker/2.6 · high confidence
Port ollama-js example to Mill build tool
The build system for the ollama-js example has been migrated from its previous configuration to the Mill build tool. This change introduces a new build.mill file that defines the project structure, including TypeScript compilation settings, npm dependencies (such as whatwg-fetch and unbuild), and custom tasks to bundle the library and prepare it as an unmanaged dependency for the included example projects.
example/thirdparty/ollama-js · high confidence
Precompiled YAML modules are now discoverable at the root level
This change ensures that top-level precompiled modules defined in YAML (such as \foo\ and \bar\) are correctly exposed and resolvable within the build context. Users can now successfully use wildcard selectors like \\\ and \\\_\ to resolve these modules, and cross-module dependencies between precompiled siblings (e.g., \bar\ depending on \foo\) are properly resolved. Additionally, the \BuildCtx.rootModule\ and \PrecompiledModule.all\ APIs now correctly enumerate all top-level precompiled YAML modules, making them visible to tasks and scripts that rely on this discovery.
integration/feature/precompiled-root-codegen · high confidence
Python toolchain now uses uv for dependency management and publishing
The Python module system has been updated to use the \uv\ toolchain instead of the previous implementation. This change introduces \UvModule\ to manage the \uv\ executable, handle virtual environments, and resolve Python dependencies (including standard packages, local projects, wheels, and requirements files) via \uv pip install\. Additionally, \PublishModule\ now generates \pyproject.toml\ files configured to use \uv\_build\ as the build backend, enabling the creation of source distributions and wheels through \uv build\. Users relying on the previous Python build and publish tasks will need to adapt to this new \uv\-based workflow.
pythonlib · high confidence
Recompile Discover macro when extends clauses change
The build system now forces recompilation of the Discover macro when extends clauses in .mill.yaml files are modified. This ensures that changes to module inheritance hierarchies (such as switching a module from JavaModule to ScalaModule) are correctly detected and applied during subsequent builds, preventing stale compilation artifacts.
integration/feature/extends-invalidation, integration/feature/package-mill-extends-invalidation · medium confidence
Redesigned documentation site with custom search and version warnings
The Mill documentation site has been updated with a new Antora-based UI that includes a custom client-side search feature (powered by Lunr.js) with highlighted results, a yellow warning banner that appears when viewing old or unstable documentation versions, and a streamlined navigation menu that keeps top-level sections open by default. The site also features a new SVG logo, a fixed-position toolbar, and a cleaner footer, while the build system now pins Antora to version 3.1.12 and configures specific example versions for the generated content.
website · high confidence
Refactor resolve core to use structured Result types and add .super task support
The resolve module now uses a dedicated \Result\ sealed trait with \Success\, \NotFound\, and \Error\ cases instead of generic exceptions or Either types, providing structured failure metadata. It also adds support for \.super\ task selectors, allowing users to invoke overridden parent tasks via syntax like \Module.task.super\. Additionally, module instantiation is cached to improve resolution performance.
resolve · high confidence
Refactored BSP worker internals and added build-target change notifications
The BSP module has been restructured to improve stability and responsiveness. A new \BspEvaluators\ class now centralizes module discovery and evaluation logic, while a new \BspConfigJson\ case class handles serialization of BSP configuration data. Additionally, a \ChangeNotifier\ component has been introduced to automatically notify BSP clients when build targets are created, modified, or deleted, ensuring the IDE stays in sync with the build definition.
bsp · high confidence
Renames internal daemon API package from \`mill.api.shared\` to \`mill.api.daemon.internal\`
The internal API package has been renamed from \mill.api.shared\ to \mill.api.daemon.internal\. This change affects the internal structure of the daemon API, moving traits and classes such as \BaseModuleApi\, \EvaluatorApi\, and \LauncherLocking\ into the new package. This is a refactoring of the internal API surface and does not change the public API or user-facing behavior.
core/api/daemon/src/mill/api/daemon/internal · high confidence
Renames mill.api.shared to mill.api.daemon and restructures daemon API
The Mill daemon API package has been renamed from \mill.api.shared\ to \mill.api.daemon\. This change reorganizes core daemon utilities—including the logging interface (\Logger\), result handling (\Result\), classloader management (\MillURLClassLoader\), and task segmentation (\Segments\)—into the new package namespace to better reflect their role in the launcher/daemon infrastructure.
core/api/daemon/src/mill/api/daemon · high confidence
Skip execution of overridden task dependencies
When a task is completely overridden via YAML configuration (using a non-append override), the build system now skips the execution of its declared dependencies. Previously, dependencies would run even though the original task body was replaced, which was inefficient and potentially incorrect. This change ensures that only the overridden task's new implementation is executed, improving performance and correctness for users relying on YAML-based task overrides.
integration/feature/yaml-config-override-deps · high confidence
Split declarative examples into individual pages
The documentation examples for cross-version and cross-platform publishing have been reorganized into separate, dedicated example pages. This change improves the clarity and navigability of the documentation by isolating specific use cases, such as platform-specific JSON parsing and version-specific text rendering, into their own distinct files rather than grouping them in a single large document.
(repo-wide) · high confidence
Task selectors now include module prefixes for scripts and external modules
Task selectors for ScriptModules and ExternalModules now include their module prefixes (e.g., \Script.java:run\, \mill.scalalib.scalafmt.ScalafmtModule/reformatAll\) in the output. This ensures that tasks from these module types are distinct and copy-pasteable, resolving ambiguity when interacting with scripts or external dependencies that are not part of the main \build.mill\ module hierarchy.
integration/feature/script-external-task-rendering · high confidence
Task type becomes invariant
The \Task\[T\]\ type is now invariant, meaning it no longer supports subtyping relationships between different task types. This change affects how tasks are composed and passed around in build definitions, requiring exact type matches rather than relying on variance rules.
api · high confidence
Unified caching infrastructure for workers and classloaders
Mill now uses a single \CachedFactoryBase\ implementation to manage object caching, replacing the previous separate \CachedFactory\ and \RefCountedCache\ classes. This change introduces a unified LRU and reference-counted caching strategy that is used by the new \RefCountedClassLoaderCache\ to safely share \URLClassLoader\ instances between workers, and by \CachedFactory\ for general-purpose caching with LRU eviction. Additionally, the \libs/util\ module now includes a \CoursierConfig\ case class to centralize repository, credential, and cache settings, and a \CoursierTickerResolutionLogger\ to provide real-time download progress updates during dependency resolution.
libs/util · high confidence
Updated Java examples to use YAML build files and mvnDeps
The example projects in example/javalib/basic have been migrated to use the new build.mill.yaml and package.mill.yaml configuration formats, replacing the previous build.sc files. This change also updates dependency declarations to use mvnDeps instead of the deprecated ivyDeps, and demonstrates modern Mill features such as nested modules, Maven-compatible source layouts, and single-file script modules.
example/javalib/basic · high confidence
Updated Kotlin library example to use modern Mill syntax and repository configuration
The example in \example/kotlinlib/dependencies/5-repository-config\ has been updated to reflect current Mill conventions. It now uses \mvnDeps\ instead of the deprecated \ivyDeps\, defines repositories via the \def repositories\ task rather than \def repositoriesTask\, and demonstrates how to customize the build by extending \JvmWorkerModule\ and \CoursierModule\ with a custom worker module (\CustomJvmWorkerModule\) that is referenced via \ModuleRef\. The example also specifies Kotlin version 2.2.20 and includes dependencies for Clikt and kotlinx-html.
example/kotlinlib/dependencies/5-repository-config · high confidence
Updated example to use modern Mill syntax and dependencies
The repository configuration example has been updated to reflect current Mill conventions. It now uses \mvnDeps\ instead of the deprecated \ivyDeps\, \Seq\ instead of \Agg\, and the \def repositories\ task instead of \def repositoriesTask\. Additionally, the example dependency has been switched from Apache Commons Text to Thymeleaf to provide a more realistic use case, and the SLF4J NOP binding is included to suppress warnings.
example/javalib/dependencies/5-repository-config · high confidence
Updated migration examples for Maven and Gradle projects
The migration documentation examples for Maven and Gradle projects have been updated to reflect current import behaviors. The Maven example (3-maven-complete-large) now demonstrates a complete migration of a multi-module Java project, including specific compilation and test commands for subprojects. The Gradle examples (4-gradle-complete and 5-gradle-incomplete) have been revised to use newer source repositories (fluency and mockito respectively) and updated usage instructions, with the incomplete example now explicitly showing a compilation error to illustrate manual tweaking requirements.
example/migrating/javalib/3-maven-complete-large · high confidence
Updated module fundamentals example with source directory demonstrations
The \6-modules\ example in the Mill fundamentals documentation has been refreshed to include concrete demonstrations of how \moduleDir\ influences source file resolution. The \build.mill\ file now contains examples using \Task.Source\ with subpath string literals and illustrates how nested modules inherit source directories. Corresponding source files have been added under \bar/src\, \bar/src2\, \outer/sources\, \outer/inner/sources\, and \outer2/nested/sources\ to validate these behaviors, ensuring the documentation accurately reflects how Mill locates input files relative to the module hierarchy.
example/fundamentals/modules/6-modules · high confidence
Updated publishing example source files
The publishing examples for Java, Kotlin, and Scala have been updated to include specific source files (Bar.java, Bar.kt, and Bar.scala) that print the Java version upon execution. This replaces previous placeholder or differently named source files, ensuring the examples demonstrate a consistent output message related to the published artifact.
example/javalib/publishing/1-publishing-yaml, example/kotlinlib/publishing/1-publishing-yaml, example/scalalib/publishing/1-publishing-yaml · high confidence
Validation of package declarations in .mill build files
The build system now validates that the package declaration in .mill files matches the directory structure. If a mismatch is detected, such as a file in a subdirectory declaring an incorrect package, the build will fail with a clear error message indicating the expected package name.
integration/failure/invalid-package-declaration · medium confidence
YAML environment variables preserve original string formatting
The YAML configuration parser now preserves the original string representation of scalar values in the \forkEnv\ section, rather than converting them to their native types (such as booleans or numbers) and back. This ensures that values like \true\, \1.200\, or \.inf\ are passed to subprocesses exactly as written in the YAML file, preventing unintended type coercion or formatting loss.
integration/feature/yaml-config · high confidence
Fixes
1 commit (1 fix) fixing integration/scheduled/migrating
A fix in integration/scheduled/migrating — 1 commit (1 fix), 3 files: “Quarkus: scheduled run fixes and enhancements (\#7831)” (refs \#7831).
integration/scheduled/migrating · medium confidence · unverified
Fix compiler bridge compilation for Scala 2.13.2 on older JVMs
Resolves an issue where compiling the compiler bridge for Scala 2.13.2 failed on Mill's own JVM because the version lacks a pre-compiled bridge and requires the \-release\ flag to read class files from older JVMs. The fix ensures that when targeting an older JVM (e.g., Java 11), the necessary \-release\ argument is passed to scalac, allowing successful compilation, while correctly reporting failures when the flag is missing for the bridge itself.
integration/feature/compiler-bridge-older-jvm · high confidence
Fix cross-file references between helper files
Resolved an issue where Mill's code generation failed to correctly resolve references between helper files (such as \ModuleA.mill\, \ModuleB.mill\, and \build.mill\) located at various levels of the build structure. This fix ensures that traits and tasks defined in one file can be properly accessed and executed from others, including nested packages and local object definitions, without breaking the build.
integration/feature/cross-file-references · high confidence
Fix incremental compilation cold-rebuilds on Scala 3 when TTY state changes
Resolves an issue where switching between interactive and non-interactive terminals (e.g., CI vs. local shell) caused Zinc to invalidate the entire module and recompile all sources, even if only one file changed. This occurred because the \-color:never\ flag, injected based on TTY presence, was baked into the incremental compilation cache (MiniSetup), causing a mismatch on subsequent builds. The fix ensures that incremental compilation remains valid regardless of the client's color/TTY settings.
integration/feature/zinc-incremental-scala3-color, integration/feature/zinc-incremental-scala3-color/resources · high confidence
Fix spurious compilation error in meta-build incremental overrides
Resolves a build failure where modifying a build file caused a 'inherits conflicting members' error when traits overriding javacOptions were loaded from TASTy. This fix ensures that incremental recompilation of the meta-build correctly handles method overrides, allowing users to safely modify their build definitions without encountering spurious compilation errors.
integration/feature/meta-build-incremental-overrides · high confidence
Fix synthetic MillScriptMain class collision in custom script modules
This change resolves a class collision issue involving the synthetic \MillScriptMain\ class when using custom module implementations in Mill scripts. The diff introduces three new example modules (\LineCountJavaModule\, \LineCountKotlinModule\, and \LineCountScalaModule\) that extend \mill.script.JavaModule\, \mill.script.KotlinModule\, and \mill.script.ScalaModule\ respectively. These examples demonstrate the correct way to define custom script modules without triggering the collision, ensuring that users can safely extend these base classes in their own build scripts.
(repo-wide) · medium confidence
Updated Python and TypeScript extension examples
The example code in the \extending\ directory has been updated to demonstrate module structures and dependency handling. Python examples now include basic module scripts, simple arithmetic functions for dependency examples, and usage of external libraries like pandas and numpy. TypeScript examples have been similarly updated to show module interfaces, dependency imports (including an npm package, \immutable\), and command-line argument handling.
(repo-wide) · high confidence
Test coverage
1 commit adding/updating tests in integration/dedicated/full-run-logs/resources/unparseable-escape/test; Add integration test for Scoverage module with mvnDeps syntax; Add integration tests for Mill Eclipse generator with new sample projects; Add large-project integration test; Added BSP server integration test fixtures; Added JMH benchmark test resources; Added Java testing examples for JUnit 4, JUnit 5, and parallel execution; Added Kotlin incremental compilation integration tests; Added Kotlin testing example modules; Added Kotlin unit tests for HTML generation; Added Playwright integration test for the React app heading; Added Python test suites for example libraries; Added Python testing examples for unit and integration suites; Added Scala callgraph test cases for iterators and collections; Added TestNG demo test resources; Added TypeScript test suite examples for Mill; Added comprehensive unit tests for the task resolution engine; Added concurrency integration tests for BSP and CLI interactions; Added demo test cases for TestNG and LambdaTest integration; Added example integration test suites for Cypress and Playwright; Added example tests for Java, Kotlin, and Scala testing patterns; Added initial Groovy test suites and examples; Added initial test suite for Python linting coverage example; Added integration test for Hello Spring Boot example; Added integration test for Java bootstrap without JAVA\_HOME; Added integration test for clean command daemon file preservation; Added integration test for rapid startup/shutdown cycles; Added integration test for root module compile errors; Added integration test for root subfolder module collision; Added integration tests for BSP server and module behavior; Added integration tests for BSP server error handling; Added integration tests for BSP server projects and daemon crash handling; Added integration tests for BSP server reload behavior; Added integration tests for GPG key initialization and publishing; Added integration tests for HTML generation; Added integration tests for Java module code-signing and Mill options parsing; Added integration tests for SBT-to-Mill migration of major Scala libraries; Added integration tests for ScalaPB module features; Added integration tests for YAML configuration error reporting; Added integration tests for YAML header key validation and meta-conflict errors; Added integration tests for YAML header validation errors; Added integration tests for YAML script error reporting; Added integration tests for \mill init\ migration and example workflows; Added integration tests for auxiliary class file cleanup; Added integration tests for code signature handling in multi-file Mill builds; Added integration tests for compile and parse error reporting; Added integration tests for daemon classloader and thread leak hygiene; Added integration tests for full run log output and coloring; Added integration tests for module definition location restrictions; Added integration tests for module initialization error handling; Added integration tests for multi-level build invalidation and background run processes; Added integration tests for multi-mode editing scenarios; Added integration tests for nested module code-signature invalidation; Added integration tests for output directory and concurrent shutdown behavior; Added integration tests for precompiled module configuration validation; Added integration tests for root module \package\ object validation; Added integration tests for runtime error line number accuracy; Added integration tests for selective execution watch mode; Added integration tests for the OS filesystem checker; Added integration tests for the watch mode source input handling; Added regression test for Zinc incremental compilation with SbtModule; Added server implementations for Cypress and Playwright integration test suites; Added test case for Scala iterator inheritance and external filter call graph; Added test case for Scala parser call graph analysis; Added test case for parallel merge sort call graph analysis; Added test cases for method hash stability with sourcecode.Line; Added test cases for precise callgraph analysis of external constructors and static method arguments; Added test cases for the code signature runner's call graph analysis; Added test coverage for Greet functionality; Added test coverage for JavaScript/TypeScript calculator examples; Added test for TypeScript module test dependencies; Added test for YAML header placement validation; Added test for YAML header syntax error handling; Added test for directory probe watch behavior; Added test for invalid meta-module build definition; Added test for local project dependency inheritance; Added test resource for Docker contrib module; Added test resource for ProGuard integration; Added test resource templates for Play multi-project and single-project skeletons; Added test resources for Scoverage BuildInfo and module dependency inheritance; Added test resources for multi-language scoverage coverage; Added test suite for the Calculator class in the qux example; Added test suite for the Testkit module; Added test suites for JavaScript/TypeScript examples; Added test suites for basic Java and Scala examples; Added test suites for the bar module across Java, Kotlin, and Scala examples; Added testing examples for Mill Scala projects; Added tests for BuildInfo Scala integration; Added tests for BuildInfo support in Java, Kotlin, and Scala modules; Added tests for CycloneDX SBOM generation; Added tests for Docker module configuration and build options; Added tests for JVM version change detection; Added tests for JVM version validation and Dagger dependency injection; Added tests for JmhModule benchmark listing; Added tests for Kapt-based MapStruct mapper generation; Added tests for Kotlin resource loading in the foo module; Added tests for MillMain0 argument parsing and version resolution; Added tests for Play integration modules; Added tests for ProxyStream data integrity and build header parsing; Added tests for Python resource loading in the foo example module; Added tests for Result.sequence and Result.traverse; Added tests for Scala Native examples; Added tests for Scoverage coverage validation and report generation; Added tests for Twirl compilation and inclusive dot support; Added tests for bootstrap script version parsing and provenance headers; Added tests for classpath and filesystem resource access in the foo module; Added tests for client-server daemon interaction; Added tests for cross-version and cross-platform publishing examples; Added tests for cross-version and cross-platform publishing examples; Added tests for improved call graph analysis precision; Added tests for repackage configuration examples; Added tests for resource file access in the foo example module; Added tests for resource loading in the foo module; Added tests for shell argument parsing, background run logging, and worker code-change handling; Added tests for the AutoOverride compiler plugin; Added tests for the Flyway module; Added tests for the OWASP Dependency Check module; Added tests for the Spark Hello World example; Added tests for the Spark example's summary statistics computation; Added tests for the new mill.api.opt API; Added unit and integration tests for sentiment analysis and server endpoints; Added unit and integration tests for the Spring Boot Todo example; Added unit test for JNI HelloWorld example; Added unit tests for Flask example applications; Added unit tests for Foo.getLineCount; Added unit tests for GitLab module token resolution and publishing; Added unit tests for JavaScript/TypeScript library examples; Added unit tests for Kotlin JNI example; Added unit tests for Python library examples; Added unit tests for TestNG integration; Added unit tests for annotation processor examples; Added unit tests for bar and foo Python modules; Added unit tests for bar, foo, and qux modules; Added unit tests for distribution example archives; Added unit tests for example Java, Kotlin, and Scala libraries; Added unit tests for internal core components; Added unit tests for task execution, cross-module resolution, and locking behavior; Added unit tests for the Bar CLI builtin command; Added unit tests for the Calculator class; Added unit tests for the PySpark hello-world example; Added unit tests for the generateUser function; Added visibility test fixtures for API compatibility checks; Example demonstrating test module dependencies in Python; Expanded integration test fixtures for IntelliJ IDEA generation; Integration test for Maven dependency worker invalidation via header comments; Integration test for shutdown exit code behavior; Integration test for system Java version directive; Integration tests for Coursier environment variable handling; Integration tests for selective execution code and input change detection; Integration tests for subprocess stdout/stderr inheritance and interleaving; New integration tests for BSP server concurrency, module resolution, and reload behavior; New test utilities for verifying Sonatype Central snapshot publishing; Test for JVM version validation error messages.
Dependencies
Gatling example build migrated to Mill with explicit dependency management
The Gatling example project has switched its build system to Mill, introducing a new \build.mill\ file that explicitly defines all compile, test, and documentation dependencies (such as Netty, Jackson, and Gatling shared modules) using Mill's \mvn\ syntax. This change replaces the previous build configuration, standardizing how third-party libraries are resolved and managed for this example.
example/thirdparty/gatling · high confidence
Updated init templates for Gradle, Maven, Python, and CycloneDX references
The \libs/init\ test resources have been updated to reflect current best practices and tooling versions. Gradle templates now target Gradle 9.0.0 (with Kotlin DSL and configuration cache), 8.0, 7.0, and 6.0, while Android templates use AGP 9.3.1 and Kotlin 2.0.20. Maven templates for Micronaut and Spring Boot have been updated to their latest major versions (Micronaut 5.0.2, Spring Boot 4.0.6). Python examples now use \uv\_build\ 0.12.12 and \numpy\ 2.1.2, and the CycloneDX reference POM has been refreshed with modern dependency versions.
(dependencies) · high confidence
Housekeeping
Core module package declaration added; Document build module access from meta-build sources.
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 48 → 49 (+1.1)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 60 → 59 (-0.5)
- Architecture 82 → 81 (-1.0)
- Maturity 54 → 58 (+3.8)
- Readiness 69 → 66 (-2.0)
- Security 67 → 64 (-2.3)
- Accessibility 34 → 36 (+1.2)
- Performance 76 → 74 (-1.9)
Resolved (39)
- Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
- Duplicated block (10 lines × 2) (example/kotlinlib/script/3-web-server/WebServer.kt)
- Duplicated block (10 lines × 2) (mill-build/src/millbuild/MillStableJavaModule.scala)
- Duplicated block (10–13 lines × 3) (example/scalalib/web/2-todo-webapp/src/WebApp.scala)
- Duplicated block (11 lines × 2) (example/kotlinlib/web/5-webapp-kotlinjs/client/src/ClientApp.kt)
- Duplicated block (11 lines × 2) (integration/dedicated/full-run-logs/src/FullRunLogsUtils.scala)
- Duplicated block (13 lines × 2) (example/kotlinlib/basic/6-custom-build-logic/foo/src/foo/Foo.kt)
- Duplicated block (15 lines × 2) (example/kotlinlib/linting/5-kover/bar/src/BarKotlin.kt)
- Duplicated block (16 lines × 2) (example/androidlib/kotlin/2-compose/app/src/main/kotlin/com/example/composetest/ui/theme/Theme.kt)
- Duplicated block (22 lines × 2) (example/kotlinlib/web/5-webapp-kotlinjs/src/WebApp.kt)
- Duplicated block (26 lines × 2) (example/androidlib/kotlin/1-hello-kotlin-declarative/app/src/main/java/com/helloworld/app/MainActivity.kt)
- Duplicated block (30–32 lines × 2) (example/kotlinlib/web/5-webapp-kotlinjs/src/WebApp.kt)
- Duplicated block (5 lines × 4) (example/kotlinlib/basic/2-module-deps/bar/src/bar/Bar.kt)
- Duplicated block (6 lines × 2) (libs/init/gradle/exportplugin/src/mill/main/gradle/BuildModelBuilder.scala)
- Duplicated block (6 lines × 2) (libs/scalajslib/config/src/mill/scalajslib/config/ScalaJSConfigModule.scala)
- Duplicated block (8 lines × 2) (example/kotlinlib/module/1-basic-config/custom-src/Foo2.kt)
- Duplicated block (8 lines × 2) (example/kotlinlib/web/5-webapp-kotlinjs/client/src/ClientApp.kt)
- Duplicated block (8 lines × 3) (example/kotlinlib/basic/1-simple/src/foo/Foo.kt)
- FileToStreamTailer.run (cognitive 33) (libs/daemon/client/src/mill/client/FileToStreamTailer.scala)
- High secret: WD-SECRET-0004 (example/androidlib/java/1-hello-world/app/releaseKey.jks)
- …and 19 more
New (204)
- Dependency hygiene PARTLY measured — Gradle build resolved part of the dependency graph, currency reported but not scored
- Duplicated block (10 lines × 2) (example/kotlinlib/script/3-web-server/WebServer.kt)
- Duplicated block (11 lines × 2) (example/kotlinlib/web/5-webapp-kotlinjs/client/src/ClientApp.kt)
- Duplicated block (13 lines × 2) (example/kotlinlib/basic/6-custom-build-logic/foo/src/foo/Foo.kt)
- Duplicated block (13–14 lines × 2) (libs/kotlinlib/worker/src/mill/kotlinlib/worker/impl/JsCompileImpl.scala)
- Duplicated block (15 lines × 2) (example/kotlinlib/linting/5-kover/bar/src/BarKotlin.kt)
- Duplicated block (15 lines × 2) (example/kotlinlib/web/5-webapp-kotlinjs/src/WebApp.kt)
- Duplicated block (16 lines × 2) (example/androidlib/kotlin/2-compose/app/src/main/kotlin/com/example/composetest/ui/theme/Theme.kt)
- Duplicated block (17 lines × 2) (example/kotlinlib/web/5-webapp-kotlinjs/src/WebApp.kt)
- Duplicated block (26 lines × 2) (example/androidlib/kotlin/1-hello-kotlin-declarative/app/src/main/java/com/helloworld/app/MainActivity.kt)
- Duplicated block (5 lines × 4) (example/kotlinlib/basic/2-module-deps/bar/src/bar/Bar.kt)
- Duplicated block (8 lines × 2) (example/kotlinlib/module/1-basic-config/custom-src/Foo2.kt)
- Duplicated block (8 lines × 2) (example/kotlinlib/web/5-webapp-kotlinjs/client/src/ClientApp.kt)
- Duplicated block (8 lines × 3) (example/kotlinlib/basic/1-simple/src/foo/Foo.kt)
- Edited copies of one member (3 members, 12+ corresponding lines) (libs/androidlib/src/mill/androidlib/AndroidKotlinModule.scala)
- Edited copies of one member (3 members, 13+ corresponding lines) (libs/scalajslib/src/mill/scalajslib/ScalaJSModule.scala)
- Edited copies of one member (3 members, 14+ corresponding lines) (libs/scalajslib/config/src/mill/scalajslib/config/ScalaJSConfigModule.scala)
- Edited copies of one member (3 members, 15+ corresponding lines) (contrib/flyway/src/mill/contrib/flyway/FlywayModule.scala)
- Edited copies of one member (3 members, 15+ corresponding lines) (libs/androidlib/src/mill/androidlib/AndroidAppModule.scala)
- Edited copies of one member (3 members, 15+ corresponding lines) (libs/pythonlib/src/mill/pythonlib/RuffModule.scala)
- …and 184 more
Changes since last survey
- 82 commits — 74 feature/other, 8 fixes
By area
- mill-build/src — 28 commits
- (root) — 9 commits
- libs/javalib — 8 commits
- integration/feature — 4 commits
- .github/workflows — 3 commits
- core/api — 3 commits
- core/internal — 3 commits
- example/androidlib — 2 commits
- example/groovylib — 2 commits
- example/kotlinlib — 2 commits
- integration/dedicated — 2 commits
- contrib/buildinfo — 1 commit
- contrib/owaspdependencycheck — 1 commit
- contrib/package.mill — 1 commit
- core/exec — 1 commit
- example/reproduce — 1 commit
- integration/scheduled — 1 commit
- libs/androidlib — 1 commit
- libs/daemon — 1 commit
- libs/groovylib — 1 commit
Notable commits
- fix: Add a regression test for relaying a line with an unparseable escape (#7847) (#7879)
- fix: Fix ANSI state bleed in PromptLogger (#7909)
- fix: Fix incomplete escape sequence handling in PromtLogger (#7869)
- fix: GenIdea: Fix meta-build module name in scala_compiler.xml (#7848)
- fix: Kotlin: Fix API deprecations (#7881)
- fix: Quarkus: Conditional ext dependencies and fixes (#7832)
- fix: Quarkus: scheduled run fixes and enhancements (#7831)
- fix: fix(android): make createAndroidVirtualDevice depend on emulatorExe (#7815)
- change: Accept module names in showMvnDepsTree --whatDependsOn (#7896)
- change: Add 1.4.0-M2 to documentation page (#7891)
- change: Add IntegrationTester.timing to access task timings/profile (#7862)
- change: Add a FIXME
- change: Android: Bump cmdline tools to 22 (#7866)
- change: CI: Update coursier/cache-action from 8 to 9 (#7878)
- change: Cache some internal task used for dependency resolution with Coursier (#7914)
- change: Doc update for --import option (#7849)
- change: Document the jvmVersion better (#7877)
- change: Don't limit shown test failures to 5 in non-CI environments (#7899)
- change: Drop mtime and always compute and keep a quickSig for PathRef (#7837)
- change: Extract Segments.segmentSeparator (#7906)
- …and 62 more
Architecture
- Containers 0 added · 0 removed · contexts 13 added · 9 removed · edges 44 added · 128 removed
Added bounded contexts (13)
- core/api/daemon
- example/scalalib/linting/5-spotless
- example/scalalib/script/4-database
- integration/feature/zinc-incremental-compilation/resources
- integration/feature/zinc-incremental-scala3-color/resources
- libs/daemon/server
- mill-build
- runner/daemon
- runner/server
- eval
- meta
- rpc
- sbom-example-reference
Removed bounded contexts (9)
- core/api/daemon
- example/scalalib/linting/5-spotless
- example/scalalib/script/4-database
- integration/feature/zinc-incremental-compilation/resources
- integration/feature/zinc-incremental-scala3-color/resources
- libs/daemon/server
- mill-build
- runner/daemon
- runner/server
Added dependency edges (44)
- core/api/daemon → example/scalalib/linting/5-spotless
- libs/daemon/server → client
- mill-build → javalib
- runner/daemon → core/api/daemon
- runner/daemon → runner/server
- runner/daemon → api (coupling)
- runner/daemon → client
- runner/daemon → internal (coupling)
- runner/daemon → launcher
- runner/daemon → rpc
- runner/server → core/api/daemon
- runner/server → libs/daemon/server (coupling)
- runner/server → rpc
- androidlib → core/api/daemon (coupling)
- api → core/api/daemon (coupling)
- bsp → core/api/daemon (coupling)
- contrib → core/api/daemon
- eclipse → core/api/daemon
- eval → core/api/daemon
- eval → api (coupling)
- …and 24 more
Removed dependency edges (was a dependency, now gone) (128)
- androidlib → contrib (coupling)
- androidlib → core/api/daemon (coupling)
- androidlib → example/scalalib/linting/5-spotless
- api → codesig
- api → contrib (coupling)
- api → core/api/daemon (coupling)
- api → example/scalalib/linting/5-spotless
- api → init (coupling)
- bsp → api
- bsp → codesig
- bsp → contrib
- bsp → core/api/daemon (coupling)
- bsp → example/scalalib/linting/5-spotless
- bsp → scalanativelib
- bsp → testrunner (coupling)
- client → api
- client → core/api/daemon (coupling)
- codesig → core/api/daemon (coupling)
- codesig → example/scalalib/linting/5-spotless
- codesig → internal (coupling)
- …and 108 more
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
com-lihaoyi/mill 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 9a3aabec8f7409404f0cbcedf1e97a6afa161c86 — 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.