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

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 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 (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:

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:

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:

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:

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.

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:

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. 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: Maven parent descriptor defining modules, dependencies, and build profiles
• 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: 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
• 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 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 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.

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