# How to Build Jenkins from Source Using Maven: Quick-Build and Full Build Guide > Build Jenkins from source using Maven with our quick-build or full-build guide. Compile jenkins.war rapidly and skip extensive tests for faster development cycles. - Repository: [Jenkins/jenkins](https://github.com/jenkinsci/jenkins) - Tags: how-to-guide - Published: 2026-07-30 --- **Run `mvn -am -pl war,bom -Pquick-build clean install` to compile Jenkins and produce a runnable `jenkins.war` in minutes while skipping the extensive integration test suite.** Building Jenkins from source requires navigating its multi-module Maven structure defined in the `jenkinsci/jenkins` repository. The top-level [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml) aggregates modules for the core engine, web UI, and plugins, allowing you to build either a minimal WAR for local development or a complete distribution. This guide explains how to use the **quick-build** profile for rapid iteration and the full build process for comprehensive testing. ## Prerequisites You need JDK 21 or JDK 25 and Maven 3.9.6 or newer installed. The [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) file in the repository root specifies these exact requirements and toolchains configuration. Ensure your environment meets these versions, as the build enforces them strictly through the Maven enforcer plugin configured in the root [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml). ## Clone the Repository Download the source and enter the project directory: ```bash git clone https://github.com/jenkinsci/jenkins.git cd jenkins ``` This checkout includes the aggregator [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml), `core/` module, `war/` module, and the `plugins/` directory containing individual plugin submodules. ## Choose Your Build Strategy The Jenkins Maven project supports two primary build modes. Select the **quick-build** profile for development or the **default lifecycle** for complete validation. ### Quick-Build Profile (Recommended) The quick-build profile, defined in the root [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml), compiles only the `war` and `bom` (Bill of Materials) modules required to produce `jenkins.war`. It skips functional tests, acceptance tests, and plugin compilation to minimize build time. Execute the quick-build: ```bash mvn -am -pl war,bom -Pquick-build clean install ``` - **`-am`** (also-make): Builds all dependencies of the specified modules automatically. - **`-pl war,bom`**: Restricts the build to the WAR and BOM modules explicitly. - **`-Pquick-build`**: Activates the profile that disables lengthy test execution and frontend asset generation (unless `-Dskip.yarn` is omitted). Upon completion, the file `war/target/jenkins.war` contains the runnable application. ### Full Build (Complete Distribution) To compile every plugin and run the full test matrix, omit the quick-build profile: ```bash mvn clean install ``` According to the `jenkinsci/jenkins` source code, this processes all modules listed in the aggregator [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml), including the `core/` engine, every plugin in `plugins/`, and the `war/` packaging module. This process takes significantly longer because it executes unit tests, integration tests, and the acceptance-test harness validations. ## Run Jenkins Locally The [`war/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/war/pom.xml) configures the Jetty Maven plugin to launch the compiled WAR directly. Set the required JVM module system flags and run: ```bash MAVEN_OPTS='--add-opens java.base/java.lang=ALL-UNNAMED \ --add-opens java.base/java.io=ALL-UNNAMED \ --add-opens java.base/java.util=ALL-UNNAMED' \ mvn -pl war jetty:run ``` This command starts Jenkins on `http://localhost:8080` using the artifact produced in `war/target/`. The `-pl war` flag limits execution to the WAR module, while `jetty:run` invokes the embedded server configuration. ## Build Frontend Assets (Optional) The Jenkins web interface resides in the `war` module and requires Node.js and Yarn for asset compilation. After the initial Maven build, build the UI: ```bash export PATH=$PWD/node:$PWD/node/node_modules/corepack/shims:$PATH yarn install yarn start ``` The [`war/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/war/pom.xml) automatically triggers `yarn` during the Maven build unless you pass `-Dskip.yarn` as a property. Running `yarn start` launches a Webpack development server with hot-reload for frontend development work. ## Understanding the Maven Architecture The Jenkins repository organizes code into a standard Maven multi-module layout. The **root [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml)** serves as the aggregator, propagating common plugin configurations—such as Spotless for code formatting, Checkstyle for style enforcement, and Enforcer for version rules—to all child modules. The **core** module ([`core/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/core/pom.xml)) compiles into `jenkins-core.jar`, containing the main application logic. The **war** module ([`war/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/war/pom.xml)) packages this JAR with web resources into the final `jenkins.war` artifact. The **quick-build** profile exploits this structure by overriding the default lifecycle in the root POM to exclude plugin modules and test execution, targeting only the artifacts necessary for a functional server. ## Summary - **Quick-build** (`-Pquick-build -pl war,bom`) generates `war/target/jenkins.war` in minutes by skipping tests and plugins. - **Full build** (`mvn clean install`) compiles all plugins and runs the complete test suite, taking significantly longer. - **Local execution** requires `mvn -pl war jetty:run` with specific `MAVEN_OPTS` to handle Java module system restrictions. - **Frontend assets** in the `war` module require Node/Yarn and integrate automatically unless `-Dskip.yarn` is specified. - **Key files**: Root [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml) for build logic, [`war/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/war/pom.xml) for the runnable WAR, and [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) for environment prerequisites. ## Frequently Asked Questions ### How long does it take to build Jenkins from source? Using the quick-build profile, compilation finishes in 5–10 minutes on modern hardware, generating `war/target/jenkins.war`. A full build including all plugins and the acceptance-test harness requires 30–60 minutes or more, depending on your system resources and network speed for dependency resolution. ### Can I build Jenkins without running tests? Yes. Append `-Pquick-build` to your Maven command to skip the majority of unit and integration tests, or add `-DskipTests` to any command to bypass the test phase while still compiling source code. The quick-build profile is defined in the root [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml) specifically for this purpose. ### What Java version is required to compile Jenkins? You must use JDK 21 or JDK 25. The build configuration in the root [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml) enforces this via Maven toolchains and the enforcer plugin. Attempting to build with older versions results in immediate failure with a clear error message indicating the version requirement per the [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) guidelines. ### Where is the compiled WAR file located after a successful build? The `jenkins.war` file is located at `war/target/jenkins.war` relative to the repository root. This self-contained archive can be deployed to any servlet container or executed directly using `java -jar war/target/jenkins.war` after completing the Maven build process.