# Where to Find Jenkins Plugin Development Resources: Official Guides and Source References

> Find essential Jenkins plugin development resources on jenkins.io/doc/developer/. Access official guides and source references directly from the jenkinsci/jenkins repository for seamless development.

- Repository: [Jenkins/jenkins](https://github.com/jenkinsci/jenkins)
- Tags: getting-started
- Published: 2026-07-29

---

**The canonical Jenkins plugin development resources are hosted on the official Jenkins website at jenkins.io/doc/developer/, with direct links maintained in the jenkinsci/jenkins repository's README.md, CONTRIBUTING.md, and docs/MAINTAINERS.adoc files.**

Developers extending the open-source automation server can find comprehensive Jenkins plugin development resources directly within the jenkinsci/jenkins repository and on the official Jenkins documentation portal. These materials cover environment configuration, build workflows, and governance policies essential for creating and maintaining plugins.

## Official Jenkins Developer Documentation Portal

The primary entry point for plugin authors is the **Jenkins Developer Documentation** homepage at https://www.jenkins.io/doc/developer/. This portal aggregates all official tutorials, API references, and best-practice guides required to build, test, and publish Jenkins plugins.

### Preparing Your Development Environment

The **"Preparing for Plugin Development"** tutorial (https://www.jenkins.io/doc/developer/tutorial/prepare/) provides step-by-step instructions for configuring your local environment. According to [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) in the core repository (lines 17-18), developers must follow this guide to set up their development environment before contributing code.

This tutorial demonstrates generating a new plugin project using the Maven archetype:

```bash
mvn -U archetype:generate -Dfilter=io.jenkins.archetypes:plugin

```

### Building and Debugging Plugins

The **"Building and Debugging Plugins"** guide (https://www.jenkins.io/doc/developer/building/) documents the Maven commands necessary to compile, package, and test your plugin. The standard workflow involves building the `.hpi` file and running a local Jenkins instance with your plugin loaded:

```bash
mvn clean install
mvn hpi:run

```

## Locating Resources in the Jenkins Core Repository

The jenkinsci/jenkins repository contains direct pointers to external documentation within its standard contribution files, making it easy to discover authoritative resources directly from the source tree.

### README.md References

The repository's [`README.md`](https://github.com/jenkinsci/jenkins/blob/main/README.md) file (lines 65-66) explicitly directs developers to the Jenkins Developer Documentation homepage with the text: "check the … [Jenkins Developer Documentation](https://www.jenkins.io/doc/developer/)".

### CONTRIBUTING.md Guidelines

As noted in lines 17-18 of [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md), new contributors are instructed to prepare their environment using the official tutorial before submitting code. This ensures all plugin developers follow standardized setup procedures.

### Maintainer Documentation

For long-term maintenance concerns, `docs/MAINTAINERS.adoc` (lines 450-452) links to the **Plugin Adoption Policy** page, which explains the lifecycle, governance standards, and adoption procedures for plugins transferred between maintainers.

## Plugin Governance and Maintenance Policies

Beyond initial development, understanding the **Plugin Governance** framework is essential for sustainable maintenance. The Plugin Adoption Policy (https://www.jenkins.io/doc/developer/plugin-governance/adopt-a-plugin/) referenced in `docs/MAINTAINERS.adoc` establishes guidelines for plugin lifecycle management, security best practices, and community ownership transitions.

## Creating Your First Plugin: Code Structure

When generated from the Maven archetype, a minimal Jenkins plugin follows a specific structure. The [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml) file declares `hpi` packaging and targets a specific Jenkins core version via the `jenkins.version` property:

```xml
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>helloworld-plugin</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>hpi</packaging>

    <properties>
        <jenkins.version>2.462</jenkins.version>
        <java.level>11</java.level>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.jenkins-ci.tools</groupId>
                <artifactId>maven-hpi-plugin</artifactId>
                <version>3.14</version>
                <configuration>
                    <jenkinsVersion>${jenkins.version}</jenkinsVersion>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

```

A basic `Builder` extension requires the `@Extension` annotation for automatic registration and `@DataBoundConstructor` for configuration binding:

```java
package com.example.helloworld;

import hudson.Extension;
import hudson.Launcher;
import hudson.model.AbstractBuild;
import hudson.model.BuildListener;
import hudson.model.AbstractProject;
import hudson.tasks.Builder;
import hudson.util.FormValidation;
import org.kohsuke.stapler.*;

public class HelloWorldBuilder extends Builder {

    private final String name;

    @DataBoundConstructor
    public HelloWorldBuilder(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public boolean perform(AbstractBuild<?, ?> build, Launcher launcher,
                           BuildListener listener) {
        listener.getLogger().println("Hello, " + name + "!");
        return true;
    }

    @Extension
    public static final class DescriptorImpl extends BuildStepDescriptor<Builder> {
        public DescriptorImpl() { load(); }

        public boolean isApplicable(Class<? extends AbstractProject> aClass) {
            return true;
        }

        public String getDisplayName() {
            return "Say hello";
        }

        public FormValidation doCheckName(@QueryParameter String value) {
            if (value.length() == 0)  return FormValidation.error("Name is required");
            return FormValidation.ok();
        }
    }
}

```

## Summary

- The **Jenkins Developer Documentation** at jenkins.io/doc/developer/ serves as the primary portal for plugin development tutorials and API references.
- The jenkinsci/jenkins repository links to these resources in [`README.md`](https://github.com/jenkinsci/jenkins/blob/main/README.md) (lines 65-66), [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) (lines 17-18), and `docs/MAINTAINERS.adoc` (lines 450-452).
- New plugins are generated using the **Maven archetype** (`io.jenkins.archetypes:plugin`) and built with the **Maven HPI Plugin**.
- Plugin governance policies, including adoption procedures, are documented on the official site and referenced in the core repository's maintainer documentation.

## Frequently Asked Questions

### Where is the official Jenkins plugin development documentation located?

The official documentation resides at https://www.jenkins.io/doc/developer/, which hosts tutorials, API references, and building guides. This URL is explicitly referenced in the [`README.md`](https://github.com/jenkinsci/jenkins/blob/main/README.md) file of the jenkinsci/jenkins repository at lines 65-66.

### How do I set up a local environment for Jenkins plugin development?

Set up your environment by following the **"Preparing for Plugin Development"** tutorial linked from [`CONTRIBUTING.md`](https://github.com/jenkinsci/jenkins/blob/main/CONTRIBUTING.md) (lines 17-18). This involves installing Maven, generating a project from the `io.jenkins.archetypes:plugin` archetype, and running `mvn hpi:run` to launch Jenkins with your plugin.

### What is the standard build tool for Jenkins plugins?

**Apache Maven** is the standard build tool. The [`pom.xml`](https://github.com/jenkinsci/jenkins/blob/main/pom.xml) file must use `hpi` packaging and include the `maven-hpi-plugin` (version 3.14 or compatible) to handle Jenkins-specific packaging and debugging tasks.

### Where can I find guidelines for maintaining or adopting an existing Jenkins plugin?

Plugin governance guidelines, including adoption policies and lifecycle management, are documented at https://www.jenkins.io/doc/developer/plugin-governance/adopt-a-plugin/. The jenkinsci/jenkins repository references these policies in `docs/MAINTAINERS.adoc` at lines 450-452.