Publishing

In this tutorial, you'll configure a publishing backend so your signed installers and their auto-update metadata land in one place — GitHub Releases, an S3 bucket, or any HTTP host. You'll pick a release channel and type, control when publishing runs, and see what each desktop store expects for submission. The configuration lives in the same nucleus { } DSL as the rest of your build.

Before you start

• Working installers for your target platforms. See Configuration for the targetFormats(...) setup.
• Signed builds for the platforms you distribute. See code signing.
• A hosting target: a GitHub repository, an S3 bucket, or an HTTP server you control.

Configure a publishing backend

Add a publish { } block inside nativeDistributions { } and enable one backend. The block only generates configuration and the update YAML; the upload itself runs in CI.

nucleus {
    application {
        nativeDistributions {
            publish {
                github {
                    enabled = true
                    owner = "myorg"
                    repo = "myapp"
                    token = System.getenv("GITHUB_TOKEN")
                    channel = ReleaseChannel.Latest
                    releaseType = ReleaseType.Release
                }
            }
        }
    }
}

v1.0.0 (Release)
├── MyApp-1.0.0-macos-arm64.dmg
├── MyApp-1.0.0-macos-universal.dmg
├── MyApp-1.0.0-windows-amd64.exe
├── MyApp-1.0.0-windows.msixbundle
├── MyApp-1.0.0-linux-amd64.deb
├── MyApp-1.0.0-linux-amd64.AppImage
├── latest-mac.yml
├── latest.yml
└── latest-linux.yml

publish {
    s3 {
        enabled = true
        bucket = "my-updates-bucket"
        region = "us-east-1"
        path = "releases/myapp"
        acl = "public-read"
    }
}

publish {
    generic {
        enabled = true
        url = "https://updates.example.com/releases/"
        channel = ReleaseChannel.Latest
        useMultipleRangeRequest = true
    }
}

Choose a release channel and type

The channel selects which YAML file the auto-updater reads, and the tag pattern it maps to:

For GitHub Releases, the release type controls visibility:

Set the publish mode

publishMode decides when publishing runs. It defaults to PublishMode.Never:

publish {
    publishMode = PublishMode.Auto
    // github { ... }
}

• PublishMode.Never — do not publish. The latest-*.yml metadata is still generated locally for every updatable format.
• PublishMode.Auto — publish when the build runs from a git tag.
• PublishMode.Always — publish on every build, tag or not.

Submit to a desktop store

Store distribution goes through each vendor's portal rather than the publish { } block. Build the store format, then upload the artifact:

• Mac App Store — submit the PKG via Transporter or xcrun altool. Provisioning profiles (sandboxing) and the store category (appCategory) are set at build time. Apple reviews the build; App Store builds are not notarized.
• Microsoft Store — upload the .msixbundle to Partner Center. The identity must match the reservation (identityName, publisher = CN=<GUID>, publisherDisplayName). See Windows targets.
• Snapcraft — run snapcraft upload from CI. The Snap Store accepts strict and classic confinement; classic requires approval. Set the grade with linux.snap { grade = SnapGrade.Stable }.
• Flathub — submit a manifest pull request to the Flathub repo. Your flatpak block produces the bundle; Flathub builds from source via your manifest.
• GitHub Releases / direct download — the default path. Pair it with auto-update for self-distributed apps.

Reference

• publish { publishMode = … }
• publish.github { enabled, owner, repo, token, channel, releaseType }
• publish.s3 { enabled, bucket, region, path, acl }
• publish.generic { enabled, url, channel, useMultipleRangeRequest }
• enum class PublishMode { Never, Auto, Always }
• enum class ReleaseChannel { Latest, Beta, Alpha }
• enum class ReleaseType { Release, Draft, Prerelease }

See the Gradle DSL reference for the full surface.

What's next

• Auto-update — how the published YAML drives in-app updates.
• Release CI — the workflow that builds, signs, and uploads.
• Code signing — sign builds before you publish them.