# How to Contribute to Jenkins Core: Complete Setup and Workflow Guide

> Learn how to contribute to Jenkins core. Follow our guide to fork the repository, set up your environment, build Jenkins, and submit a pull request for review.

- Repository: [Jenkins/jenkins](https://github.com/jenkinsci/jenkins)
- Tags: how-to-guide
- Published: 2026-08-01

---

**To contribute to Jenkins core, fork the jenkinsci/jenkins repository, set up JDK 21+ and Maven 3.9.6+, build using the quick-build profile, and submit a pull request that passes CI and receives two maintainer approvals.**

Contributing to Jenkins core follows a standardized workflow defined in the repository's [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) file. This guide walks through the complete development lifecycle from forking the repository to submitting changes for review, covering build commands, testing profiles, and code quality requirements.

## Forking and Cloning the Repository

Start by creating your own copy of the repository on GitHub.

1. Click **Fork** on the [jenkinsci/jenkins](https://github.com/jenkinsci/jenkins) repository page to create your personal copy.
2. Clone your fork locally and enter the directory:

```bash
git clone https://github.com/<your-username>/jenkins.git
cd jenkins

```

## Setting Up Your Development Environment

Jenkins core is a Java Maven project requiring specific toolchain versions as documented in [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md).

You need:

- **JDK 21 or 25** (Temurin/OpenJDK) — Referenced in [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) lines 12-14
- **Maven 3.9.6 or higher** — Referenced in [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) lines 14-15
- **Node.js** with **Corepack** enabled — Required for frontend modifications, referenced in [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md)

For frontend work, ensure Corepack is active so the `yarn` binary becomes available from the repository's `node` directory.

## Building Jenkins Core from Source

The fastest way to generate the WAR file without running tests uses the **quick-build** profile.

Execute the build command:

```bash
mvn -am -pl war,bom -Pquick-build clean install

```

The artifact appears at `war/target/jenkins.war`.

To launch a development instance with remote-debug support:

```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

```

## Frontend Development and Asset Building

When modifying UI code, enable the frontend toolchain and development server.

First, export the Node and Yarn paths:

```bash
export PATH=$PWD/node:$PWD/node/node_modules/corepack/shims:$PATH

```

Start the Webpack dev server for live reload:

```bash
yarn start

```

When running the backend with the dev server, add `-Dskip.yarn` to prevent duplicate asset processing:

```bash
mvn -pl war jetty:run -Dskip.yarn

```

## Code Quality and Linting

Jenkins enforces code standards through automated linting integrated into the Maven build.

For **backend** Java code:

```bash
mvn spotless:apply

```

For **frontend** code:

```bash
yarn lint
yarn lint:fix

```

Both tools can be invoked manually for rapid feedback or will run automatically during the full build.

## Testing Your Changes

Jenkins provides three distinct test profiles defined in the Maven configuration:

- **`-Plight-test`** — Runs unit tests only for rapid feedback
- **`-Psmoke-test`** — Runs unit tests plus selected functional tests
- **`-Pall-tests`** — Runs the full test suite (default profile)

Run a specific profile with:

```bash
mvn test -Plight-test

```

For UI-heavy changes, consider adding tests in the **Acceptance Test Harness (ATH)** repository as referenced in [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md).

## Submitting a Pull Request

Follow the repository's collaborative workflow to submit your changes.

1. Create a feature branch, commit your changes, and push to your fork.
2. Open a pull request against `jenkinsci/jenkins:master`.
3. Follow the PR template located at [`.github/PULL_REQUEST_TEMPLATE.md`](https://github.com/jenkinsci/jenkins/blob/main/.github/PULL_REQUEST_TEMPLATE.md).
4. Apply appropriate **labels** (such as `good first issue` or `needs-docs`) from the repository's label page.

The Jenkins core team merges PRs after meeting these criteria:

- At least **two approvals** from maintainers
- No outstanding `needs-fix` or `needs-justification` labels
- Successful CI build on `ci.jenkins.io`

If review stalls, ping `@jenkinsci/core-pr-reviewers` after three days of inactivity.

## Summary

- Fork the `jenkinsci/jenkins` repository and clone locally to begin contributing to Jenkins core.
- Install **JDK 21+**, **Maven 3.9.6+**, and **Node.js** with Corepack for the complete development environment.
- Use `mvn -am -pl war,bom -Pquick-build clean install` to generate the WAR file quickly at `war/target/jenkins.war`.
- Run `mvn spotless:apply` for Java formatting and `yarn lint:fix` for frontend code quality.
- Execute tests using `-Plight-test` for quick validation or `-Pall-tests` for full verification.
- Submit PRs against the master branch following the template in [`.github/PULL_REQUEST_TEMPLATE.md`](https://github.com/jenkinsci/jenkins/blob/main/.github/PULL_REQUEST_TEMPLATE.md) and obtain two approvals for merge.

## Frequently Asked Questions

### What Java version is required to build Jenkins core?

Jenkins core requires **JDK 21 or 25** (Temurin/OpenJDK) according to [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) lines 12-14. While the project may compile with newer versions, the CI pipeline and official builds target these specific LTS or latest JDK releases to ensure compatibility.

### How do I run Jenkins core locally without building the full test suite?

Use the **quick-build** profile to skip tests and generate the WAR file rapidly. Run `mvn -am -pl war,bom -Pquick-build clean install` then execute `mvn -pl war jetty:run` with the appropriate `MAVEN_OPTS` for Java module access. This starts a local instance suitable for manual testing and debugging.

### What is the difference between the light-test and smoke-test profiles?

The **light-test** profile executes only unit tests, providing rapid feedback during development iterations. The **smoke-test** profile runs unit tests plus a curated set of functional tests that verify critical integration paths. Use light-test for initial validation and smoke-test before submitting PRs to ensure broader stability.

### How long does the pull request review process typically take?

The Jenkins core team aims to review PRs promptly, but you should expect several days to weeks depending on complexity and maintainer availability. If your PR receives no response after three days, mention `@jenkinsci/core-pr-reviewers` in a comment to request attention. All merges require at least two maintainer approvals and passing CI on `ci.jenkins.io`.