# Building Scala Applications Sample

version 7.6.6-20260801035835+0000

- Groovy DSL

- Kotlin DSL

| You can open this sample inside an IDE using the IntelliJ native importer or Eclipse Buildship.

This guide demonstrates how to create a Scala application with Gradle using `gradle init`. You can follow the guide step-by-step to create a new project from scratch or download the complete sample project using the links above.

## What you’ll build

You’ll generate a Scala application that follows Gradle’s conventions.

## What you’ll need

- A text editor or IDE - for example IntelliJ IDEA

- A Java Development Kit (JDK), version 8 or higher - for example AdoptOpenJDK

- The latest Gradle distribution

## Create a project folder

Gradle comes with a built-in task, called `init`, that initializes a new Gradle project in an empty folder. The `init` task uses the (also built-in) `wrapper` task to create a Gradle wrapper script, `gradlew`.

The first step is to create a folder for the new project and change directory into it.

    $ mkdir demo
    $ cd demo

## Run the init task

From inside the new project directory, run the `init` task using the following command in a terminal: `gradle init`. When prompted, select the `2: application` project type and `5: Scala` as implementation language. Next you can choose the DSL for writing buildscripts - `1 : Groovy` or `2: Kotlin`. For the other questions, press enter to use the default values.

The output will look like this:

    $ gradle init

    Select type of project to generate:
      1: basic
      2: application
      3: library
      4: Gradle plugin
    Enter selection (default: basic) [1..4] 2

    Select implementation language:
      1: C++
      2: Groovy
      3: Java
      4: Kotlin
      5: Scala
      6: Swift
    Enter selection (default: Java) [1..6] 5

    Select build script DSL:
      1: Groovy
      2: Kotlin
    Enter selection (default: Groovy) [1..2] 1

    Project name (default: demo):
    Source package (default: demo):

    BUILD SUCCESSFUL
    2 actionable tasks: 2 executed

The `init` task generates the new project with the following structure:

    ├── gradle (1)
    │   └── wrapper
    │       ├── gradle-wrapper.jar
    │       └── gradle-wrapper.properties
    ├── gradlew (2)
    ├── gradlew.bat (2)
    ├── settings.gradle (3)
    └── app
        ├── build.gradle (4)
        └── src
            ├── main
            │   └── scala (5)
            │       └── demo
            │           └── App.scala
            └── test
                └── scala (6)
                    └── demo
                        └── AppSuite.scala

    ├── gradle (1)
    │   └── wrapper
    │       ├── gradle-wrapper.jar
    │       └── gradle-wrapper.properties
    ├── gradlew (2)
    ├── gradlew.bat (2)
    ├── settings.gradle.kts (3)
    └── app
        ├── build.gradle.kts (4)
        └── src
            ├── main
            │   └── scala (5)
            │       └── demo
            │           └── App.scala
            └── test
                └── scala (6)
                    └── demo
                        └── AppSuite.scala

1 | Generated folder for wrapper files
2 | Gradle wrapper start scripts
3 | Settings file to define build name and subprojects
4 | Build script of `app` project
5 | Default Scala source folder
6 | Default Scala test source folder

You now have the project setup to build a Scala application.

## Review the project files

The `settings.gradle(.kts)` file has two interesting lines:

settings.gradle

    rootProject.name = 'demo'
    include('app')

settings.gradle.kts

    rootProject.name = "demo"
    include("app")

- `rootProject.name` assigns a name to the build, which overrides the default behavior of naming the build after the directory it’s in. It’s recommended to set a fixed name as the folder might change if the project is shared - e.g. as root of a Git repository.

- `include("app")` defines that the build consists of one subproject called `app` that contains the actual code and build logic. More subprojects can be added by additional `include(…​)` statements.

Our build contains one subproject called `app` that represents the Scala application we are building. It is configured in the `app/build.gradle(.kts)` file:

app/build.gradle

    plugins {
        id 'scala' (1)

        id 'application' (2)
    }

    repositories {
        mavenCentral() (3)
    }

    dependencies {
        implementation 'org.scala-lang:scala-library:2.13.9' (4)

        implementation 'com.google.guava:guava:32.1.3-jre' (5)

        testImplementation 'junit:junit:4.13.2' (6)
        testImplementation 'org.scalatest:scalatest_2.13:3.2.13'
        testImplementation 'org.scalatestplus:junit-4-13_2.13:3.2.2.0'

        testRuntimeOnly 'org.scala-lang.modules:scala-xml_2.13:1.2.0' (7)
    }

    application {
        mainClass = 'demo.App' (8)
    }

app/build.gradle.kts

    plugins {
        scala (1)

        application (2)
    }

    repositories {
        mavenCentral() (3)
    }

    dependencies {
        implementation("org.scala-lang:scala-library:2.13.9") (4)

        implementation("com.google.guava:guava:32.1.3-jre") (5)

        testImplementation("junit:junit:4.13.2") (6)
        testImplementation("org.scalatest:scalatest_2.13:3.2.13")
        testImplementation("org.scalatestplus:junit-4-13_2.13:3.2.2.0")

        testRuntimeOnly("org.scala-lang.modules:scala-xml_2.13:1.2.0") (7)
    }

    application {
        mainClass.set("demo.App") (8)
    }

1 | Apply the scala Plugin to add support for Scala.
2 | Apply the application plugin to add support for building a CLI application in Java.
3 | Use Maven Central for resolving dependencies.
4 | Use Scala 2.13 in our library project
5 | This dependency is used by the application.
6 | Use Scalatest for testing our library
7 | Need scala-xml at test runtime
8 | Define the main class for the application.

The file `src/main/scala/demo/App.scala` is shown here:

Generated src/main/scala/demo/App.scala

    /*
     * This Scala source file was generated by the Gradle 'init' task.
     */
    package demo

    object App {
      def main(args: Array[String]): Unit = {
        println(greeting())
      }

      def greeting(): String = "Hello, world!"
    }

The generated test, `src/test/scala/demo/App.scala` is shown next:

Generated src/test/scala/demo/AppSuite.scala

    /*
     * This Scala Testsuite was generated by the Gradle 'init' task.
     */
    package demo

    import org.scalatest.funsuite.AnyFunSuite
    import org.junit.runner.RunWith
    import org.scalatestplus.junit.JUnitRunner

    @RunWith(classOf[JUnitRunner])
    class AppSuite extends AnyFunSuite {
      test("App has a greeting") {
        assert(App.greeting() != null)
      }
    }

The generated test class has a single ScalaTest test. The test instantiates the `App` class, invokes a method on it, and checks that it returns the expected value.

## Run the application

Thanks to the `application` plugin, you can run the application directly from the command line. The `run` task tells Gradle to execute the `main` method in the class assigned to the `mainClass` property.

    $ ./gradlew run

    > Task :app:run
    Hello world!

    BUILD SUCCESSFUL
    2 actionable tasks: 2 executed

| The first time you run the wrapper script, `gradlew`, there may be a delay while that version of `gradle` is downloaded and stored locally in your `~/.gradle/wrapper/dists` folder.

## Bundle the application

The `application` plugin also bundles the application, with all its dependencies, for you. The archive will also contain a script to start the application with a single command.

    $ ./gradlew build

    BUILD SUCCESSFUL in 0s
    7 actionable tasks: 7 executed

If you run a full build as shown above, Gradle will have produced the archive in two formats for you: `app/build/distributions/app.tar` and `app/build/distributions/app.zip`.

## Publish a Build Scan

The best way to learn more about what your build is doing behind the scenes, is to publish a build scan. To do so, just run Gradle with the `--scan` flag.

    $ ./gradlew build --scan

    BUILD SUCCESSFUL in 0s
    7 actionable tasks: 7 executed

    Publishing a build scan to scans.gradle.com requires accepting the Gradle Terms of Service defined at https://gradle.com/terms-of-service.
    Do you accept these terms? [yes, no] yes

    Gradle Terms of Service accepted.

    Publishing build scan...
    https://gradle.com/s/5u4w3gxeurtd2

Click the link and explore which tasks where executed, which dependencies where downloaded and many more details!

## Summary

That’s it! You’ve now successfully configured and built a Scala application project with Gradle. You’ve learned how to:

- Initialize a project that produces a Scala application

- Run the build and view the test report

- Execute a Scala application using the `run` task from the `application` plugin

- Bundle the application in an archive

## Next steps

To learn more about how you can further customize Scala application projects, check out the following user manual chapters:

- Building Java & JVM projects

- Java Application Plugin documentation