# What Are the Dependencies for Jenkins Development? A Complete Maven Guide

> Explore Jenkins development dependencies managed by Maven. Understand core libraries, testing frameworks, and plugin POMs for seamless builds.

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

---

**Jenkins development requires a Maven-based Java dependency stack defined across modular POM files, including core runtime libraries in [`core/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/core/pom.xml), testing frameworks in [`test/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/test/pom.xml), and the plugin parent POM for extension authors.**

Jenkins is a large-scale, modular Java application built with **Apache Maven**. All compile-time, test-time, and runtime libraries are declared in the [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml) files across the `jenkinsci/jenkins` repository. Understanding these dependencies is essential for core contributions, plugin development, and custom workflow implementation.

## Core Runtime Dependencies

The foundational libraries required to build and run Jenkins are declared in [`core/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/core/pom.xml) and [`war/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/war/pom.xml). These modules define the servlet container, logging, and utility libraries that power the Jenkins master.

### Servlet Container and Web Layer

Jenkins embeds **Jetty 12** as its servlet container. In [`core/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/core/pom.xml), you will find dependencies on `org.eclipse.jetty.ee9:jetty-server` and `org.eclipse.jetty.ee9:jetty-servlet`. The servlet API is provided by `jakarta.servlet:jakarta.servlet-api`, ensuring compatibility with Jakarta EE specifications.

### Core Utilities

The core module relies on **Google Guava** (`com.google.guava:guava`) for collections and caching utilities. Logging is handled through **SLF4J** (`org.slf4j:slf4j-api`), while command-line parsing uses `org.kohsuke:args`. The [`war/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/war/pom.xml) aggregates these into the deployable web application archive alongside `org.jenkins-ci.main:jenkins-war`.

## Plugin Development Dependencies

Plugins inherit from the **plugin parent POM** (`org.jenkins-ci.plugins:plugin`) declared in the root [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml). This parent manages versions for core APIs and common plugin dependencies.

Key dependencies for plugin authors include:

- **Jenkins Core API**: `org.jenkins-ci.main:jenkins-core` (scope: **provided**)
- **Workflow Support**: `org.jenkins-ci.main:workflow-step-api` for Pipeline steps
- **Authentication**: `org.jenkins-ci.main:matrix-auth` for security utilities

Using the `provided` scope for `jenkins-core` ensures the plugin uses the classes available at runtime without bundling them into the plugin HPI file. Optional integrations like SSH support (`mina-sshd-api`) or GitHub connectivity (`github-api`) are available as separate plugin dependencies.

## Testing Dependencies

The [`test/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/test/pom.xml) module declares the complete testing stack for integration and unit tests. This centralized approach ensures consistent test behavior across all Jenkins modules.

The testing dependencies include:

- **JUnit 5**: `org.junit.jupiter:junit-jupiter-api` and `junit-jupiter-engine`
- **Mocking**: `org.mockito:mockito-core` for test doubles
- **Async Testing**: `org.awaitility:awaitility` for asynchronous condition polling
- **Coverage**: `org.jacoco:jacoco-maven-plugin` and `org.jacoco:org.jacoco.core` for code coverage reporting

These dependencies use the `test` scope and are inherited by modules running integration tests against the Jenkins core runtime.

## WebSocket and CLI Dependencies

Modern Jenkins features require specialized transport layers for real-time communication and remote administration.

### WebSocket Support

The [`websocket/spi/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/websocket/spi/pom.xml) defines the abstract API (`org.jenkins-ci.main:jenkins-websocket`), while [`websocket/jetty12-ee9/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/websocket/jetty12-ee9/pom.xml) provides the concrete implementation using `org.eclipse.jetty.ee9:jetty-websocket-jetty12`. This separation allows Jenkins to support WebSocket connections for real-time build log streaming.

### Command Line Interface

The CLI module in [`cli/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/cli/pom.xml) declares `org.jenkins-ci.main:jenkins-cli` along with `org.kohsuke:metainf-services` for service-loader utilities. These enable the Jenkins CLI client to communicate with the server over HTTP or WebSocket transports.

## Build and Plugin Management

The root [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml) manages the build lifecycle through standard Maven plugins and dependency versions. All modules inherit Java 11+ compatibility settings from this parent.

Key build dependencies include:

- **Compiler**: `org.apache.maven.plugins:maven-compiler-plugin` enforces Java 11+ source compatibility
- **Testing**: `org.apache.maven.plugins:maven-surefire-plugin` executes JUnit 5 tests
- **Packaging**: `org.apache.maven.plugins:maven-jar-plugin` and `maven-resources-plugin` handle artifact creation

All artifacts resolve from the `https://repo.jenkins-ci.org/public/` repository defined in the root POM.

## How to Declare Dependencies in a Jenkins Plugin

When developing a plugin, inherit from the Jenkins plugin parent and declare core dependencies as provided:

```xml
<project>
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.jenkins-ci.plugins</groupId>
        <artifactId>plugin</artifactId>
        <version>5.52</version>
    </parent>

    <artifactId>my-awesome-plugin</artifactId>

    <dependencies>
        <!-- Core Jenkins API (provided at runtime) -->
        <dependency>
            <groupId>org.jenkins-ci.main</groupId>
            <artifactId>jenkins-core</artifactId>
            <scope>provided</scope>
        </dependency>

        <!-- Test helpers -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

```

Access core classes in your Java source to interact with the Jenkins instance:

```java
import hudson.model.Result;
import jenkins.model.Jenkins;

public class ExampleUtil {
    public static boolean isRunningInJenkins() {
        return Jenkins.get() != null;
    }

    public static String getResultName(Result r) {
        return r.toString();
    }
}

```

## Summary

- **Core runtime**: Declared in [`core/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/core/pom.xml) and [`war/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/war/pom.xml), including Jetty 12, Jakarta Servlet API, Guava, and SLF4J.
- **Plugin development**: Uses the parent POM from `org.jenkins-ci.plugins:plugin`, treating `jenkins-core` as a provided dependency.
- **Testing stack**: Defined in [`test/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/test/pom.xml) with JUnit 5, Mockito, Awaitility, and JaCoCo for comprehensive coverage.
- **WebSocket/CLI**: Modular dependencies in [`websocket/spi/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/websocket/spi/pom.xml), [`websocket/jetty12-ee9/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/websocket/jetty12-ee9/pom.xml), and [`cli/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/cli/pom.xml) enable real-time features and remote access.
- **Build tools**: Standard Maven plugins in the root POM manage compilation and packaging for Java 11+.

## Frequently Asked Questions

### What build tool does Jenkins use for dependency management?

Jenkins uses **Apache Maven** with a multi-module project structure. The root [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml) acts as the parent, and all modules—including `core`, `war`, `test`, and `cli`—inherit common dependency versions and plugin configurations from it.

### How do I add a dependency to a Jenkins plugin?

Declare the dependency in your plugin's [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml) with the appropriate scope. Use `provided` for anything included in Jenkins core (like `jenkins-core`), `compile` for libraries you need to bundle, and `test` for testing frameworks. Inherit from `org.jenkins-ci.plugins:plugin` to ensure version alignment with the Jenkins ecosystem.

### Where are the test dependencies defined in the Jenkins source?

Testing dependencies are centralized in the [`test/pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/test/pom.xml) module. This file declares JUnit 5, Mockito, Awaitility, and JaCoCo. Modules that run integration tests depend on this artifact to receive the complete testing classpath.

### What Java version is required for Jenkins development?

According to the root POM configuration, Jenkins currently requires **Java 11 or newer** for compilation and runtime. The `maven-compiler-plugin` in the root [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml) enforces this compatibility level.