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

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

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:

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 file (lines 65-66) explicitly directs developers to the Jenkins Developer Documentation homepage with the text: "check the … Jenkins Developer Documentation".

CONTRIBUTING.md Guidelines

As noted in lines 17-18 of 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 file declares hpi packaging and targets a specific Jenkins core version via the jenkins.version property:

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

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 (lines 65-66), 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 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 (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 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.

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