https://mill-build.org/mill/index.html

[logo-white] The Mill Build Tool
[                    ]
GitHub Blog API Issues Discuss

  * 
      + Building Java with Mill
          o Java Module Configuration
          o Java Library Dependencies
          o Testing Java Projects
          o Linting Java Projects
          o Java Packaging & Publishing
          o Java Build Examples
          o Java Web Project Examples
      + Building Scala with Mill
          o Scala Module Configuration
          o Scala Library Dependencies
          o Testing Scala Projects
          o Linting Scala Projects
          o Scala Packaging & Publishing
          o Scala Build Examples
          o Scala Web Project Examples
          o Scala Native Examples
          o Spark Examples
      + Building Kotlin with Mill
          o Kotlin Module Configuration
          o Kotlin Library Dependencies
          o Testing Kotlin Projects
          o Linting Kotlin Projects
          o Kotlin Packaging & Publishing
          o Kotlin Web Project Examples
      + Experimental Platform Support
          o Building Android Apps
              # Android Java Projects
              # Android Kotlin Projects
              # Linting Android Projects
          o Building Python with Mill
              # Python Module Configuration
              # Python Library Dependencies
              # Linting Python Projects
              # Testing Python Projects
              # Python Packaging & Publishing
              # xref:pythonlib/web-examples.adoc
          o Building Javascript with Mill
              # Typescript Library Dependencies
              # Typescript Module Configuration
              # Testing Typescript Projects
              # Linting Typescript Projects
              # Typescript Packaging & Publishing
              # JavaScript Build Examples
      + Why Use Mill?
          o Case Study: Mill vs Maven
          o Case Study: Mill vs Gradle
          o Case Study: Mill vs sbt
      + The Mill CLI
          o Installation & IDE Setup
          o Mill Command-Line Flags
          o Built-in Commands
          o Task Query Syntax
          o Build Header Config
      + Migrating to Mill
          o Importing Maven Projects
          o Importing Gradle Projects
          o Importing sbt Projects
      + Mill Fundamentals
          o Tasks
          o Modules
          o The Output Directory
          o Library Dependencies in Mill
          o Cross Builds
          o Bundled Libraries
          o Configuring JVM Versions
      + Extending Mill
          o Import Libraries and Plugins
          o Contrib Plugins
              # Artifactory
              # BuildInfo
              # Codeartifact
              # Docker
              # Flyway
              # Gitlab
              # JMH
              # Play Framework
              # Proguard
              # ScalaPB
              # Scoverage
              # Sonatype Central (Plugin Moved to Scalalib)
              # TestNG
              # Twirl
              # Version file
          o Third-Party Plugins
          o Running Dynamic JVM Code
          o Writing Mill Plugins
          o The Mill Meta-Build
          o Example: Typescript Support
          o Example: Python Support
      + Large Builds and Monorepos
          o Selective Test Execution
          o Multi-File Builds
          o Multi-Language Builds
      + Mill In Depth
          o The Mill Evaluation Model
          o Caching in Mill
          o Parallelism in Mill
          o The Mill Process Architecture
          o Mill Sandboxing
          o Mill Design Principles
          o Why does Mill use Scala?
      + Reference
          o Mill API Reference
          o Changelog
          o Talks & Blog Posts

Mill Documentation 1.0.0

  * Mill Documentation
      + main-branch
      + 1.0.0
      + dev-1.0.0-13-69124b
      + 0.12.14
      + 0.11.13
      + 0.10.15
      + 0.9.12
  * The Mill Build Engineering Blog

Mill: A Better Build Tool for Java, Scala, & Kotlin

d Maven Central Version

Mill is a build tool that tries to improve upon the tools
traditionally used in the JVM ecosystem:

  * Mill builds the same Java project 3-6x faster than Maven or
    Gradle due to aggressive caching & parallelism

  * Mill's rich featureset means less fiddling with plugins, since
    everything needed for development is built in

  * Mill builds are easily explorable in your IDE, letting you work
    on them without constantly googling for help

Although the Java compiler is very fast and the Java language is easy
to learn, JVM build tools have a reputation for being sluggish and
confusing. Mill tries to offer a better alternative, its
object-oriented builds reducing the learning curve and letting your
build system take full advantage of the Java platform's performance,
usability, and IDE support.

If you prefer a video introduction to Mill, see:

  * Video: Better Java Builds with the Mill Build Tool, GeeCon Krakow
    16 May 2025

  * Video: Solving Scala's Build Problem with the Mill Build Tool, SF
    Scala Meetup 22 April 2025

For more discussion on the motivation behind the project, see Why Use
Mill?

 Getting Started

To get started using Mill for the first time, or migrating an
existing JVM codebase (built using Maven, Gradle, or SBT) to Mill,
see:

  * Installation & IDE Setup   * Migrating to Mill

Or see the language-specific introductory documentation linked below:

java Java with Mill scala Scala with Mill kotlin Kotlin with Mill

 Mill Features

  * Performance: Mill automatically caches and parallelizes build
    tasks and tests to keep local development fast, incrementally
    builds assembly jars to speed up manual testing workflows, and
    shortens CI times with selective test execution to only run the
    subset of tests necessary to validate a code change.

  * Builtins: Mill has builtin support for most common workflows: not
    just compile/run/test, but also managing JVM versions, linting,
    publishing, building executable assemblies, native binaries or
    installers, etc. This lets you focus on your actual project and
    spend less time fiddling with tooling and plugins.

  * Maintainability: Mill's config and custom logic is written in
    concise type-checked JVM code, with an immutable module tree and
    task graph. This catches configuration issues early, and helps
    both humans and IDEs (IntelliJ or VSCode) understand your Mill
    build better than any other build system

  * Flexibility: Mill's tasks and modules allow anything from adding
    simple build steps, up to entire language toolchains. You can
    import any JVM library in your build, use Mill's rich ecosystem
    of Third-Party Mill Plugins, or write plugins yourself and
    publish them to Maven Central for others to use.

  * Scalability Mill scales well from small projects to large
    monorepos with hundreds of modules and multiple languages. Even
    projects with hundreds or thousands of sub-modules can be handled
    performantly and with minimal overhead.

Mill is used to build many real-world projects, such as:

  * C3P0 JDBC Connection Pool

  * Coursier dependency resolver

  * Ammonite REPL

  * SpinalHDL and Chisel chip design frameworks

Mill can be used for applications built on top of common JVM
frameworks like Spring Boot (both in Java and in Kotlin), Micronaut,
Ktor, or Http4S.

Mill borrows ideas from other tools like Maven, Gradle, Bazel, and
sbt, but tries to learn from the strengths of each tool and improve
on their weaknesses. For comparisons with existing build tools, check
out these pages:

maven Mill vs Maven gradle Mill vs Gradle sbt Mill vs sbt

 Tool & Framework Support

Mill supports most common JVM development workflows and tools built
in, so you can get very far before you need to reach for third-party
plugins or write custom code to extend your build pipelines. The
table below links to the relevant part of the documentation and
examples for each tool:

Languages                        Packaging

  * Java, Kotlin, Scala            * Executable Assemblies

Dependency Management              * Graal Native Image, JLink,
                                     JPackage
  * Adding Dependencies
                                   * Docker
  * Dependency Version
    Management and BOMs          Publishing

  * Unmanaged Dependencies         * Maven Central, Artifactory

  * JVM Version Management       Web Frameworks

Testing                            * Spring Boot, Micronaut

  * JUnit4, JUnit5, TestNG,        * Ktor, Kotlin.js
    ScalaTest, Specs2, Munit
                                   * Http4s, Scala.js
  * Integration Testing
                                 Others
  * Test Parallelism
                                   * Java Annotation Processors,
Linting                              Kotlin Compiler Plugins, Scala
                                     Compiler Plugins
  * ErrorProne, Checkstyle,
    Palantir Java Format, Jacoco   * JNI
    , PMD, RevApi
                                   * Apache Spark, Scala-Native
  * Detekt, KtLint, KtFmt, Kover
                                   * Selective Test Execution,
  * Scalafix, Scalafmt,              Multi-Language Builds
    Scoverage, Mima

When the time comes that you do need something not in its builtin
feature set, Mill also has a rich ecosystem of third party plugins
for less common use cases:

  * Third-Party Plugins

 Contributing and Community

If you want to contribute to Mill, or are interested in the
fundamental ideas behind Mill rather than the user-facing features
discussed above, check out the page on Mill Design Principles. In
particular, this video is a must-watch to help you understand the
fundamental concepts behind Mill and why they are interesting:

  * Video: A Deep Dive into the Mill Build Tool

To engage Mill with the community, you can use the channels below:

  * Mill Github Discussions

  * Scala Discord, in the TOOLING#mill channel

Mill maintains an open list of issue bounties below, with payouts
ranging from 500USD to 3000USD per issue. Feel free to look through
the list and try your hand at any bounties that may interest you

  * Open Issue Bounties

Commercial support and services related to Mill are available if you
need help with training, adoption, or maintenance in your
organization. Email info@mill-build.org with details on what you need
and we can make an arrangement.

Building Java with Mill