Skip to content
Switch branches/tags


Gradle plugin that creates a publish task to automatically upload all of your Java, Kotlin or Android libraries to any Maven instance. This plugin is based on Chris Banes initial implementation and has been enhanced to add Kotlin support and keep up with the latest changes.

Set up


buildscript {
  repositories {
  dependencies {
    classpath 'com.vanniktech:gradle-maven-publish-plugin:0.18.0'

apply plugin: "com.vanniktech.maven.publish"

Snapshots can be found here.

Setting properties

To configure the coordinates of your published artifacts as well as the POM this plugin uses Gradle properties. It's generally recommended to set them in your file.


POM_NAME=My Library
POM_DESCRIPTION=A description of what my library does.

POM_LICENSE_NAME=The Apache Software License, Version 2.0



This Gradle plugin is using itself to publish any of the updates and sets the Gradle properties in this

In multi module projects you can set most properties in the root file and then only set the module specific ones in the submodules. For example if you have two modules called runtime and driver you could only set POM_ARTIFACT_ID and POM_NAME in <project-dir>/runtime/ and <project-dir>/driver/ while sharing the rest by putting them into <project-dir>/

Where to upload to

Without any further configuration the plugin has two tasks. publish which will upload to Maven Central (through Sonatype OSSRH) by default. To publish to the local maven repository on your machine (~/.m2/repository) there is publishToMavenLocal.

In case you are using you need to configure that like this:

allprojects {
    plugins.withId("com.vanniktech.maven.publish") {
        mavenPublish {
            sonatypeHost = "S01"

The username and password for Sonatype OSS can be provided as Gradle properties called mavenCentralUsername and mavenCentralPassword to avoid having to commit them. You can also supply them as environment variables called ORG_GRADLE_PROJECT_mavenCentralUsername and ORG_GRADLE_PROJECT_mavenCentralPassword.

To remove the default repository set sonatypeHost to null.

You can add additional repositories to publish to using the standard Gradle APIs:

publishing {
    repositories {
        maven {
            def releasesRepoUrl = "$buildDir/repos/releases"
            def snapshotsRepoUrl = "$buildDir/repos/snapshots"
            url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl

More information can be found in Gradle's documentation

Note: To prevent looping behavior, especially in Kotlin projects / modules, you need to run the publish task with --no-daemonand --no-parallel flags


The plugin supports signing all of your release artifacts with GPG. This is a requirement when publishing to Maven Central - our default behavior. Any version ending in -SNAPSHOT will never be signed. Signing parameters can be configured via:


It's best to place them inside your home directory (for windows %UserProfile%), $HOME/.gradle/ You can find more information about these properties in Gradle's documentaion.

In case you want to use in memory signing keys, which works great for CI, you can specify them like this instead:

# Optional.
# If key was created with a password.

These properties can also be provided as environment variables by prefixing them with ORG_GRADLE_PROJECT_

It is possible to disable signing of release artifacts directly in your build scripts (takes precedence):

mavenPublish {
  releaseSigningEnabled = false

Alternatively, you can use a Gradle property which is recommended if you only want to sign certain builds or only build on certain machines.


Android Variants

By default, the "release" variant will be used for publishing. Optionally, a specific variant can be defined by the plugin extension:

mavenPublish {
  androidVariantToPublish = "demoDebug"  // or use'PUBLISH_VARIANT'), etc.


Once publish is called, and if you're using a Nexus repository, you'll have to make a release. This can be done manually by following the release steps at sonatype.

Additionally, the plugin will create a closeAndReleaseRepository task that you can call after publish:

# prepare your release by assigning a version (remove the -SNAPSHOT suffix)
./gradlew publish --no-daemon --no-parallel
./gradlew closeAndReleaseRepository

It assumes there's only one staging repository active when closeAndReleaseRepository is called. If you have stale staging repositories, you'll have to delete them by logging at (or you Nexus instance).

Base plugin

Starting with version 0.15.0 there is a base plugin. This new plugin has the same capabilities as the main plugin but does not configure anything automatically. In the current stage the APIs are still marked with @Incubating so they might change.

In your root build.gradle file you can do the general configuration for all modules in your project.

import com.vanniktech.maven.publish.SonatypeHost

allprojects {
    plugins.withId("com.vanniktech.maven.publish.base") {
        group = "com.example.project"
        version = "1.0.3-SNAPSHOT"

        mavenPublishing {

            // Will only apply to non snapshot builds.
            // Uses credentials as described above, supports both regular and in memory signing.

            pom {
                name = "My Library"
                description = "A description of what my library does."
                inceptionYear = "2020"
                url = "https ://"
                licenses {
                    license {
                        name = "The Apache License, Version 2.0"
                        url = ""
                        distribution = ""
                developers {
                    developer {
                        id = "username"
                        name = "User Name"
                        url = ""
                scm {
                    url = ""
                    connection = "scm:git:git://"
                    developerConnection = "scm:git:ssh://"

            // Alternatively to the DSL based POM configuration above you can define them
            // in Gradle properties

The above also works to configure the POM of the regular plugin without properties. It's also possible to use it in a project where some modules use the regular and some use the base plugin.

In the individual projects you can then configure publishing like this:

import com.vanniktech.maven.publish.JavaLibrary
import com.vanniktech.maven.publish.JavadocJar

apply plugin: "com.vanniktech.maven.publish.base"

mavenPublishing {
    // available options:
    //   - JavaLibrary
    //   - GradlePlugin
    //   - AndroidLibrary
    //   - KotlinJvm
    //   - KotlinJs
    //   - KotlinMultiplatform
    // the first parameter configures the javadoc jar, available options:
    //   - None
    //   - Empty
    //   - Javadoc
    //   - Dokka("dokkaHtml") - the parameter is the name of the Dokka task
    // second one is for whether to publish sources, optional, defaults to true (not supported for KotlinMultiplatform(
    // AndroidLibrary has a third parameter for which variant to publish, defaults to "release"
    configure(new JavaLibrary(new JavadocJar.Javadoc(), true))


Copyright (C) 2018 Vanniktech - Niklas Baudy

Licensed under the Apache License, Version 2.0


Gradle plugin that configures an uploadArchives task to automatically upload all of your Java, Kotlin or Android libraries to any Maven instance.








No packages published