DEV Community: Sumanth Perambuduri

Multi-OS Electron Build & Release with GitHub Actions

Sumanth Perambuduri — Mon, 06 Oct 2025 08:20:49 +0000

Automating your Electron app’s build and release process can save a lot of time—and reduce human error. With GitHub Actions, we can create a workflow that not only builds and publishes Electron apps but also handles multiple operating systems and automatically generates changelogs for tagged releases.

Here’s how you can set it up.

Workflow Overview

This workflow triggers on every push to the main branch. It does the following:

Checks if the commit is a version tag (e.g., v1.2.3)
Builds the Electron app on both Ubuntu and Windows
Publishes releases only for tagged commits
Generates a changelog for tagged releases (check this)
Updates or creates a GitHub release

GitHub Actions Workflow File

name: Build/release

on: 
  push:
    branches:
      - 'main'

jobs:
  release:
    runs-on: ${{ matrix.os }}

    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]

    steps:
      # Step 1: Checkout the repository
      - name: Check out repository
        uses: actions/checkout@v5

      # Step 2: Detect if commit is a tag
      - uses: kaisugi/action-regex-match@v1.0.1
        id: regex-match
        with:
          text: ${{ github.event.head_commit.message }}
          regex: '^v[0-9]+\.[0-9]+\.[0-9]+$'

      # Step 3: Set up Node.js
      - name: Set up Node.js
        uses: actions/setup-node@v5
        with:
          node-version: 20
          cache: 'npm'

      # Step 4: Package Electron (non-tagged commits)
      - name: Package Electron
        if: ${{ steps.regex-match.outputs.match == '' }}
        env: 
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          npm i
          npx electron-builder --publish never

      # Step 5: Package and Publish Electron (tagged commits)
      - name: Package and Publish Electron
        if: ${{ steps.regex-match.outputs.match != '' }}
        env: 
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          npm i
          npx electron-builder --publish always

      # Step 6: Build Changelog
      - name: Build Changelog
        if: ${{ steps.regex-match.outputs.match != '' }}
        id: changelog
        uses: ardalanamini/auto-changelog@v4
        with:
          mention-authors: false
          mention-new-contributors: false
          include-compare-link: false
          semver: false

      # Step 7: Update GitHub Release
      - name: Update Release
        if: ${{ steps.regex-match.outputs.match != '' }}
        uses: ncipollo/release-action@v1.20.0
        with:
          body: ${{ steps.changelog.outputs.changelog }} 
          allowUpdates: true
          tag: ${{ github.event.head_commit.message }}
          name: Release ${{ github.event.head_commit.message }}
          token: ${{ secrets.GITHUB_TOKEN }}

How It Works

Multi-OS Builds

The workflow uses a matrix strategy to run the release job on both Ubuntu and Windows. This ensures your Electron app is packaged correctly for multiple platforms without needing separate workflows.

strategy:
  matrix:
    os: [ubuntu-latest, windows-latest]

Tag Detection

Instead of relying on bash scripts, this workflow uses action-regex-match to check if the commit message is a semantic version tag (vX.Y.Z).

- uses: kaisugi/action-regex-match@v1.0.1
  id: regex-match
  with:
    text: ${{ github.event.head_commit.message }}
    regex: '^v[0-9]+\.[0-9]+\.[0-9]+$'

This outputs a match variable we can use to determine whether to publish a release.

Conditional Steps

We use GitHub Actions’ if: statements to separate regular builds from release builds:
match == '' → normal packaging
match != '' → publish and release

Changelog & Release

For tagged releases, the workflow automatically generates a changelog with auto-changelog and updates the GitHub release with ncipollo/release-action.

Get Unlimited Google Photos Storage

Sumanth Perambuduri — Sat, 04 May 2024 11:20:35 +0000

Disclaimer: This method might not work in future and your account might get banned by Google. I am not responsible for any of the consequences. This post is for educational purpose only.

Download Nox Player

Install Nox Player

Change language

Create instance

Run instance

Setup Magisk

Setup LSposed

Setup Pixelify GPhotos

Setup Google Photos

Enable module

Configure Module

Setup shared folder

Removing uploaded photos

Update Your Android App When You Release an APK on GitHub (Using a Library)

Sumanth Perambuduri — Tue, 14 Dec 2021 08:40:29 +0000

supersu-man / apkupdater-library

Checks for the latest release in the GitHub repo and if latest apk release is found, it downloads the apk for you.

If you release APK files with every new GitHub release, APKUpdater-Library can make updating your app seamless.

Requirements

Version Consistency Your Gradle versionName and GitHub release tag version must match. Adding a v prefix in GitHub is optional.

Gradle:

versionName "X.Y"
or
versionName "X.Y.Z"

GitHub Release Tag:

vX.Y or X.Y
or
vX.Y.Z or X.Y.Z

Add JitPack repository In your top-level build.gradle:

allprojects {
    repositories {
        /// ....
        maven { url "https://jitpack.io" }
    }
}

Add the library dependency In your module-level build.gradle:

implementation 'com.github.supersu-man:apkupdater-library:v2.1.0'

Usage

Initialize the Updater

val url = "https://github.com/supersu-man/macronium-android/releases/latest"
val updater = ApkUpdater(this@MainActivity, url)

Check for update

updater.isNewUpdateAvailable {
    //Your code when new update is found in the repo
}

Example

thread {
    val url = "https://github.com/supersu-man/macronium-android/releases/latest"
    val updater = ApkUpdater(this@MainActivity, url)
    updater.threeNumbers = false //if versioning is X.Y
    updater.threeNumbers = true  //if versioning is X.Y.Z
    checkForUpdates(updater)
}

private fun checkForUpdates(updater: ApkUpdater) {
    if (updater.isNewUpdateAvailable() == true) {
        updater.requestDownload()
    }
}

Use GitHub Secrets in Your Android App

Sumanth Perambuduri — Sat, 11 Dec 2021 04:50:07 +0000

Handling Secrets Securely 🔐

If your Android app uses API keys or other sensitive data, you definitely don’t want to hardcode them in your source files or accidentally push them to GitHub.
Here’s how you can securely inject secrets into your Android app using GitHub Actions — so your keys stay safe and your builds stay automated.

Alright, Let’s Get Straight to the Point ⚡

Add the following paths to your .gitignore file:

app/src/main/res/values/secrets.xml

Create a new file named secrets.xml in the path: app/src/main/res/values/
Add the following code in 'secrets.xml' :

<resources>
    <string name="API_KEY">YOUR_KEY_HERE</string>
</resources>

Next, add the following code to your activity.kt file:

val secret = getString(R.string.API_KEY)

Then, add this code under steps in your workflow file — right before the build step:

- name: Access Api keys
  env:
    apiKey: ${{ secrets.API_KEY }}
    path: app/src/main/res/values/secrets.xml
  run: |
    touch $path
    echo \<resources\> >> $path
    echo \<string name=\"API_KEY\"\>$apiKey\</string\> >> $path
    echo \</resources\> >> $path

Finally, add a new secret to your GitHub repository with the key API_KEY.

That’s it — you’re good to go! 🚀

Here’s an example project implementing the entire process:
👉 Spotify Playlist Downloader

Recommended Read 📖
If you’d like to understand the complete process of building, signing, and releasing Android apps on GitHub using GitHub Actions, I highly recommend reading my earlier post first — it covers all the fundamentals before we dive into using secrets:
Building, Signing and Releasing Android Apps with GitHub Actions

Building, Signing and Releasing Android Apps with GitHub Actions

Sumanth Perambuduri — Sat, 11 Dec 2021 04:41:37 +0000

GitHub Actions is honestly amazing — you can automate your entire build process just by pushing code to GitHub! Recently, I’ve been experimenting with it and absolutely love how powerful and flexible it is. I’ve used GitHub Actions before to build Python packages and Electron apps, and then I thought — why not try it for Android too?

Before getting started
Make sure you’ve completed the following setup steps:

Encode your KeyStore file (.jks) to Base64:

openssl base64 -A -in keystore.jks -out base64.txt

Copy the contents of base64.txt and add it as a GitHub secret named SIGNINGKEYBASE64.
Add the following secrets as well:

ALIAS → your key alias
KEYSTOREPASSWORD → your keystore password
KEYPASSWORD → your key password

Setting Up the Workflow File
Now, in your project root, create the following folder structure:

.github/
└── workflows/
    └── build.yml

Inside the workflows folder, create a file named build.yml and add the following content to it:

You’re All Set! 🚀
That’s it — you’re now good to go!
Whenever you create a tag (for example, v1.2.3), make a commit with the same message (v1.2.3), and push it to GitHub — GitHub Actions will automatically:

Build the APK and AAB files
Sign them with your keystore credentials
Create a release using the tag
And upload the files as release assets

Version bumping, committing, tagging, and pushing can be done effortlessly using a handy tool called Bumper.

It automates version management, so you can focus on building instead of manually updating version numbers every time.

Example Project
If you’d like to see this entire build process in action, check out my example project:
👉 Spotify Playlist Downloader

Want to use GitHub secrets in your Android Apps? Check out this post.