Mill

https://mill-build.org/mill/
Admin
Mill is a fast, simple build tool for Java, Scala, and Kotlin that offers 3-7x faster builds than...
Tokens:222,158
Snippets:2,361
Trust Score:7.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Execute Multi-Language Build Commands

Source: https://mill-build.org/mill/large/multi-language-builds.html

Command-line examples for running tests, starting the server, and interacting with the API in a multi-language project.

```bash
> ./mill client.test
...PASS .../test/App.test.tsx
...Text Analysis Tool
...renders the app with initial UI...
...displays sentiment result...
...
Test Suites:...1 passed, 1 total
Tests:...2 passed, 2 total
...

> ./mill sentiment-analysis.test
...
test_negative_sentiment... ok
test_neutral_sentiment... ok
test_positive_sentiment... ok
...
Ran 3 tests...
...
OK
...

> ./mill server.test
...com.example.ServerTest#shouldReturnStaticPage() finished...
...com.example.ServerTest#shouldReturnPositiveAnalysis() finished...
...com.example.ServerTest#shouldReturnNegativeAnalysis() finished...

> ./mill server.runBackground

> curl http://localhost:${PORT:-8080}
...<title>Sentiment Analysis Tool</title>...

> curl -X POST http://localhost:${PORT:-8080}/api/analysis -H "Content-Type: text/plain" --data "This is awesome!" # Make request to the analysis api
Positive sentiment (polarity: 1.0)

> ./mill clean server.runBackground
```

--------------------------------

### Install and Run APK

Source: https://mill-build.org/mill/android/kotlin.html

Installs the APK on the emulator or uses the run command to install and launch the main activity in one step.

```bash
> ./mill show app.androidInstall
...All files should be loaded. Notifying the device...
```

```bash
> ./mill show app.run
```

--------------------------------

### Observe Classloader Lifecycle via CLI

Source: https://mill-build.org/mill/extending/running-jvm-code.html

Example output showing the setup and teardown of classloaders when running tasks and cleaning the build.

```bash
> ./mill '{foo1,foo2,foo3}.run' # 3 classloaders are setup, one is torn down due to maxCacheSize
Setting up Classloader
Setting up Classloader
Setting up Classloader
Tearing down Classloader
Foo.value: HELLO

> ./mill clean # mill clean tears down the 2 remaining classloaders
Tearing down Classloader
Tearing down Classloader
```

--------------------------------

### Sample properties file

Source: https://mill-build.org/mill/javalib/linting.html

Example properties file for formatting demonstration.

```properties
foo=bar
```

--------------------------------

### Example project source layout

Source: https://mill-build.org/mill/depth/evaluation-model.html

The expected directory structure for the Mill build example.

```text
foo/
    src/
        *.java files
    package.mill (optional)
bar/
    src/
        *.java files
    package.mill (optional)
build.mill
```

--------------------------------

### Run module command

Source: https://mill-build.org/mill/scalalib/module-config.html

Example command execution for a configured module.

```bash
> mill foo.run You
Hello You!
```

--------------------------------

### Install and Run Android Applications

Source: https://mill-build.org/mill/android/android-initial-setup.html

Commands to install the APK, run the application, or launch a specific activity on the emulator.

```bash
> ./mill app.androidInstall
```

```bash
> ./mill app.run
```

```bash
> ./mill app.androidRun --activity com.example.MainActivity
```

--------------------------------

### Run project examples

Source: https://mill-build.org/mill/javascriptlib/build-examples.html

Execute specific project examples using the mill build system.

```bash
> ./mill examples.abort.run

> ./mill examples.fill-in-middle.run

> ./mill examples.multimodal.run

> ./mill examples.pull-progress.run

> ./mill examples.structured_outputs.run

> ./mill examples.tools.run
```

--------------------------------

### Example Kotlin source file

Source: https://mill-build.org/mill/kotlinlib/linting.html

A sample Kotlin file used to demonstrate formatting.

```kotlin
import a.*

import kotlinx.android.synthetic.main.layout_name.*

import a.b.c.*
import a.b

fun main() {
    fun name() { a(); return b }
    println(";");
    println();
}
```

--------------------------------

### Execute and Show Tasks

Source: https://mill-build.org/mill/fundamentals/tasks.html

Command line examples for running tasks and displaying their output.

```bash
> ./mill jar
Generating classfiles
Generating jar

> ./mill show jar
".../out/jar.dest/foo.jar"
```

--------------------------------

### Execute printJavaVersion Command

Source: https://mill-build.org/mill/cli/build-header.html

Example output after running the printJavaVersion task.

```bash
> ./mill printJavaVersion
Java version: 17.0.14
```

--------------------------------

### Initialize Project

Source: https://mill-build.org/mill/cli/builtin-commands.html

Downloads and extracts project examples or Giter8 templates to bootstrap a new build.

```bash
> ./mill init
Run `mill init <example-id>` with one of these examples as an argument to download and extract example.
Run `mill init --show-all` to see full list of examples.
Run `mill init <Giter8 template>` to generate project from Giter8 template.
...
scalalib/basic/1-simple
...
scalalib/web/1-web-example
scalalib/web/2-todo-webapp
scalalib/web/3-webapp-cache-busting
scalalib/web/4-todo-http4s
scalalib/web/5-scalajs-module
scalalib/web/6-webapp-scalajs
scalalib/web/7-webapp-scalajs-shared
...
javalib/basic/1-simple
...
javalib/basic/9-realistic
...
javalib/web/1-web-example
javalib/web/2-hello-jetty
javalib/web/3-hello-micronaut
javalib/web/4-todo-micronaut
kotlinlib/basic/1-simple
...
kotlinlib/basic/9-realistic
...
kotlinlib/web/1-web-example
kotlinlib/web/2-hello-ktor
```

--------------------------------

### Example workflow for large projects

Source: https://mill-build.org/mill/migrating/auto-migrating.html

Demonstrates initializing, compiling, and testing a large multi-module repository.

```sh
> git init .
> git remote add -f origin https://github.com/iluwatar/java-design-patterns
> git checkout ede37bd05568b1b8b814d8e9a1d2bbd71d9d615d

> ./mill init --mill-jvm-id 21 # Repo needs Java >=21 to build and test

> rm twin/src/test/java/com/iluwatar/twin/BallThreadTest.java # skip flaky test
> rm actor-model/src/test/java/com/iluwatar/actor/ActorModelTest.java # skip flaky test

> ./mill __.compile # Compile all 300+ subprojects!
compiling 6 Java sources to ...service-to-worker...
compiling 4 Java sources to ...update-method...

> ./mill acyclic-visitor.test # run a subproject's tests
...
Test com.iluwatar.acyclicvisitor.ZoomTest#testAcceptForUnix() started
Test com.iluwatar.acyclicvisitor.ZoomTest#testAcceptForUnix() finished, took ...
Test com.iluwatar.acyclicvisitor.ZoomTest finished, took ...
...
```

--------------------------------

### Define build package and imports

Source: https://mill-build.org/mill/android/java.html

Initial setup for the build.mill file.

```scala
package build

import mill.*, androidlib.*, scalalib.*
```

--------------------------------

### Simple Publish CLI Commands

Source: https://mill-build.org/mill/javascriptlib/publishing.html

Commands to run, bundle, and install the simple project.

```bash
> ./mill foo.run "James Bond"
Hello James Bond!

> ./mill show foo.bundle
Build succeeded!

> node out/foo/bundle.dest/dist/src/foo.js "James Bond"
Hello James Bond!

> npm i -g mill-simple # install the executable file globally
...

> greet "James Bond"
Hello James Bond!
```

--------------------------------

### Execute run command

Source: https://mill-build.org/mill/extending/example-typescript-support.html

Example of running the compiled program with arguments.

```bash
> ./mill run James Bond
Hello James Bond
```

--------------------------------

### Run and Assembly Output

Source: https://mill-build.org/mill/javalib/module-config.html

Example output from running the module and generating an assembly JAR.

```bash
> ./mill run
Foo2.value: <h1>hello2</h1>
Foo.value: <h1>hello</h1>
FooA.value: hello A
FooB.value: hello B
FooC.value: hello C
MyResource: My Resource Contents
MyOtherResource: My Other Resource Contents
my.custom.property: my-prop-value
MY_CUSTOM_ENV: my-env-value

> ./mill show assembly
".../out/assembly.dest/out.jar"

> ./out/assembly.dest/out.jar # mac/linux
Foo2.value: <h1>hello2</h1>
Foo.value: <h1>hello</h1>
FooA.value: hello A
FooB.value: hello B
FooC.value: hello C
MyResource: My Resource Contents
MyOtherResource: My Other Resource Contents
my.custom.property: my-prop-value
```

--------------------------------

### Task Query Syntax Examples

Source: https://mill-build.org/mill/javalib/intro.html

Using wildcards and brace-expansion to target multiple tasks.

```bash
> ./mill bar._.compile            # Runs `compile` for all direct sub-modules of `foo`

> ./mill bar.__.test              # Runs `test` for all transitive sub-modules of `foo`

> ./mill {foo,bar}.compile        # Runs `compile` for `foo` and `bar`

> ./mill __.compile + bar.__.test # Runs all `compile` tasks and all tests under `foo`.
```

--------------------------------

### Run Command Output

Source: https://mill-build.org/mill/javascriptlib/module-config.html

Example output after executing the run command with arguments.

```text
> ./mill run "added tags"
Compiling...
Hello World!
Running... added tags
```

--------------------------------

### Sample Java source file

Source: https://mill-build.org/mill/javalib/linting.html

Example Java file used to demonstrate formatting rules.

```java
import mylib.Unused;
import mylib.UsedB;
import mylib.UsedA;

public class A {
/**
 * Some javadoc.
 */
public static void main(String[] args) {
System.out.println("A very very very very very very very very very very very very very very very very very very very very very long string that goes beyond the 100-character line length.");
UsedB.someMethod();
UsedA.someMethod();
}
}
```

--------------------------------

### Start Scala REPL

Source: https://mill-build.org/mill/scalalib/intro.html

Launches a Scala REPL session within the project context.

```bash
> ./mill repl    # start a Scala REPL within your project
> ./mill test.repl
```

--------------------------------

### Run application with unmanaged dependencies

Source: https://mill-build.org/mill/javalib/dependencies.html

Example command to execute the application after configuring unmanaged jars.

```bash
> ./mill run '{"name":"John","age":30}'     # mac/linux
Key: name, Value: John
Key: age, Value: 30
```

--------------------------------

### Execution and Output Example

Source: https://mill-build.org/mill/javalib/script.html

Commands to run the script via Mill and the resulting HTML output.

```bash
> ./mill StaticSite.java

> cat site-out/post/my-first-post.html
<!DOCTYPE html>
<html>
    <body>
        <h1>
            Blog / My First Post
        </h1>
        <div>
            <p>Sometimes you want numbered lists:</p>
            <ol>
            <li>One</li>
            <li>Two</li>
            <li>Three</li>
            </ol>
        </div>
    </body>
</html>
```

--------------------------------

### Manage Android Emulator

Source: https://mill-build.org/mill/android/kotlin.html

Commands to create, start, and verify the status of an Android Virtual Device.

```bash
> ./mill app.createAndroidVirtualDevice

> ./mill show app.startAndroidEmulator

> ./mill show app.adbDevices
...emulator-...device...
```

--------------------------------

### Execution with Flags Output

Source: https://mill-build.org/mill/javascriptlib/module-config.html

Example output showing the effect of configured execution flags.

```text
> ./mill foo.run
Debugger listening on ws://...
...
Foo:
Hello World!
```

--------------------------------

### View Cross-Build Output Structure

Source: https://mill-build.org/mill/fundamentals/cross-builds.html

Example of the directory structure generated by cross-build tasks.

```text
out/
├── foo/
│     ├── 2.10/
│     │     ├── bigSuffix.json
│     │     └── suffix.json
│     ├── 2.11/
│     │     ├── bigSuffix.json
│     │     └── suffix.json
│     └── 2.12/
│         ├── bigSuffix.json
│         └── suffix.json
```

--------------------------------

### Root Module File Structure

Source: https://mill-build.org/mill/fundamentals/modules.html

Example file structure for a project using a root module.

```text
build.mill
src/
    foo/Foo.java
resources/
    ...
test/
    src/
        foo/FooTest.java
out/
    compile.json
    compile.dest/
    ...
    test/
        compile.json
        compile.dest/
        ...
```

--------------------------------

### Run Checkstyle commands

Source: https://mill-build.org/mill/javalib/linting.html

Examples of running the checkstyle command, handling violations, and fixing issues.

```bash
> ./mill checkstyle # run checkstyle to produce a report, defaults to warning without error
...src/InputWhitespaceCharacters.java:3:23: Line contains a tab character...
...src/InputWhitespaceCharacters.java:16:3: Line contains a tab character...
...src/InputFileName1.java:2:1: Top-level class MyAnnotation1 has to reside in its own source file...
...src/InputFileName1.java:13:1: Top-level class Enum1 has to reside in its own source file...
...src/InputFileName1.java:26:1: Top-level class TestRequireThisEnum has to reside in its own source file...
Audit done.

> sed -i.bak 's/warning/error/g' checkstyle-config.xml # make checkstyle error on violations

> ./mill checkstyle
error: ...src/InputWhitespaceCharacters.java:3:23: Line contains a tab character...
...src/InputWhitespaceCharacters.java:16:3: Line contains a tab character...
...src/InputFileName1.java:2:1: Top-level class MyAnnotation1 has to reside in its own source file...
...src/InputFileName1.java:13:1: Top-level class Enum1 has to reside in its own source file...
...src/InputFileName1.java:26:1: Top-level class TestRequireThisEnum has to reside in its own source file...
Audit done.

> sed -i.bak 's/\t/    /g' src/InputWhitespaceCharacters.java

> rm src/InputFileName1.java

> ./mill checkstyle # after fixing the violations, checkstyle no longer errors
Audit done.
```

--------------------------------

### Configure a Mill plugin build

Source: https://mill-build.org/mill/extending/writing-plugins.html

Example build.mill configuration for a plugin, including integration test setup and publishing settings.

```scala
package build
import mill.*, scalalib.*, publish.*

object myplugin extends ScalaModule, PublishModule {
  def millVersion = "1.0.6"

  def scalaVersion = "3.7.4"

  def jvmVersion = "11"

  // Set the `platformSuffix` so the name indicates what Mill version it is compiled for
  def platformSuffix = s"_mill1"

  // Depend on `mill-libs` so we can compile against Mill APIs
  def mvnDeps = Seq(mvn"com.lihaoyi::mill-libs:$millVersion")

  // Setup for integration/example tests
  object integration extends ScalaTests, TestModule.Utest {
    def mvnDeps = Seq(mvn"com.lihaoyi::mill-testkit:$millVersion")
    def forkEnv = Task {
      val repos = Seq(publishLocalTestRepo().path.toNIO.toUri.toASCIIString) ++
        Seq(Task.env.getOrElse("COURSIER_REPOSITORIES", "ivy2Local|central"))
      Map(
        "MILL_EXECUTABLE_PATH" -> millExecutable.assembly().path.toString,
        "COURSIER_REPOSITORIES" -> repos.mkString("|")
      )
    }

    // Create a Mill executable configured for testing our plugin
    object millExecutable extends JavaModule {
      def mvnDeps = Seq(mvn"com.lihaoyi:mill-runner-launcher_3:$millVersion")
      def mainClass = Some("mill.launcher.MillLauncherMain")
    }
  }

  // Publishing Config
  def publishVersion = "0.0.1"

  def pomSettings = PomSettings(
    description = "Line Count Mill Plugin",
    organization = "com.lihaoyi",
    url = "https://github.com/lihaoyi/myplugin",
    licenses = Seq(License.MIT),
    versionControl = VersionControl.github("lihaoyi", "myplugin"),
    developers = Seq(Developer("lihaoyi", "Li Haoyi", "https://github.com/lihaoyi"))
  )
}
```

--------------------------------

### Runtime server dependencies

Source: https://mill-build.org/mill/contrib/playlib.html

Runtime dependencies for the start command, varying by Play version.

```scala
mvn"com.typesafe.play::play-akka-http-server:${playVersion()}"
```

```scala
mvn"com.typesafe.play::play-pekko-http-server:${playVersion()}"
```

--------------------------------

### View mill init help

Source: https://mill-build.org/mill/migrating/auto-migrating.html

Displays all available options for the initialization command.

```sh
./mill init --help
```

--------------------------------

### Example Java source file

Source: https://mill-build.org/mill/javalib/linting.html

A sample Java class with incorrect indentation to demonstrate formatting.

```java
public class A {

    public static void main(String[] args) {
    System.out.println("hello"); // indentation should be fixed
    }
}
```

--------------------------------

### Install scip-java CLI

Source: https://mill-build.org/mill/extending/thirdparty-plugins.html

Use Coursier to install the scip-java command-line tool.

```shell
> cs install scip-java
```

--------------------------------

### TypeScript Source Files

Source: https://mill-build.org/mill/extending/example-typescript-support.html

Example TypeScript source files for the foo, bar, and qux modules.

```typescript
interface User { firstName: string }

const user: User = { firstName: process.argv[2] }

console.log("Hello " + user.firstName + " Foo")
```

```typescript
interface User { firstName: string }

const user: User = { firstName: process.argv[2] }

console.log("Hello " + user.firstName + " Bar")
```

```typescript
interface User { firstName: string }

const user: User = { firstName: process.argv[2] }

console.log("Hello " + user.firstName + " Qux")
```

--------------------------------

### Example project structure for static site

Source: https://mill-build.org/mill/scalalib/module-config.html

Recommended directory layout for including docs and blog content in Scaladoc.

```text
.
├── build.mill
├── bar
│  ├── docs
│  │  ├── _blog
│  │  │  ├── _posts
│  │  │  │  └── 2022-08-14-hello-world.md
│  │  │  └── index.md
│  │  └── _docs
│  │     ├── getting-started.md
│  │     ├── index.html
│  │     └── index.md
│  └── src
│     └── example
│        └── Hello.scala
```

--------------------------------

### Install Mill Tab Completion

Source: https://mill-build.org/mill/cli/installation-ide.html

Installs the tab completion script and registers it in shell configuration files.

```bash
> ./mill mill.tabcomplete/install
```

--------------------------------

### Bundle and run assembly

Source: https://mill-build.org/mill/javalib/intro.html

Create a deployable JAR file and execute it across different platforms.

```bash
> ./mill assembly # bundle classfiles and libraries into a jar for deployment

> ./mill show assembly # show the output of the assembly task
".../out/assembly.dest/out.jar"

> java -jar ./out/assembly.dest/out.jar --text hello
<h1>hello</h1>

> ./out/assembly.dest/out.jar --text hello # mac/linux
<h1>hello</h1>

> # Note that on windows you need to rename `out.jar` to `out.bat` to run it without `java -jar`
> cp ./out/assembly.dest/out.jar out.bat # windows

> ./out.bat --text hello # windows
<h1>hello</h1>
```

--------------------------------

### Install Maven via package managers

Source: https://mill-build.org/mill/comparisons/maven.html

Common commands to install Maven across various operating systems and package managers.

```bash
> brew install maven
> sdk install maven
> sudo port install maven
> sudo apt install maven
> sudo dnf install maven
> sudo yum install maven
> choco install maven
> scoop install maven
```

--------------------------------

### Example source files for formatting

Source: https://mill-build.org/mill/scalalib/linting.html

Sample Java and Scala files used to demonstrate formatting rules.

```java
import mylib.Unused;
import mylib.UsedB;
import mylib.UsedA;

public class A {
/**
 * Some javadoc.
 */
public static void main(String[] args) {
System.out.println("A very very very very very very very very very very very very very very very very very very very very very long string that goes beyond the 100-character line length.");
UsedB.someMethod();
UsedA.someMethod();
}
}
```

```scala
sealed trait B
object B{
case object F extends B
case object T extends B
}
```

```scala
enum B:
  case F,T
```

--------------------------------

### Install TypeScript dependencies

Source: https://mill-build.org/mill/extending/example-typescript-support.html

Uses the npm CLI to install specific versions of TypeScript and Node.js types into the task's destination directory.

```scala
def npmInstall = Task {
  os.call(("npm", "install", "--save-dev", "typescript@5.6.3", "@types/node@22.7.8"))
  PathRef(Task.dest)
}
```

--------------------------------

### Execute a task calling a command

Source: https://mill-build.org/mill/fundamentals/bundled-libraries.html

Example of running the taskCallingCommand.

```bash
> ./mill show taskCallingCommand
"arg: HELLO"
```

--------------------------------

### Execute build commands

Source: https://mill-build.org/mill/large/multi-file-builds.html

Example output from running build tasks that utilize the defined helper files.

```bash
> ./mill run
Main Env build.util.myScalaVersion: 2.13.16
Main Env build.foo.versions.myProjectVersion: 0.0.1

> ./mill foo.run
Foo Env build.util.myScalaVersion: 2.13.16
Foo Env build.foo.versions.myProjectVersion: 0.0.1
```

--------------------------------

### Define WorldTests Suite

Source: https://mill-build.org/mill/scalalib/testing.html

Example test suite for the world functionality.

```scala
package foo
import utest.*
object WorldTests extends TestSuite {
  def tests = Tests {
    test("world") {
      println("Testing World")
      val result = Foo.hello()
      assert(result.endsWith("World"))
      Thread.sleep(1000)
      println("Testing World Completed")
      result
    }
  }
}
```

--------------------------------

### Define HelloTests Suite

Source: https://mill-build.org/mill/scalalib/testing.html

Example test suite for the hello functionality.

```scala
package foo
import utest.*
object HelloTests extends TestSuite {
  def tests = Tests {
    test("hello") {
      println("Testing Hello")
      val result = Foo.hello()
      assert(result.startsWith("Hello"))
      Thread.sleep(1000)
      println("Testing Hello Completed")
      result
    }
  }
}
```

--------------------------------

### Initialize version file

Source: https://mill-build.org/mill/contrib/versionfile.html

Create the initial version file manually in the project directory.

```bash
$ echo 0.1.0-SNAPSHOT > versionFile/version
```

--------------------------------

### Example Python Source Script

Source: https://mill-build.org/mill/pythonlib/testing.html

A simple Python class to be tested.

```python
class Foo:
    def main(self):
        return "Hello World"


if __name__ == "__main__":
    print(Foo().main())
```

--------------------------------

### Execute Mill Task

Source: https://mill-build.org/mill/pythonlib/dependencies.html

Example command to run a Mill task.

```bash
> ./mill foo.run
2
```

--------------------------------

### Implement Ktor Hello World Application

Source: https://mill-build.org/mill/kotlinlib/web-examples.html

A simple Ktor server implementation that responds with a Hello World HTML string.

```kotlin
package com.example

import io.ktor.server.application.Application
import io.ktor.server.application.call
import io.ktor.server.engine.embeddedServer
import io.ktor.server.netty.Netty
import io.ktor.server.response.respondText
import io.ktor.server.routing.get
import io.ktor.server.routing.routing

fun main() {
    val port = System.getenv("PORT")?.toIntOrNull() ?: 8080
    embeddedServer(Netty, port = port, host = "0.0.0.0", module = Application::module)
        .start(wait = true)
}

fun Application.module() {
    routing {
        get("/") {
            call.respondText("<h1>Hello, World!</h1>")
        }
    }
}
```

--------------------------------

### Execute a command taking a Task

Source: https://mill-build.org/mill/fundamentals/bundled-libraries.html

Example of invoking the commandTakingTask task.

```bash
> ./mill commandTakingTask --str helloworld
arg: helloworld
```

--------------------------------

### Execute a command taking os.Path

Source: https://mill-build.org/mill/fundamentals/bundled-libraries.html

Example of invoking the commandTakingPath task.

```bash
> ./mill commandTakingPath --path foo/bar/baz.txt
...foo/bar/baz.txt
```

--------------------------------

### Run the application

Source: https://mill-build.org/mill/groovylib/intro.html

Executes the main class with provided arguments.

```bash
> ./mill run --text hello
<h1>hello</h1>
```

--------------------------------

### Run Mill module

Source: https://mill-build.org/mill/comparisons/gradle.html

Example output after running the modified module.

```text
> mill foo.run
Line Count: 18
```

--------------------------------

### Example build.mill configuration

Source: https://mill-build.org/mill/cli/builtin-commands.html

A sample build configuration defining two modules, foo and bar, with dependencies.

```scala
package build
import mill.*, javalib.*

trait MyModule extends JavaModule {
  object test extends JavaTests, TestModule.Junit4
}

object foo extends MyModule {
  def moduleDeps = Seq(bar)
  def mvnDeps = Seq(
    mvn"net.sourceforge.argparse4j:argparse4j:0.9.0"
  )
}

object bar extends MyModule {
  def mvnDeps = Seq(
    mvn"net.sourceforge.argparse4j:argparse4j:0.9.0",
    mvn"org.thymeleaf:thymeleaf:3.1.1.RELEASE",
    mvn"org.slf4j:slf4j-nop:2.0.7"
  )
}
```

--------------------------------

### Configure a realistic Java project with dependencies and publishing

Source: https://mill-build.org/mill/javalib/intro.html

Demonstrates a multi-module setup using a trait to share configuration, including dependency management, publishing settings, and dynamic source generation.

```scala
package build
import mill.*, javalib.*, publish.*

trait MyModule extends JavaModule, PublishModule {
  def publishVersion = "0.0.1"

  def pomSettings = PomSettings(
    description = "Hello",
    organization = "com.lihaoyi",
    url = "https://github.com/lihaoyi/example",
    licenses = Seq(License.MIT),
    versionControl = VersionControl.github("lihaoyi", "example"),
    developers = Seq(Developer("lihaoyi", "Li Haoyi", "https://github.com/lihaoyi"))
  )

  def mvnDeps = Seq(mvn"org.thymeleaf:thymeleaf:3.1.1.RELEASE")

  object test extends JavaTests, TestModule.Junit4
}

object foo extends MyModule {
  def moduleDeps = Seq(bar, qux)

  def generatedSources = Task {
    os.write(
      Task.dest / "Version.java",
      s"""
         |package foo;
         |public class Version {
         |    public static String value() {
         |        return "${publishVersion()}";
         |    }
         |}
      """.stripMargin
    )
    Seq(PathRef(Task.dest))
  }
}

object bar extends MyModule {
  def moduleDeps = Seq(qux)
}

object qux extends MyModule
```

--------------------------------

### Defining a Scala Module

Source: https://mill-build.org/mill/cli/query-syntax.html

Example build.mill configuration for a Scala module.

```scala
package build
import mill.*, scalalib.*

object foo extends ScalaModule {
  def scalaVersion = "3.8.2"
}
```

--------------------------------

### Configure ClassicDockerConfig

Source: https://mill-build.org/mill/contrib/docker.html

Settings for Dockerfile-based builds, requiring the Docker CLI to be installed.

```scala
object docker extends ClassicDockerConfig {
  // Configure whether the docker build should check the remote registry for a new version
  // of the base image before building. By default true if the base image uses a latest tag.
  def pullBaseImage = true
  // The names of mount points (not supported by Jib)
  def volumes = Seq("/v1", "/v2")
  // Add RUN instructions (not supported by Jib)
  def run = Seq(
    "/bin/bash -c 'echo Hello World!'",
    "useradd -ms /bin/bash new-user"
  )
  // Optionally override the docker executable
  def executable = "podman"
}
```

--------------------------------

### Test and run web server integration

Source: https://mill-build.org/mill/scalalib/web-examples.html

Commands to verify the web server integration and serve the static assets.

```bash
> ./mill test
+ webapp.WebAppTests.simpleRequest ...

> ./mill runBackground

> curl http://localhost:${PORT:-8080}
...What needs to be done...
...

> curl http://localhost:${PORT:-8080}/static/main.js
..."org.scalajs.linker.runtime.RuntimeLong$"...
...

> ./mill clean runBackground
```

--------------------------------

### Running the Overridden Task

Source: https://mill-build.org/mill/pythonlib/module-config.html

Example output when executing the overridden run command.

```bash
> ./mill foo.run
Type Checking...
Success: no issues found in 1 source file
Running...
Hello World
```

--------------------------------

### Configure Pytest in build.mill

Source: https://mill-build.org/mill/pythonlib/testing.html

Example of using the Pytest framework within a PythonModule.

```scala
object bar extends PythonModule {
  def mainScript = Task.Source("src/bar.py")
  object test extends PythonTests, TestModule.Pytest
}
```

--------------------------------

### Define Python source files

Source: https://mill-build.org/mill/extending/example-python-support.html

Example Python source files for the modules.

```python
import sys
def multiply(a: int, b: int) -> int: return a * b
```

```python
import sys
def add(a: int, b: int) -> int: return a + b
```

```python
from foo.bar.src.bar import add # type: ignore
from foo.src.foo import multiply # type: ignore
import sys
def divide(a: int, b: int) -> float: return a/b
def main() -> None:
    x = int(sys.argv[1])
    y = int(sys.argv[2])
    print(f"Add: {x} + {y} = {add(x, y)} | Multiply: {x} * {y} = {multiply(x, y)} | Divide: {x} / {y} = {divide(x, y)}")
if __name__ == "__main__":
    main()
```

--------------------------------

### Verify PKG Output

Source: https://mill-build.org/mill/javalib/packaging.html

Lists the generated PKG installer file in the output directory.

```bash
> ls -l ./out/foo/jpackageAppImage.dest/image
... foo-1.0.pkg
```

--------------------------------

### Verify DMG Output

Source: https://mill-build.org/mill/javalib/packaging.html

Lists the generated DMG installer file in the output directory.

```bash
> ls -l ./out/foo/jpackageAppImage.dest/image
... foo-1.0.dmg
```

--------------------------------

### Execute custom module tasks

Source: https://mill-build.org/mill/fundamentals/modules.html

Example CLI commands to inspect sources, build assemblies, and run the resulting JAR files.

```bash
> ./mill showNamed __.sources
{
  "foo.sources": ".../foo/src",
  "foo.bar.sources": ".../foo/bar/src",
  "qux.sources": ".../qux/src"
}

> ./mill show qux.assembly
".../out/qux/assembly.dest/assembly.jar"

> java -jar out/qux/assembly.dest/assembly.jar
Foo.value: 31337
Bar.value: 271828
Qux.value: 9000

> ./mill show foo.assembly
".../out/foo/assembly.dest/assembly.jar"

> java -jar out/foo/assembly.dest/assembly.jar
Foo.value: 31337
Bar.value: 271828
```

--------------------------------

### Execute and assemble JavaModule

Source: https://mill-build.org/mill/javalib/module-config.html

Command line output demonstrating running the module and creating an assembly jar.

```bash
> ./mill run
Foo2.value: <h1>hello2</h1>
Foo.value: <h1>hello</h1>
MyResource: My Resource Contents
MyOtherResource: My Other Resource Contents
my.custom.property: my-prop-value
MY_CUSTOM_ENV: my-env-value

> ./mill show assembly
".../out/assembly.dest/out.jar"

> ./out/assembly.dest/out.jar # mac/linux
Foo2.value: <h1>hello2</h1>
Foo.value: <h1>hello</h1>
MyResource: My Resource Contents
MyOtherResource: My Other Resource Contents
my.custom.property: my-prop-value
```

--------------------------------

### Customize jpackageType

Source: https://mill-build.org/mill/javalib/packaging.html

Overrides the default package type to generate a specific installer format.

```scala
def jpackageType = "pkg"
```

--------------------------------

### Execute complex build operations and assembly

Source: https://mill-build.org/mill/javalib/intro.html

Demonstrates resolving tasks, running specific modules, and creating an assembly JAR for deployment.

```bash
> ./mill resolve __.run
bar.run
bar.test.run
foo.run
foo.test.run
qux.run

> ./mill foo.run
foo version 0.0.1
Foo.value: <h1>hello</h1>
Bar.value: <p>world</p>
Qux.value: 31337

> ./mill bar.test
...bar.BarTests.test ...

> ./mill qux.run
Qux.value: 31337

> ./mill __.compile

> ./mill __.test
...bar.BarTests.test ...
...foo.FooTests.test ...

> ./mill __.publishLocal
Publishing com.lihaoyi:foo:0.0.1 to ivy repo...
Publishing com.lihaoyi:bar:0.0.1 to ivy repo...
Publishing com.lihaoyi:qux:0.0.1 to ivy repo...
...

> ./mill show foo.assembly # mac/linux
".../out/foo/assembly.dest/out.jar"

> ./out/foo/assembly.dest/out.jar # mac/linux
foo version 0.0.1
Foo.value: <h1>hello</h1>
Bar.value: <p>world</p>
Qux.value: 31337
```

--------------------------------

### Observe compiler plugin output

Source: https://mill-build.org/mill/scalalib/module-config.html

Example output when a compiler plugin detects a violation.

```bash
> ./mill compile
...
error: Unwanted cyclic dependency
error: ...src/Foo.scala...
error:   def y = Bar.z
error: ...src/Bar.scala...
error:   def x = Foo.y
```

--------------------------------

### Run Ktor Hello World Commands

Source: https://mill-build.org/mill/kotlinlib/web-examples.html

Common Mill commands for testing and running the Ktor application.

```bash
> ./mill test
Test com.example.HelloKtorTest HelloKtorTest finished, took...

> ./mill runBackground

> curl http://localhost:${PORT:-8080}
...<h1>Hello, World!</h1>...

> ./mill clean runBackground
```

--------------------------------

### Configure Alternative Test Module

Source: https://mill-build.org/mill/scalalib/testing.html

Example of extending a predefined TestModule for a different project.

```yaml
extends: ScalaModule
scalaVersion: 3.8.2
```

```yaml
extends: [build.bar.ScalaTests, TestModule.Utest]
mvnDeps: [com.lihaoyi::utest:0.8.9]
```

--------------------------------

### Execute Mill Commands

Source: https://mill-build.org/mill/pythonlib/module-config.html

Example CLI commands for running the application and its test suite.

```bash
> ./mill foo.run
Hello World Resource File

> ./mill foo.test
...
test_all (test.TestScript...) ... ok
...Ran 1 test...
OK
...
```

--------------------------------

### Publishing artifacts via CLI

Source: https://mill-build.org/mill/javalib/publishing.html

Example command to trigger the publishAll task with specific configuration options.

```bash
$ mill \
mill.javalib.SonatypeCentralPublishModule/publishAll \
--username myusername \
--password mypassword \
--gpgArgs --passphrase=$MILL_PGP_PASSPHRASE,--no-tty,--pinentry-mode,loopback,--batch,--yes,--armor,--detach-sign \
--publishArtifacts __.publishArtifacts \
--readTimeout  36000 \
--awaitTimeout 36000 \
--connectTimeout 36000 \
--shouldRelease false \
--bundleName com.lihaoyi-requests:1.0.0
```

--------------------------------

### Resource file contents

Source: https://mill-build.org/mill/javalib/module-config.html

Example content for various resource files used in the project.

```text
Hello World Resource File
```

```text
Test Hello World Resource File A
```

```text
Test Hello World Resource File B
```

```text
Other Hello World File
```

--------------------------------

### Execute tests and run multi-module applications

Source: https://mill-build.org/mill/javalib/intro.html

Example CLI commands for running tests and applications within a multi-module project structure.

```bash
> ./mill bar.test
Test bar.BarTests.simple finished...
Test bar.BarTests.escaping finished...
```

```bash
> ./mill foo.run --foo-text hello --bar-text world
Foo.value: hello
Bar.value: <h1>world</h1>
```

--------------------------------

### Verify custom registry configuration

Source: https://mill-build.org/mill/javascriptlib/dependencies.html

Example output showing the resolution of packages from an alternate registry and verifying the registry setting via npm config.

```bash
> ./mill foo.run e b k a l m o p
Sorted with lodash: [a,b,e,k,l,m,o,p]
....
{
  version: '4.17.21',
  resolved: 'https://registry.npmmirror.com/lodash/-/lodash-4.17.21.tgz',
  integrity: ...
...
}

> cd out/foo/npmInstall.dest && npm config get registry
https://registry.npmmirror.com...
```

--------------------------------

### Project Directory Structure

Source: https://mill-build.org/mill/kotlinlib/module-config.html

Recommended file layout for the native C and Kotlin integration.

```text
build.mill
src/
    foo/
        HelloWorld.kt

native-src/
    HelloWorld.c

test/
    src/
        foo/
            HelloWorldTest.kt
```

--------------------------------

### Test Ktor Hello World Application

Source: https://mill-build.org/mill/kotlinlib/web-examples.html

Uses Kotest and Ktor test host to verify the server response.

```kotlin
package com.example

import io.kotest.core.spec.style.FunSpec
import io.kotest.matchers.shouldBe
import io.ktor.client.request.get
import io.ktor.client.statement.bodyAsText
import io.ktor.http.HttpStatusCode
import io.ktor.server.testing.testApplication

class HelloKtorTest :
    FunSpec({
        test("HelloKtorTest") {
            testApplication {
                application {
                    module()
                }
                val response = client.get("/")
                response.status shouldBe HttpStatusCode.OK
                response.bodyAsText() shouldBe "<h1>Hello, World!</h1>"
            }
        }
    })
```

--------------------------------

### Checkstyle XSLT directory structure

Source: https://mill-build.org/mill/javalib/linting.html

Example directory structure for automatic XSLT detection.

```text
/**
 * checkstyle-xslt
 *  ├─ html
 *  │   ├─ xslt0.xml
 *  │   └─ xslt1.xml
 *  └─ pdf
 *      ├─ xslt1.xml
 *      └─ xslt2.xml
 *
 * html/xslt0.xml -> xslt0.html
 * html/xslt1.xml -> xslt1.html
 * pdf/xslt1.xml  -> xslt1.pdf
 * pdf/xslt2.xml  -> xslt2.pdf
 */
```

--------------------------------

### Specify Checkstyle source paths

Source: https://mill-build.org/mill/javalib/linting.html

Examples of targeting specific files or directories for linting.

```bash
// incorrect paths will cause a command failure
./mill checkstyle a/b

// you can specify paths relative to moduleDir
./mill checkstyle src/a/b

// process a single file
./mill checkstyle src/a/B.java

// process multiple sources
./mill checkstyle src/a/b src/c/d src/e/F.java

// process with flags
./mill checkstyle --check --stdout src/a/b src/c/d

// process all module sources
./mill checkstyle
```

--------------------------------

### Generate and verify static site docs

Source: https://mill-build.org/mill/scalalib/module-config.html

Commands to generate the static site and verify the output.

```bash
> ./mill show bar.docJar

> unzip -p out/bar/docJar.dest/out.jar bar/Bar.html
...
...<p>My Awesome Docs for class Bar</p>...
```

--------------------------------

### Sample Python Main File

Source: https://mill-build.org/mill/extending/example-python-support.html

A simple Python script demonstrating basic functionality and type hints.

```python
import sys
def add(a: int, b: int) -> int: return a + b
def main() -> None: print("Hello, " + " ".join(sys.argv[1:]) + "!")
if __name__ == "__main__":
    main()
    print(add(5, 10)) # Error Example: add("5", 10) will cause a TypeError
```

--------------------------------

### Ktor Web Server Script

Source: https://mill-build.org/mill/kotlinlib/script.html

Demonstrates running a lightweight web server using Ktor and CIO engine within a single Kotlin script.

```kotlin
//| mvnDeps: [io.ktor:ktor-server-core:2.3.7, io.ktor:ktor-server-cio:2.3.7]
import io.ktor.server.engine.*
import io.ktor.server.cio.*
import io.ktor.server.application.*
import io.ktor.server.request.*
import io.ktor.server.response.*
import io.ktor.server.routing.*

fun main() {
    val port = System.getenv("PORT")?.toIntOrNull() ?: 8080
    embeddedServer(CIO, port = port) {
        routing {
            post("/reverse-string") {
                val body = call.receiveText()
                call.respondText(body.reversed())
            }
        }
    }.start(wait = true)
}
```

```bash
> ./mill WebServer.kt:runBackground

> curl -d 'helloworld' localhost:${PORT:-8080}/reverse-string
dlrowolleh
```
Tokens:
Raw