Skip to main content
Asta uses GitHub Actions to automate building and releasing the desktop app for macOS and Windows. Releases are triggered by pushing version tags to the repository.

​
Release Workflow Overview

The release process is defined in .github/workflows/release.yml and follows this flow:
1

Push a Version Tag

Create and push a git tag following semantic versioning:
git tag v1.4.2
git push origin v1.4.2
This automatically triggers the release workflow.
2

Build Matrix Execution

GitHub Actions runs parallel builds for:
  • macOS Apple Silicon (aarch64-apple-darwin)
  • macOS Intel (x86_64-apple-darwin)
  • Windows (x86_64-pc-windows-msvc)
Each build:
  1. Checks out the repository
  2. Sets up Node.js 20
  3. Installs Rust toolchain with target architecture
  4. Caches Rust dependencies
  5. Installs npm dependencies
  6. Runs npm run tauri build
3

Create GitHub Release

The tauri-action automatically:
  • Creates a GitHub Release with the tag name
  • Uploads all platform binaries as release assets
  • Generates release notes
  • Publishes the release (not a draft)

​
Version Bumping

1

Update Version Numbers

Before creating a release tag, update the version in three files:package.json:
{
  "version": "1.5.0"
}
src-tauri/Cargo.toml:
[package]
version = "1.5.0"
src-tauri/tauri.conf.json:
{
  "version": "1.5.0"
}
All three version strings must match exactly.
2

Commit Version Changes

git add package.json src-tauri/Cargo.toml src-tauri/tauri.conf.json
git commit -m "Bump version to 1.5.0"
git push
3

Create and Push Tag

git tag v1.5.0
git push origin v1.5.0
The v prefix is required for the workflow to trigger.

​
GitHub Actions Configuration

The release workflow is defined in .github/workflows/release.yml: 
name: Release Desktop App

on:
  push:
    tags:
      - "v*"              # Trigger on any tag starting with 'v'
  workflow_dispatch:      # Allow manual trigger

permissions:
  contents: write         # Required to create releases

jobs:
  build-tauri:
    strategy:
      fail-fast: false
      matrix:
        include:
          - platform: macos-latest
            args: --target aarch64-apple-darwin
            rust_target: aarch64-apple-darwin
          - platform: macos-latest
            args: --target x86_64-apple-darwin
            rust_target: x86_64-apple-darwin
          - platform: windows-latest
            args: ""
            rust_target: ""

    runs-on: ${{ matrix.platform }}
    defaults:
      run:
        working-directory: MACWinApp/asta-app

​
Build Steps

For each platform in the matrix:
1

Checkout Repository

- uses: actions/checkout@v4
2

Setup Node.js

- name: Setup Node
  uses: actions/setup-node@v4
  with:
    node-version: 20
3

Install Rust

- name: Install Rust stable
  uses: dtolnay/rust-toolchain@stable
  with:
    targets: ${{ matrix.rust_target }}
4

Cache Rust Dependencies

- name: Rust cache
  uses: swatinem/rust-cache@v2
  with:
    workspaces: MACWinApp/asta-app/src-tauri
This dramatically speeds up builds by caching compiled dependencies.
5

Install npm Dependencies

- name: Install npm dependencies
  run: npm ci || npm install
6

Build and Release

- name: Build Tauri app
  uses: tauri-apps/tauri-action@v0
  env:
    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
  with:
    projectPath: MACWinApp/asta-app
    tagName: \$\{\{ github.ref_name \}\}
    releaseName: "Asta \$\{\{ github.ref_name \}\}"
    releaseBody: |
      ## Asta Desktop App
      
      **macOS:** Download the `.dmg` for your architecture:
      - `aarch64` = Apple Silicon (M1/M2/M3/M4)
      - `x86_64` = Intel
      
      **Windows:** Download the `.msi` installer.
      
      After installing the desktop app, start the backend separately:
      ./asta.sh start
      
      See CHANGELOG.md for what's new.
    releaseDraft: false
    prerelease: false
    args: \$\{\{ matrix.args \}\}

​
Manual Release Trigger

You can also trigger the release workflow manually from the GitHub Actions UI:
  1. Go to Actions tab in your repository
  2. Select Release Desktop App workflow
  3. Click Run workflow
  4. Choose the branch and click Run workflow
Manual triggers still require version tags to be present in the repository. They’re useful for re-running failed builds.

​
Release Assets

After a successful build, the following files are uploaded to the GitHub Release:

​
macOS

  • Asta_1.4.2_aarch64.dmg - Apple Silicon installer
  • Asta_1.4.2_x86_64.dmg - Intel installer
  • Asta_1.4.2_aarch64.dmg.tar.gz - Compressed Apple Silicon bundle
  • Asta_1.4.2_x86_64.dmg.tar.gz - Compressed Intel bundle

​
Windows

  • Asta_1.4.2_x64_en-US.msi - MSI installer
  • Asta_1.4.2_x64_en-US.msi.zip - Compressed MSI

​
Finding Releases

Releases are published on the GitHub Releases page: 
https://github.com/helloworldxdwastaken/asta/releases
The desktop app includes an auto-update checker that polls this URL to notify users of new versions: 
// src-tauri/src/lib.rs:178
#[tauri::command]
fn check_app_update(current_version: String) -> Result<serde_json::Value, String> {
    let url = "https://api.github.com/repos/helloworldxdwastaken/asta/releases/latest";
    // ... fetch and compare versions
}
When a new version is detected, the UpdateToast component displays a notification with a download link.

​
Versioning Strategy

Asta follows Semantic Versioning:
  • Major (2.0.0) - Breaking changes, incompatible API changes
  • Minor (1.5.0) - New features, backward-compatible
  • Patch (1.4.3) - Bug fixes, backward-compatible

​
Current Version

The current stable version is 1.4.2 (as of March 2026).

​
Code Signing

The automated builds are not code-signed. Users will see security warnings when installing.

​
macOS Code Signing

To sign macOS builds, add these secrets to your GitHub repository:
  • APPLE_CERTIFICATE - Base64-encoded .p12 certificate
  • APPLE_CERTIFICATE_PASSWORD - Certificate password
  • APPLE_ID - Apple ID email
  • APPLE_TEAM_ID - Developer Team ID
Then update the workflow: 
- name: Build Tauri app
  uses: tauri-apps/tauri-action@v0
  env:
    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
    APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
    APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
    APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
    APPLE_ID: ${{ secrets.APPLE_ID }}
    APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
    APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}

​
Windows Code Signing

For Windows, add:
  • WINDOWS_CERTIFICATE - Base64-encoded PFX certificate
  • WINDOWS_CERTIFICATE_PASSWORD - Certificate password

​
Troubleshooting

Ensure all three version files are in sync:
grep -h '"version"' package.json src-tauri/tauri.conf.json
grep 'version = ' src-tauri/Cargo.toml
All three should show the same version number.
Check that:
  1. The tag starts with v (e.g., v1.4.2, not 1.4.2)
  2. The workflow has contents: write permission
  3. GitHub Actions is enabled in repository settings
Common issues:
  • Xcode license not accepted - GitHub runners should have this pre-configured
  • Target not found - Ensure rust_target is correct in the matrix
  • Disk space - macOS runners have limited space; clean cache if needed
Common issues:
  • Missing WebView2 - Should be pre-installed on windows-latest runners
  • Path issues - Use MACWinApp/asta-app with forward slashes
  • Antivirus - Windows Defender may block some build steps

​
Release Checklist

Before creating a release:
  • Update version in package.json, Cargo.toml, and tauri.conf.json
  • Update CHANGELOG.md with release notes
  • Test build locally on target platforms
  • Commit version changes to main branch
  • Create and push git tag
  • Monitor GitHub Actions workflow
  • Verify release assets are uploaded
  • Test installers on clean systems
  • Update documentation if API changed

​
Next Steps

Desktop App Overview

Learn about the app’s architecture and features

Building from Source

Build the desktop app locally for development

Build docs developers (and LLMs) love

Get started for freeTalk to us