### Install Plugin Locally

Source: https://github.com/davidb/scala-maven-plugin/blob/master/README.md

Installs the plugin to the local Maven repository after running integration tests.

```bash
./mvnw install
```

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

### Install Plugin Locally (Skip Tests)

Source: https://github.com/davidb/scala-maven-plugin/blob/master/README.md

Installs the plugin to the local Maven repository, skipping both unit and integration tests.

```bash
./mvnw install -Dmaven.test.skip=true
```

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

### Control Scala Installation with scala.version and scalaHome

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Override the Scala version detected from the `scala-library` dependency or point to a local Scala installation to avoid downloading compiler artifacts. Configure `failOnMultipleScalaVersions` and `compileOrder`.

```xml
<!-- pom.xml: explicit scala.version and compat version check -->
<properties>
  <scala.version>2.13.16</scala.version>
  <scala.compat.version>2.13</scala.compat.version>
</properties>

<plugin>
  <groupId>net.alchim31.maven</groupId>
  <artifactId>scala-maven-plugin</artifactId>
  <version>4.9.2</version>
  <configuration>
    <!-- Fail build if multiple Scala binary versions are detected -->
    <failOnMultipleScalaVersions>true</failOnMultipleScalaVersions>
    <!-- Use a locally installed Scala instead of Maven artifacts -->
    <!-- <scalaHome>/usr/share/scala</scalaHome> -->

    <!-- Compile-order for mixed sources: Mixed | JavaThenScala | ScalaThenJava -->
    <compileOrder>Mixed</compileOrder>
  </configuration>
</plugin>
```

```bash
# Override Scala version from command line
mvn compile -Dscala.version=2.12.20

# Point to a local Scala installation
mvn compile -Dscala.home=/opt/scala-2.13.16
```

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

### Run Continuous Compilation with scala:cc / scala:cctest

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Start continuous compilation loops that watch for file changes. Use '-Donce=true' to run once, or 'scala:cctest' to include test execution.

```bash
# Start continuous compilation loop (watches for file changes)
mvn scala:cc

# Run once (no loop) — useful in CI or editor integrations
mvn scala:cc -Donce=true

# Continuous compile + run tests on each successful compile
mvn scala:cctest

# Enable verbose output
mvn scala:cc -Dverbose=true
```

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

### Configure Scala Maven Plugin for Incremental Compilation

Source: https://github.com/davidb/scala-maven-plugin/wiki/Tips

Enable incremental compilation for Scala projects using the maven-scala-plugin. Configure specific arguments for main and test compilation, including dependency file paths. This setup is available since Scala 2.8.0.

```xml
<plugin>
        <groupId>org.scala-tools</groupId>
        <artifactId>maven-scala-plugin</artifactId>
        <version>2.14.1</version>
        <executions>
          <execution>
            <id>cmain</id>
            <goals>
              <goal>compile</goal>
            </goals>
            <configuration>
              <args>
                <arg>-make:transitive</arg>
                <arg>-dependencyfile</arg>
                <arg>${project.build.directory}/.main_scala_dependencies</arg>
              </args>
            </configuration>
          </execution>
          <execution>
            <id>ctest</id>
            <goals>
              <goal>testCompile</goal>
            </goals>
            <configuration>
              <args>
                <arg>-make:transitive</arg>
                <arg>-dependencyfile</arg>
                <arg>${project.build.directory}/.test_scala_dependencies</arg>
              </args>
            </configuration>
          </execution>
        </executions>
        <configuration>
          <jvmArgs>
            <jvmArg>-Xms64m</jvmArg>
            <jvmArg>-Xmx1024m</jvmArg>
          </jvmArgs>
        </configuration>
      </plugin>
```

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

### Configure Named Launchers for scala:run

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Define named configurations in pom.xml for common entry points. Supports arguments and JVM options for specific launchers.

```xml
<plugin>
  <groupId>net.alchim31.maven</groupId>
  <artifactId>scala-maven-plugin</artifactId>
  <version>4.9.2</version>
  <configuration>
    <launchers>
      <launcher>
        <id>server</id>
        <mainClass>com.example.ServerMain</mainClass>
        <args>
          <arg>--port</arg>
          <arg>8080</arg>
        </args>
        <jvmArgs>
          <jvmArg>-Xmx512m</jvmArg>
        </jvmArgs>
      </launcher>
      <launcher>
        <id>migrate</id>
        <mainClass>com.example.MigrationTool</mainClass>
      </launcher>
    </launchers>
  </configuration>
</plugin>
```

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

### Generate Plugin Website

Source: https://github.com/davidb/scala-maven-plugin/blob/master/README.md

Command to generate the plugin's website documentation using Maven.

```bash
./mvnw site
```

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

### Run Scala Main Class with scala:run

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Execute a Scala main class using a named launcher or an arbitrary class. Additional arguments can be passed via the command line.

```bash
# Run using a named launcher defined in pom.xml
mvn scala:run -Dlauncher=server

# Run an arbitrary main class (not defined in pom.xml)
mvn scala:run -DmainClass=com.example.App

# Pass additional arguments from the command line (pipe-separated)
mvn scala:run -DmainClass=com.example.App -DaddArgs="arg1|arg2|arg3"
```

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

### Run Scaladoc Generation

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Commands to generate Scaladoc HTML documentation or run the scala:doc goal directly.

```bash
mvn site          # generates Scaladoc under target/site/scaladocs/
```

```bash
mvn scala:doc     # run directly
```

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

### Launch Scala REPL with scala:console

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Launch the Scala REPL. Compile first to ensure the latest classes are available, or specifically include test-compiled classes.

```bash
# Compile first, then launch REPL with compiled classes on classpath
mvn compile scala:console

# Launch REPL with test-compiled classes available
mvn test-compile scala:console
```

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

### Manual Release Deployment

Source: https://github.com/davidb/scala-maven-plugin/blob/master/README.md

A comprehensive manual command for deploying a release, including generating artifacts, signing, and deploying to repositories. Requires manual closing and releasing of staging repositories on OSS Sonatype.

```bash
./mvnw site package source:jar javadoc:jar install:install gpg:sign deploy:deploy changes:announcement-generate -Dmaven.test.skip=true -DperformRelease=true
```

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

### Release Plugin (Standard)

Source: https://github.com/davidb/scala-maven-plugin/blob/master/README.md

Standard Maven release process to prepare and perform a release, publishing to a staging repository.

```bash
./mvnw release:clean && ./mvnw release:prepare && ./mvnw release:perform
```

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

### Run Integration Tests

Source: https://github.com/davidb/scala-maven-plugin/blob/master/README.md

Executes all integration tests for the plugin. Ensure the 'scala.home' property is correctly set in 'src/it/test_scalaHome/pom.xml' if needed.

```bash
./mvnw integration-test
```

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

### Build Plugin Jar

Source: https://github.com/davidb/scala-maven-plugin/blob/master/README.md

Use this command to package the Scala Maven Plugin into a JAR file.

```bash
./mvnw package
```

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

### Run Package Goal to Produce Scaladoc JAR

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Execute the Maven package goal to produce the main artifact along with the associated -javadoc.jar.

```bash
mvn package   # produces myartifact-1.0-javadoc.jar alongside the main jar
```

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

### Release Plugin (Skip Tests)

Source: https://github.com/davidb/scala-maven-plugin/blob/master/README.md

Prepares and performs a plugin release, skipping tests during the process. This is useful for faster releases, especially in CI environments.

```bash
./mvnw release:clean && ./mvnw release:prepare -Darguments="-DskipTests -Dmaven.test.skip=true" && ./mvnw release:perform -Darguments="-DskipTests -Dmaven.test.skip=true"
```

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

### Register Scala Source Directories and Compile

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Register Scala source directories and bind compile goals to Maven lifecycle phases. Ensure Scala sources are discovered by IDEs and other plugins.

```xml
<plugin>
  <groupId>net.alchim31.maven</groupId>
  <artifactId>scala-maven-plugin</artifactId>
  <version>4.9.2</version>
  <executions>
    <execution>
      <id>scala-add-source</id>
      <goals>
        <goal>add-source</goal>
      </goals>
    </execution>
    <execution>
      <id>scala-compile</id>
      <goals>
        <goal>compile</goal>
        <goal>testCompile</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <!-- default: ${project.build.sourceDirectory}/../scala -->
    <sourceDir>${project.basedir}/src/main/scala</sourceDir>
    <testSourceDir>${project.basedir}/src/test/scala</testSourceDir>
  </configuration>
</plugin>
```

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

### Configure Scala 3 Project with Scala Maven Plugin

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Set up a Maven project to use Scala 3 by declaring the Scala 3 library dependency and configuring the scala-maven-plugin. The plugin auto-detects Scala 3.

```xml
<!-- pom.xml: Scala 3 project -->
<properties>
  <scala.compat.version>3</scala.compat.version>
  <scala.version>3.4.1</scala.version>
</properties>

<dependencies>
  <dependency>
    <groupId>org.scala-lang</groupId>
    <artifactId>scala3-library_${scala.compat.version}</artifactId>
    <version>${scala.version}</version>
  </dependency>
</dependencies>

<build>
  <plugins>
    <plugin>
      <groupId>net.alchim31.maven</groupId>
      <artifactId>scala-maven-plugin</artifactId>
      <version>4.9.2</version>
      <executions>
        <execution>
          <goals>
            <goal>compile</goal>
            <goal>testCompile</goal>
          </goals>
        </execution>
      </executions>
      <configuration>
        <args>
          <arg>-encoding</arg>
          <arg>UTF-8</arg>
        </args>
      </configuration>
    </plugin>
  </plugins>
</build>
```

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

### Configure REPL Classpath with scala:console

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Customize the classpath for the Scala REPL. Use test-scope classes and runtime dependencies by setting specific configuration properties.

```xml
<plugin>
  <groupId>net.alchim31.maven</groupId>
  <artifactId>scala-maven-plugin</artifactId>
  <version>4.9.2</version>
  <configuration>
    <!-- include test-scope classes in the REPL classpath -->
    <maven.scala.console.useTestClasspath>true</maven.scala.console.useTestClasspath>
    <maven.scala.console.useRuntimeClasspath>true</maven.scala.console.useRuntimeClasspath>
  </configuration>
</plugin>
```

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

### Command Line Compilation Options

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Control Scala compilation from the command line. Skip main source compilation or force batch recompilation. Pass extra scalac flags without modifying the POM.

```bash
# From the command line
mvn compile
# Skip main source compilation
mvn compile -Dmaven.main.skip=true
# Force batch recompile
mvn compile -DrecompileMode=all
# Pass extra scalac flags without editing pom.xml
mvn compile -DaddScalacArgs="-Xfatal-warnings|-Xlint"
```

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

### Configure Surefire for Scala Test Execution

Source: https://github.com/davidb/scala-maven-plugin/wiki/Frequently-Asked-Questions

Add this configuration to the surefire plugin to set up the argument line for executing Scala tests, including the Scala library path.

```xml
<argLine>-Xbootclasspath/p:${settings.localRepository}/org/scala-lang/scala-library/${scala.version}/scala-library-${scala.version}.jar</argLine>
```

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

### Run Scala Test Compilation

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Execute the Scala test compilation process using Maven. Includes an option to skip test compilation.

```bash
mvn test-compile
```

```bash
mvn test-compile -Dmaven.test.skip=true   # skips test compilation
```

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

### Build Project for Multiple Scala Versions

Source: https://github.com/davidb/scala-maven-plugin/wiki/Frequently-Asked-Questions

To build a project configured for cross-Scala versions, invoke Maven multiple times, specifying the desired Scala version for each build.

```sh
#! /bin/sh
        for v in 2.8.1 2.9.1 2.9.2 ; do
          mvn -DscalaVersion=$v $* 
        done
```

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

### Execute Scala Script with scala:script

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Execute Scala scripts, either embedded in the POM or from an external file. Configure script inclusion scopes and whether to keep generated files.

```bash
mvn validate          # runs the inline script during the validate phase
mvn scala:script -DscriptFile=scripts/my-task.scala
```

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

### Configure Continuous Compilation Tuning

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Optional tuning for continuous compilation modes (scala:cc and scala:cctest). Set recompile mode for incremental compilation.

```xml
<plugin>
  <groupId>net.alchim31.maven</groupId>
  <artifactId>scala-maven-plugin</artifactId>
  <version>4.9.2</version>
  <configuration>
    <recompileMode>incremental</recompileMode>
  </configuration>
</plugin>
```

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

### Run Specific Integration Test

Source: https://github.com/davidb/scala-maven-plugin/blob/master/README.md

Allows running a specific integration test by its name, useful for debugging or tuning.

```bash
./mvnw integration-test -Dinvoker.test=test1
```

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

### GPG Signature for Release

Source: https://github.com/davidb/scala-maven-plugin/blob/master/README.md

Command to create a detached GPG signature for the pom.xml file. This is a workaround for potential GPG issues on macOS during the release process.

```bash
gpg --use-agent --armor --detach-sign --output $(mktemp) pom.xml
```

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

### Add Compiler Plugins to Scala Maven Plugin

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Apply scalac compiler plugins like kind-projector or better-monadic-for to all compilations by listing them under `<compilerPlugins>`. The plugin resolves them from Maven repositories and automatically passes `-Xplugin:` arguments to scalac.

```xml
<!-- pom.xml: add kind-projector compiler plugin -->
<plugin>
  <groupId>net.alchim31.maven</groupId>
  <artifactId>scala-maven-plugin</artifactId>
  <version>4.9.2</version>
  <executions>
    <execution>
      <goals>
        <goal>compile</goal>
        <goal>testCompile</goal>
        <goal>doc-jar</goal>   <!-- compiler plugins also apply to scaladoc -->
      </goals>
    </execution>
  </executions>
  <configuration>
    <compilerPlugins>
      <compilerPlugin>
        <groupId>org.typelevel</groupId>
        <artifactId>kind-projector_2.13.16</artifactId>
        <version>0.13.3</version>
      </compilerPlugin>
      <compilerPlugin>
        <groupId>com.olegpy</groupId>
        <artifactId>better-monadic-for_2.13</artifactId>
        <version>0.3.1</version>
      </compilerPlugin>
    </compilerPlugins>
  </configuration>
</plugin>
```

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

### Compile Scala 2.13 Project with Incremental Compilation

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Configure Scala compilation for a Scala 2.13 project using incremental compilation and specify compiler and JVM arguments. Ensure correct Scala library version is included.

```xml
<dependencies>
  <dependency>
    <groupId>org.scala-lang</groupId>
    <artifactId>scala-library</artifactId>
    <version>2.13.16</version>
  </dependency>
</dependencies>

<build>
  <plugins>
    <plugin>
      <groupId>net.alchim31.maven</groupId>
      <artifactId>scala-maven-plugin</artifactId>
      <version>4.9.2</version>
      <executions>
        <execution>
          <id>scala-compile-first</id>
          <phase>process-resources</phase>
          <goals><goal>compile</goal></goals>
        </execution>
        <execution>
          <id>scala-test-compile</id>
          <phase>process-test-resources</phase>
          <goals><goal>testCompile</goal></goals>
        </execution>
      </executions>
      <configuration>
        <!-- incremental (default) uses sbt Zinc; use "all" for batch recompile -->
        <recompileMode>incremental</recompileMode>
        <args>
          <arg>-encoding</arg><arg>UTF-8</arg>
          <arg>-deprecation</arg>
          <arg>-unchecked</arg>
          <arg>-feature</arg>
        </args>
        <jvmArgs>
          <jvmArg>-Xms256m</jvmArg>
          <jvmArg>-Xmx1g</jvmArg>
        </jvmArgs>
      </configuration>
    </plugin>
  </plugins>
</build>
```

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

### Configure Scaladoc Generation with Maven Site

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Enable Scaladoc generation during the Maven site lifecycle phase. This configuration integrates the scala-maven-plugin's doc goal with the site reporting mechanism.

```xml
<!-- pom.xml: enable scaladoc generation during site phase -->
<build>
  <plugins>
    <plugin>
      <groupId>net.alchim31.maven</groupId>
      <artifactId>scala-maven-plugin</artifactId>
      <version>4.9.2</version>
      <executions>
        <execution>
          <goals>
            <goal>compile</goal>
          </goals>
        </execution>
      </executions>
      <configuration>
        <doctitle>${project.name} ${project.version} API</doctitle>
      </configuration>
    </plugin>
  </plugins>
</build>

<!-- Report section wires scala:doc into mvn site -->
<reporting>
  <plugins>
    <plugin>
      <groupId>net.alchim31.maven</groupId>
      <artifactId>scala-maven-plugin</artifactId>
      <version>4.9.2</version>
    </plugin>
  </plugins>
</reporting>
```

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

### Cross Building for Multiple Scala Versions in Maven

Source: https://github.com/davidb/scala-maven-plugin/wiki/Frequently-Asked-Questions

Configure your pom.xml to support cross-building for different Scala versions by adjusting artifact IDs, managing dependencies, and using profiles for version-specific configurations.

```xml
<artifactId>scala-maven-plugin_${scalaVersion}</artifactId>
```

```xml
<dependencies>
              <dependency>
                <groupId>y.x</groupId>
                <artifactId>z_${scalaVersion}</artifactId>
                <version>0.0</version>
              </dependency>
            </dependencies>
```

```xml
<profile>
               <id>scala-2.9.0</id>
               <activation>
                 <property>
                   <name>scalaVersion</name>
                   <value>2.9.0</value>
                 </property>
               </activation>
               <dependencies>
                  ...
```

```xml
<build>
              <plugins>
                <plugin>
                  <groupId>org.codehaus.mojo</groupId>
                  <artifactId>build-helper-maven-plugin</artifactId>
                  <version>1.5</version>
                  <executions>
                    <execution>
                      <id>add-source</id>
                      <phase>generate-sources</phase>
                      <goals>
                        <goal>add-source</goal>
                      </goals>
                      <configuration>
                        <sources>
                          <source>src/main/scala_${scalaVersion}</source>
                        </sources>
                      </configuration>
                    </execution>
                  </executions>
                </plugin>
              </plugins>
            </build>
```

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

### Configure Scala Test Compilation with Javac Flags

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Configure separate compilation for Scala test sources with specific javac flags. This snippet shows how to set arguments for both the Scala compiler and javac.

```xml
<!-- pom.xml: separate configuration for test compilation with javac flags -->
<execution>
  <id>scala-test-compile</id>
  <phase>process-test-resources</phase>
  <goals><goal>testCompile</goal></goals>
  <configuration>
    <recompileMode>incremental</recompileMode>
    <args>
      <arg>-deprecation</arg>
      <arg>-unchecked</arg>
    </args>
    <javacArgs>
      <javacArg>-Xlint:unchecked</javacArg>
      <javacArg>-Xlint:deprecation</javacArg>
    </javacArgs>
    <!-- Cache file for test incremental analysis -->
    <testAnalysisCacheFile>${project.build.directory}/analysis/test-compile</testAnalysisCacheFile>
  </configuration>
</execution>
```

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

### Package Scaladoc into a JAR

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Configure the scala-maven-plugin to generate Scaladoc HTML and package it into a -javadoc.jar artifact, typically during the package phase.

```xml
<!-- pom.xml: attach Scaladoc JAR during package phase -->
<plugin>
  <groupId>net.alchim31.maven</groupId>
  <artifactId>scala-maven-plugin</artifactId>
  <version>4.9.2</version>
  <executions>
    <execution>
      <id>scala-compile</id>
      <goals><goal>compile</goal></goals>
    </execution>
    <execution>
      <id>attach-scaladocs</id>
      <goals><goal>doc-jar</goal></goals>
    </execution>
  </executions>
</plugin>
```

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

### Configure Mixed Java and Scala Compilation in Maven

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Coordinate with the Maven compiler plugin for projects containing both Java and Scala sources. The recommended pattern is to run `scala:compile` and `scala:testCompile` before the Java compiler in their respective phases.

```xml
<!-- pom.xml: Java + Scala mixed project -->
<build>
  <plugins>
    <plugin>
      <groupId>net.alchim31.maven</groupId>
      <artifactId>scala-maven-plugin</artifactId>
      <version>4.9.2</version>
      <executions>
        <execution>
          <id>scala-compile-first</id>
          <phase>process-resources</phase>
          <goals><goal>compile</goal></goals>
        </execution>
        <execution>
          <id>scala-test-compile</id>
          <phase>process-test-resources</phase>
          <goals><goal>testCompile</goal></goals>
        </execution>
      </executions>
    </plugin>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.13.0</version>
      <configuration>
        <source>1.8</source>
        <target>1.8</target>
      </configuration>
    </plugin>
  </plugins>
</build>
```

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

### Configure Source Includes and Excludes in Scala Maven Plugin

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Control which source files are passed to the compiler using Ant-style glob patterns. Filters apply to all compilation goals. By default, the plugin includes `**/*.scala` and `**/*.java`.

```xml
<!-- pom.xml: compile only specific files, exclude generated/bad sources -->
<plugin>
  <groupId>net.alchim31.maven</groupId>
  <artifactId>scala-maven-plugin</artifactId>
  <version>4.9.2</version>
  <executions>
    <execution>
      <goals>
        <goal>compile</goal>
        <goal>testCompile</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <includes>
      <include>**/*.scala</include>
      <include>**/MyJavaClass.java</include>
    </includes>
    <excludes>
      <exclude>**/generated/**</exclude>
      <exclude>bad.scala</exclude>
    </excludes>
    <!-- Prevent Java sources being sent to scalac (compile Java separately) -->
    <sendJavaToScalac>false</sendJavaToScalac>
  </configuration>
</plugin>
```

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

### Specify Scalac Recompilation Strategy

Source: https://github.com/davidb/scala-maven-plugin/wiki/Frequently-Asked-Questions

Use this configuration to specify the recompilation detection strategy for scalac, supporting options like 'transitive'.

```xml
<arg>-make:transitive</arg>
```

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

### Configure Inline Scala Script for scala:script

Source: https://context7.com/davidb/scala-maven-plugin/llms.txt

Embed a Scala script directly within the pom.xml for custom build automation. The script receives Maven project objects.

```xml
<plugin>
  <groupId>net.alchim31.maven</groupId>
  <artifactId>scala-maven-plugin</artifactId>
  <version>4.9.2</version>
  <executions>
    <execution>
      <id>print-info</id>
      <phase>validate</phase>
      <goals><goal>script</goal></goals>
      <configuration>
        <script>
          log.info("Building: " + project.getArtifactId + " v" + project.getVersion)
          val outputDir = project.getBuild.getOutputDirectory
          log.info("Output directory: " + outputDir)
        </script>
      </configuration>
    </execution>
  </executions>
</plugin>
```

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

### Skip Tests with Maven Property

Source: https://github.com/davidb/scala-maven-plugin/wiki/Tips

To skip running tests during a Maven build, use the '-Dmaven.test.skip=true' property on the command line. This is a convenient way to bypass tests without modifying your pom.xml.

```bash
mvn .... -Dmaven.test.skip=true
```

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

### Configure Recompilation Mode in Maven

Source: https://github.com/davidb/scala-maven-plugin/wiki/Frequently-Asked-Questions

To re-enable recompiling only modified files in Scala-Maven-Plugin versions 2.13+, configure the recompilation mode via the plugin configuration or a system property.

```xml
<recompileMode>modified-only</recompileMode>
```

```properties
-Drecompilation-mode=modified-only
```

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

### Disable Tests in pom.xml

Source: https://github.com/davidb/scala-maven-plugin/wiki/Tips

To permanently disable tests by editing the pom.xml, add the 'maven.test.skip' property within the '<properties>' section. This method is preferred as it doesn't require a Surefire configuration and respects profile-specific test execution.

```xml
<properties>
  <maven.test.skip>true</maven.test.skip>
</properties>
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.