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

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 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 repository page to create your personal copy.
2. Clone your fork locally and enter the directory:

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.

You need:

• JDK 21 or 25 (Temurin/OpenJDK) — Referenced in CONTRIBUTING.md lines 12-14
• Maven 3.9.6 or higher — Referenced in CONTRIBUTING.md lines 14-15
• Node.js with Corepack enabled — Required for frontend modifications, referenced in 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:

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:

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:

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

Start the Webpack dev server for live reload:

yarn start

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

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:

mvn spotless:apply

For frontend code:

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:

mvn test -Plight-test

For UI-heavy changes, consider adding tests in the Acceptance Test Harness (ATH) repository as referenced in 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.
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 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 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}