# How to Contribute to Jenkins Core Development: A Complete Guide for New Contributors

> Learn how to contribute to Jenkins core development. Fork jenkinsci/jenkins, set up JDK 21/25 and Maven, build, and submit PRs for review and approval.

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

---

**To contribute to Jenkins core development, fork the jenkinsci/jenkins repository, set up JDK 21 or 25 with Maven 3.9.6+, build using the quick-build profile, and submit pull requests that pass CI on ci.jenkins.io and receive two maintainer approvals.**

Contributing to Jenkins core development requires following a specific workflow defined in the [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) file of the jenkinsci/jenkins repository. This guide walks you through the complete setup—from forking the repository to submitting your first pull request—using the exact build profiles and tooling used by the Jenkins core team.

## Prerequisites for Jenkins Core Development

### Java and Maven Requirements

According to [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) (lines 12-15), Jenkins core requires **JDK 21 or 25** (Temurin or OpenJDK distribution) and **Maven 3.9.6** or higher. You can use any Maven-aware IDE such as IntelliJ IDEA or Eclipse, as mentioned in lines 16-17 of the contributor documentation.

### Node.js for Frontend Contributions

For UI changes, install **Node.js** and enable **Corepack** to access the `yarn` binary. The repository includes a `node` directory with packaged tools, so the build process can find Yarn through the path `$PWD/node/node_modules/corepack/shims`.

## Setting Up Your Development Environment

Start by forking the repository on GitHub and cloning your fork locally:

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

```

This creates your personal copy of the codebase where you can experiment with changes before submitting them upstream.

## Building Jenkins from Source

### Quick Build Profile

The fastest way to generate a WAR file without running tests uses the **quick-build** profile defined in the Maven configuration:

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

```

The resulting artifact appears at `war/target/jenkins.war` immediately after the build completes.

### Running a Development Instance

To launch a local server with remote-debug support, set the required JVM options to open internal Java modules and run Jetty:

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

If modifying UI code in the Jenkins frontend, start the Webpack development server for live reload capabilities:

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

```

When running the backend simultaneously, start it with `-Dskip.yarn` to avoid duplicate asset processing, as documented in the frontend build section of [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md).

## Code Quality and Linting

Maintain consistent formatting using the built-in linting tools integrated into the Maven build:

- **Backend**: Run `mvn spotless:apply` to auto-format Java code according to the project style
- **Frontend**: Run `yarn lint` or `yarn lint:fix` for JavaScript and CSS formatting

Both checks can be invoked manually for rapid feedback during development, though they also run automatically during the full build process.

## Testing Your Changes

Jenkins provides three test profiles defined in the Maven configuration:

- **`light-test`**: Unit tests only for fastest feedback
- **`smoke-test`**: Unit tests plus selected functional tests  
- **`all-tests`**: Complete test suite (default profile)

Run a specific profile using the `-P` flag:

```bash
mvn test -Plight-test

```

For UI-heavy changes, add tests in the separate **Acceptance Test Harness (ATH)** repository rather than the core test suite.

## Submitting Your Contribution

Create a pull request against `jenkinsci/jenkins:master` following the template located at [`.github/PULL_REQUEST_TEMPLATE.md`](https://github.com/jenkinsci/jenkins/blob/main/.github/PULL_REQUEST_TEMPLATE.md). The Jenkins core team merges PRs only after meeting strict quality gates:

- At least **two approvals** from core maintainers
- No outstanding `needs-fix` or `needs-justification` labels
- Successful completion of the CI pipeline on `ci.jenkins.io`

If your pull request receives no review activity for three days, ping `@jenkinsci/core-pr-reviewers` to request attention. After merge, your change enters the weekly release line automatically, while the LTS team handles potential back-porting to long-term support baselines.

## Key Files and Directories in Jenkins Core

Understanding the repository structure accelerates your ability to contribute effectively:

- **[`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml)**: Maven parent descriptor defining modules, dependencies, and build profiles
- **[`war/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/war/pom.xml)**: Specific configuration for building the `jenkins.war` artifact
- **`Jenkinsfile`**: CI pipeline definition used by `ci.jenkins.io`
- **`core/src/main/java/`**: Core server implementation containing the bulk of Java source code
- **`test/src/`**: Unit and functional test suite
- **[`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md)**: Canonical contributor guide with setup and workflow details
- **`docs/MAINTAINERS.adoc`**: Guidelines for core maintainers explaining the review process

## Summary

- **Fork and clone** the jenkinsci/jenkins repository to your GitHub account before making changes
- **Install JDK 21+ and Maven 3.9.6+** as mandatory build requirements defined in [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md)
- **Use `mvn -am -pl war,bom -Pquick-build`** for rapid WAR generation during iterative development
- **Run `mvn spotless:apply`** before committing to ensure Java code formatting compliance
- **Execute `mvn test -Plight-test`** for quick validation of unit tests before submission
- **Submit PRs** that pass CI on `ci.jenkins.io` and obtain two maintainer approvals before merging

## Frequently Asked Questions

### What Java version do I need to contribute to Jenkins core?

Jenkins core requires **JDK 21 or 25** (Temurin or OpenJDK distribution) as specified in [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) lines 12-14. While newer JDK versions might compile successfully, only versions 21 and 25 are officially supported and tested by the core maintainers.

### How do I run Jenkins locally for development testing?

Use `mvn -pl war jetty:run` with the `MAVEN_OPTS` flags specified in [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) to open required Java internal modules. For frontend development, run `yarn start` in a separate terminal to enable the Webpack dev server with live reload capabilities, then launch the backend with `-Dskip.yarn` to prevent asset duplication.

### What tests should I run before submitting a pull request?

At minimum, run `mvn test -Plight-test` to execute unit tests locally. If your changes modify core functionality or APIs, use `mvn test -Psmoke-test` to include selected functional tests. The full `all-tests` profile runs automatically in CI on `ci.jenkins.io` after you open your pull request.

### How long does it take for a Jenkins core PR to get merged?

Merge requires at least two maintainer approvals plus passing CI checks on `ci.jenkins.io`. If no reviewer responds within three days, contributors should ping `@jenkinsci/core-pr-reviewers` in a comment. After merge, changes enter the weekly release line immediately, while potential back-porting to the LTS (Long-Term Support) branch is handled separately by the dedicated LTS team.