Skip to content

Free, open-source 3D sculpting for Linux, macOS and Windows: dense meshes, remeshing, painting, built-in AI (image/text to 3D), Send to Unreal, game-ready LODs, Gaussian splats and OpenUSD.

Release pipeline: Packages workflow builds and tests the release packages on every push to main; a tag promotes those (or builds them), smoke-tests every package on fresh runners, then publishes (only publish can write); CI splits the slow test sets over free runners, skips website-only changes, keeps the required checks; SF_RUNNER_* variables pick runners

islandmedc8a5afa679b8
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index afe247dc..1256a435 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -18,23 +18,72 @@ concurrency:
# produce, and anything changed compiles fresh. Caches are saved only by push and workflow_dispatch runs (main, or a
# maintainer's own branch): pull_request runs, forks included, only restore them (actions/cache/restore), so nothing a
# pull request builds can end up in another run. GitHub scopes caches by branch as well: a branch reads its own and
-# main's, never another branch's. The release workflow uses no cache at all: release packages build from a clean tree.
-# Keys are ccache-<job>.<commit>: the dot keeps one job's prefix from matching another's (ubuntu-24.04 / ubuntu-24.04-arm).
+# main's, never another branch's. Release packages (packages.yml) restore main's caches and never save from a tag.
+# Keys are ccache-ci-<job>.<commit>: the dot keeps one job's prefix from matching another's (one key may start with another's).
# The suite runs as parallel ctest entries (sculptforge_tests is split into shards, CMakeLists.txt), every test as before.
-# The Flatpak bundle check is in flatpak.yml.
+# Free runners in parallel: the slowest test sets are split over several standard runners (matrix shard K of N runs
+# every N-th ctest entry, `ctest -I K,,N`; the shards together run every test once). The jobs branch protection
+# requires ("Linux x86_64", "Windows", ...) are the small result jobs at the end.
+# Runners: repository variables SF_RUNNER_LINUX, SF_RUNNER_LINUX_ARM, SF_RUNNER_MAC, SF_RUNNER_WIN name other runners
+# for the build and test jobs (unset: GitHub's standard ones); the jobs that read the repository's change list stay on
+# GitHub's runners. No job here gets a secret.
+# The release packages are built by packages.yml (on pushes to main), the Flatpak check for pull requests is flatpak.yml.
jobs:
+ # Pushes and pull requests that change only the website (not its phone page, website/link, which is built into the
+ # app) or release paperwork skip the build and test jobs; their required checks then pass as skipped.
+ changes:
+ name: Changes
+ runs-on: ubuntu-24.04
+ outputs:
+ code: ${{ steps.diff.outputs.code }}
+ steps:
+ - id: diff
+ env:
+ GH_TOKEN: ${{ github.token }}
+ REPO: ${{ github.repository }}
+ EVENT: ${{ github.event_name }}
+ BEFORE: ${{ github.event.before }}
+ BASE: ${{ github.event.pull_request.base.sha }}
+ HEAD: ${{ github.event.pull_request.head.sha || github.sha }}
+ run: |
+ base=$BASE
+ [ "$EVENT" = push ] && base=$BEFORE
+ code=true
+ if [ "$EVENT" != workflow_dispatch ] && [ -n "$base" ] && [ "$base" != 0000000000000000000000000000000000000000 ]; then
+ # (the compare API lists at most 300 files: more than that counts as a code change)
+ if files=$(gh api "repos/$REPO/compare/$base...$HEAD" --jq '.files | if length >= 300 then error("many") else .[].filename end'); then
+ code=false
+ while IFS= read -r f; do
+ case "$f" in
+ website/link/*) code=true ;;
+ website/*|.github/workflows/pages.yml|.github/workflows/download-stats.yml|packaging/arch/*|tools/publish/*|scripts/release.sh|docs/releasing.md) ;;
+ '') ;;
+ *) code=true ;;
+ esac
+ done <<< "$files"
+ fi
+ fi
+ echo "code=$code" | tee -a "$GITHUB_OUTPUT"
+
+
build:
- name: ${{ matrix.name }}
+ name: ${{ matrix.name }} (${{ matrix.shard }}/${{ matrix.shards }})
+ needs: changes
+ if: needs.changes.outputs.code == 'true'
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
include:
- - { name: Linux x86_64, os: ubuntu-24.04 }
- - { name: Linux ARM64, os: ubuntu-24.04-arm }
- - { name: macOS, os: macos-15 }
- - { name: Windows, os: windows-2022 }
+ - { name: Linux x86_64, key: linux-x86_64, shard: 1, shards: 2, os: "${{ vars.SF_RUNNER_LINUX || 'ubuntu-24.04' }}" }
+ - { name: Linux x86_64, key: linux-x86_64, shard: 2, shards: 2, os: "${{ vars.SF_RUNNER_LINUX || 'ubuntu-24.04' }}" }
+ - { name: Linux ARM64, key: linux-arm64, shard: 1, shards: 2, os: "${{ vars.SF_RUNNER_LINUX_ARM || 'ubuntu-24.04-arm' }}" }
+ - { name: Linux ARM64, key: linux-arm64, shard: 2, shards: 2, os: "${{ vars.SF_RUNNER_LINUX_ARM || 'ubuntu-24.04-arm' }}" }
+ - { name: macOS, key: macos, shard: 1, shards: 1, os: "${{ vars.SF_RUNNER_MAC || 'macos-15' }}" }
+ - { name: Windows, key: windows, shard: 1, shards: 3, os: "${{ vars.SF_RUNNER_WIN || 'windows-2022' }}" }
+ - { name: Windows, key: windows, shard: 2, shards: 3, os: "${{ vars.SF_RUNNER_WIN || 'windows-2022' }}" }
+ - { name: Windows, key: windows, shard: 3, shards: 3, os: "${{ vars.SF_RUNNER_WIN || 'windows-2022' }}" }
env:
CCACHE_DIR: ${{ github.workspace }}/.ccache
CCACHE_BASEDIR: ${{ github.workspace }}
@@ -79,8 +128,8 @@ jobs:
uses: actions/cache/restore@v5
with:
path: .ccache
- key: ccache-${{ matrix.os }}.${{ github.sha }}
- restore-keys: ccache-${{ matrix.os }}.
+ key: ccache-ci-${{ matrix.key }}.${{ github.sha }}
+ restore-keys: ccache-ci-${{ matrix.key }}.
- name: NumPy for the Python API test
run: python -m pip install numpy
- name: Configure
@@ -100,22 +149,22 @@ jobs:
ccache -z
cmake --build build --config Release --parallel 4
ccache -s -v
- - name: Compiler cache (save; not from pull requests)
- if: github.event_name != 'pull_request'
+ - name: Compiler cache (save; not from pull requests; one shard saves)
+ if: github.event_name != 'pull_request' && matrix.shard == 1
uses: actions/cache/save@v5
with:
path: .ccache
- key: ccache-${{ matrix.os }}.${{ github.sha }}
+ key: ccache-ci-${{ matrix.key }}.${{ github.sha }}
# Every test in one parallel ctest run (UI tests too, where there is a display), so no core idles while the
# last tests of one group finish.
- name: Test (C++, Python API, UI tests with Xvfb + Mesa)
if: runner.os == 'Linux'
run: |
xvfb-run -a -s "-screen 0 1920x1080x24" env LIBGL_ALWAYS_SOFTWARE=1 \
- ctest --test-dir build -C Release --output-on-failure -j 4
+ ctest --test-dir build -C Release --output-on-failure -j 4 -I ${{ matrix.shard }},,${{ matrix.shards }}
- name: Test (C++ and Python API; UI tests need a display)
if: runner.os == 'macOS'
- run: ctest --test-dir build -C Release --output-on-failure -LE ui -j 4
+ run: ctest --test-dir build -C Release --output-on-failure -LE ui -j 4 -I ${{ matrix.shard }},,${{ matrix.shards }}
- name: Test (C++, Python API, UI tests with Mesa llvmpipe)
if: runner.os == 'Windows'
shell: pwsh
@@ -128,13 +177,13 @@ jobs:
}
7z e mesa.7z x64/opengl32.dll x64/libgallium_wgl.dll -obuild/Release -y | Out-Null
$env:GALLIUM_DRIVER = 'llvmpipe'
- ctest --test-dir build -C Release --output-on-failure -j 4
+ ctest --test-dir build -C Release --output-on-failure -j 4 -I ${{ matrix.shard }},,${{ matrix.shards }}
if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
- name: UI test screenshots
if: always() && runner.os != 'macOS'
uses: actions/upload-artifact@v7
with:
- name: ui-shots-${{ matrix.os }}
+ name: ui-shots-${{ matrix.key }}-${{ matrix.shard }}
path: build/ui-shots
if-no-files-found: ignore
@@ -142,7 +191,9 @@ jobs:
# sculptforge-cli: the oldest supported Blender (4.2 LTS, Python 3.11) and the newest.
blender-addon:
name: Blender add-on (bpy ${{ matrix.bpy }})
- runs-on: ubuntu-24.04
+ needs: changes
+ if: needs.changes.outputs.code == 'true'
+ runs-on: ${{ vars.SF_RUNNER_LINUX || 'ubuntu-24.04' }}
strategy:
fail-fast: false
matrix:
@@ -166,8 +217,8 @@ jobs:
uses: actions/cache/restore@v5
with:
path: .ccache
- key: ccache-blender-cli-${{ matrix.bpy }}.${{ github.sha }}
- restore-keys: ccache-blender-cli-${{ matrix.bpy }}.
+ key: ccache-ci-blender-${{ matrix.bpy }}.${{ github.sha }}
+ restore-keys: ccache-ci-blender-${{ matrix.bpy }}.
- name: bpy and numpy
run: python -m pip install "bpy==${{ matrix.bpy }}" numpy
- name: Build sculptforge-cli
@@ -181,7 +232,7 @@ jobs:
uses: actions/cache/save@v5
with:
path: .ccache
- key: ccache-blender-cli-${{ matrix.bpy }}.${{ github.sha }}
+ key: ccache-ci-blender-${{ matrix.bpy }}.${{ github.sha }}
- name: Add-on round trip in Blender
run: python tests/blender/test_in_blender.py -- --cli build/sculptforge-cli
- name: Add-on exchange code and package
@@ -192,8 +243,10 @@ jobs:
# VFX Reference Platform (vfxplatform.com): GCC 14.2 with glibc 2.28 (CY2026, EL8)
# or glibc 2.34 (CY2027, EL9), C++20, Python 3.13.
vfx-platform:
- name: VFX Reference Platform ${{ matrix.cy }} (${{ matrix.image }})
- runs-on: ubuntu-24.04
+ name: VFX Reference Platform ${{ matrix.cy }} build (${{ matrix.image }})
+ needs: changes
+ if: needs.changes.outputs.code == 'true'
+ runs-on: ${{ vars.SF_RUNNER_LINUX || 'ubuntu-24.04' }}
container: ${{ matrix.image }}
strategy:
fail-fast: false
@@ -220,8 +273,8 @@ jobs:
uses: actions/cache/restore@v5
with:
path: .ccache
- key: ccache-${{ matrix.cy }}.${{ github.sha }}
- restore-keys: ccache-${{ matrix.cy }}.
+ key: ccache-ci-${{ matrix.cy }}.${{ github.sha }}
+ restore-keys: ccache-ci-${{ matrix.cy }}.
- name: Python 3.13 (python-build-standalone via uv)
run: |
curl -LsSf https://astral.sh/uv/0.9.5/install.sh | sh
@@ -243,7 +296,7 @@ jobs:
uses: actions/cache/save@v5
with:
path: .ccache
- key: ccache-${{ matrix.cy }}.${{ github.sha }}
+ key: ccache-ci-${{ matrix.cy }}.${{ github.sha }}
- name: Test
run: ctest --test-dir build --output-on-failure -LE ui -j 4
- name: Check binary compatibility (glibc <= ${{ matrix.glibc }})
@@ -253,3 +306,26 @@ jobs:
echo "$f needs $max"
[ "$(printf '%s\n' "GLIBC_${{ matrix.glibc }}" "$max" | sort -V | tail -1)" = "GLIBC_${{ matrix.glibc }}" ]
done
+
+ # The checks branch protection requires, by name. Each passes when the build and test jobs passed or were skipped
+ # (a website-only change); a failure anywhere fails them all, and the run shows which job failed.
+ result:
+ name: ${{ matrix.check }}
+ needs: [changes, build, blender-addon, vfx-platform]
+ if: always()
+ runs-on: ubuntu-24.04
+ strategy:
+ matrix:
+ check:
+ - Linux x86_64
+ - Linux ARM64
+ - macOS
+ - Windows
+ - VFX Reference Platform CY2026 (rockylinux:8)
+ - VFX Reference Platform CY2027 (rockylinux:9)
+ steps:
+ - env:
+ RESULTS: ${{ needs.changes.result }} ${{ needs.build.result }} ${{ needs.blender-addon.result }} ${{ needs.vfx-platform.result }}
+ run: |
+ echo "changes, build, blender-addon, vfx-platform: $RESULTS"
+ for r in $RESULTS; do case $r in success|skipped) ;; *) exit 1 ;; esac; done
diff --git a/.github/workflows/flatpak.yml b/.github/workflows/flatpak.yml
index c2152e1b..50af6e03 100644
--- a/.github/workflows/flatpak.yml
+++ b/.github/workflows/flatpak.yml
@@ -11,29 +11,12 @@ name: Flatpak
# src/io/BlenderBridge.*, src/app/PanelBlender.cpp; settings isolation for UI tests: src/app/main.cpp) and the
# SpaceMouse reading /dev/input (src/app/SpaceMouse.cpp), with the three UI tests run in the sandbox;
# - this workflow.
-# Every night it also runs on main whatever changed (a newer freedesktop runtime, or a code change the list above
-# misses, shows up within a day), it can be run by hand (workflow_dispatch), and the release workflow builds and
-# tests the Flatpak on x86_64 and aarch64 for every tag before anything is published.
+# On main, the Packages workflow (packages.yml) builds and tests both Flatpaks on every push that changes the app,
+# and the release promotes those; this workflow is the check for pull requests, and can be run by hand.
on:
- push:
- branches: [main]
- paths:
- - packaging/flatpak/**
- - packaging/linux/**
- - CMakeLists.txt
- - cmake/**
- - third_party/**
- - src/io/BlenderBridge.*
- - src/app/PanelBlender.cpp
- - src/app/main.cpp
- - src/app/SpaceMouse.cpp
- - tests/ui/sculpt_basics.sfui
- - tests/ui/blender_bridge.sfui
- - tests/ui/spacemouse.sfui
- - .github/workflows/flatpak.yml
pull_request:
- paths: # the same list as above
+ paths: # the list above
- packaging/flatpak/**
- packaging/linux/**
- CMakeLists.txt
@@ -47,8 +30,6 @@ on:
- tests/ui/blender_bridge.sfui
- tests/ui/spacemouse.sfui
- .github/workflows/flatpak.yml
- schedule:
- - cron: '17 4 * * *'
workflow_dispatch:
permissions:
@@ -61,7 +42,7 @@ concurrency:
jobs:
flatpak:
name: Flatpak x86_64
- runs-on: ubuntu-24.04
+ runs-on: ${{ vars.SF_RUNNER_LINUX || 'ubuntu-24.04' }}
steps:
- uses: actions/checkout@v7
- run: sudo apt-get update && sudo apt-get install -y flatpak flatpak-builder xvfb
diff --git a/.github/workflows/packages.yml b/.github/workflows/packages.yml
new file mode 100644
index 00000000..66d33595
--- /dev/null
+++ b/.github/workflows/packages.yml
@@ -0,0 +1,310 @@
+name: Packages
+
+# The release packages (.deb, AppImage, .tar.gz, Flatpak, .rpm and VFX Reference Platform tarballs, .dmg, Windows
+# installer and .zip), each built and tested exactly as a release ships them. It runs on every push to main that
+# changes the app, so a tagged release can promote the packages of the commit it tags instead of building them again
+# (.github/workflows/release.yml); the release workflow also calls it to build from scratch when there are none.
+#
+# Integrity: the release promotes only artifacts of a successful run of THIS workflow on a push to main for exactly
+# the tagged commit (checked in release.yml). Compiler caches are restored here but saved only by branch runs (pushes
+# to main, maintainers' own dispatches): never from a tag (a release that calls this builds from main's cache and
+# writes nothing) and never from a pull request (this workflow doesn't run on pull requests). See ci.yml for ccache.
+# Runners: repository variables SF_RUNNER_* (Settings > Secrets and variables > Actions > Variables) name other
+# runners for these build-and-test jobs; unset, they are GitHub's standard ones. No job here gets a secret.
+
+on:
+ push:
+ branches: [main]
+ paths: # everything but the website (its phone page, website/link, is built into the app) and release paperwork
+ - '**'
+ - '!website/**'
+ - website/link/**
+ - '!.github/workflows/pages.yml'
+ - '!.github/workflows/download-stats.yml'
+ - '!packaging/arch/**'
+ - '!tools/publish/**'
+ - '!scripts/release.sh'
+ - '!docs/releasing.md'
+ workflow_dispatch:
+ workflow_call:
+ inputs:
+ ref:
+ description: Commit or tag to build
+ type: string
+ required: true
+ tag:
+ description: Release tag, e.g. v1.2.3 (names the AppImage and the VFX tarballs)
+ type: string
+ required: true
+
+permissions:
+ contents: read
+
+concurrency:
+ group: packages-${{ inputs.ref || github.ref }}
+ cancel-in-progress: true # a newer push to main supersedes; a tag of the older commit then builds its own
+
+env:
+ REF: ${{ inputs.ref || github.sha }}
+ CCACHE_MAXSIZE: 500M
+ CCACHE_DEPEND: 'true'
+ # Saved by branch runs only: never a tag, never a pull request.
+ SAVE_CACHE: ${{ !startsWith(github.ref, 'refs/tags/') && github.event_name != 'pull_request' }}
+
+jobs:
+ linux:
+ name: Linux ${{ matrix.arch }} (.deb, AppImage, .tar.gz)
+ runs-on: ${{ matrix.os }}
+ strategy:
+ fail-fast: false
+ matrix:
+ include:
+ - { arch: x86_64, os: "${{ vars.SF_RUNNER_LINUX_OLD || 'ubuntu-22.04' }}", ld: x86_64 }
+ - { arch: arm64, os: "${{ vars.SF_RUNNER_LINUX_OLD_ARM || 'ubuntu-22.04-arm' }}", ld: aarch64 }
+ steps:
+ - uses: actions/checkout@v7
+ with: { ref: '${{ env.REF }}' }
+ - name: Tag (the release's, or v<project version>)
+ run: echo "TAG=${{ inputs.tag }}" | sed "s/^TAG=$/TAG=v$(sed -n 's/^project(SculptForge VERSION \([0-9.]*\).*/\1/p' CMakeLists.txt)/" >> "$GITHUB_ENV"
+ - run: |
+ sudo ./packaging/linux/install-build-deps.sh
+ sudo apt-get install -y --no-install-recommends ccache xvfb libgl1-mesa-dri
+ echo "CCACHE_DIR=$GITHUB_WORKSPACE/.ccache" >> "$GITHUB_ENV"
+ echo "CCACHE_BASEDIR=$GITHUB_WORKSPACE" >> "$GITHUB_ENV"
+ - uses: actions/cache/restore@v5
+ with:
+ path: .ccache
+ key: ccache-pkg-linux-${{ matrix.arch }}.${{ github.sha }}
+ restore-keys: ccache-pkg-linux-${{ matrix.arch }}.
+ - name: Build
+ run: |
+ cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr -DSCULPTFORGE_USE_SYSTEM_SDL=OFF \
+ -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+ cmake --build build --parallel 4
+ ccache -s
+ - if: env.SAVE_CACHE == 'true'
+ uses: actions/cache/save@v5
+ with:
+ path: .ccache
+ key: ccache-pkg-linux-${{ matrix.arch }}.${{ github.sha }}
+ - name: Test (every test, UI tests under Xvfb + Mesa)
+ run: |
+ xvfb-run -a -s "-screen 0 1920x1080x24" env LIBGL_ALWAYS_SOFTWARE=1 \
+ ctest --test-dir build --output-on-failure -j 4
+ - name: .deb and .tar.gz
+ run: cd build && cpack -G "DEB;TGZ"
+ - name: AppImage
+ run: |
+ DESTDIR=$PWD/AppDir cmake --install build
+ # Named the AppImage way (SculptForge-1.2.3-x86_64.AppImage, no "linux"), with update information so
+ # AppImageUpdate and similar tools can update it from the newest GitHub release (the .zsync file). The
+ # AppDir's root gets PNG icons (AppImage managers cannot use the SVG), and appimagetool checks it (#17).
+ packaging/linux/build-appimage.sh AppDir "${TAG#v}" ${{ matrix.ld }} build
+ - uses: actions/upload-artifact@v7
+ with:
+ name: linux-${{ matrix.arch }}
+ path: |
+ build/*.deb
+ build/*.tar.gz
+ build/*.AppImage
+ build/*.AppImage.zsync
+
+ # Built in the freedesktop SDK (packaging/flatpak/build.sh), installed, and UI tests run inside the sandbox.
+ flatpak:
+ name: Flatpak ${{ matrix.arch }}
+ runs-on: ${{ matrix.os }}
+ strategy:
+ fail-fast: false
+ matrix:
+ include:
+ - { arch: x86_64, os: "${{ vars.SF_RUNNER_LINUX || 'ubuntu-24.04' }}" }
+ - { arch: aarch64, os: "${{ vars.SF_RUNNER_LINUX_ARM || 'ubuntu-24.04-arm' }}" }
+ steps:
+ - uses: actions/checkout@v7
+ with: { ref: '${{ env.REF }}' }
+ - name: flatpak and flatpak-builder
+ run: sudo apt-get update && sudo apt-get install -y flatpak flatpak-builder xvfb
+ - name: Build the bundle (packaging/flatpak/org.sculptforge.SculptForge.yml)
+ run: packaging/flatpak/build.sh dist
+ - name: Install it and run UI tests inside the sandbox (Xvfb, Mesa from the runtime)
+ run: |
+ flatpak install --user -y --noninteractive dist/*.flatpak
+ for t in sculpt_basics blender_bridge spacemouse release_smoke; do
+ [ -f "tests/ui/$t.sfui" ] || continue # (release_smoke: newer than some tags a release may rebuild)
+ xvfb-run -a -s "-screen 0 1920x1080x24" \
+ flatpak run --env=LIBGL_ALWAYS_SOFTWARE=1 org.sculptforge.SculptForge \
+ --ui-test "$PWD/tests/ui/$t.sfui" --ui-out "$PWD/flatpak-ui/$t"
+ done
+ - uses: actions/upload-artifact@v7
+ with:
+ name: flatpak-${{ matrix.arch }}
+ path: dist/*.flatpak
+
+ vfx:
+ name: ${{ matrix.label }} ${{ matrix.arch }}
+ runs-on: ${{ matrix.os }}
+ container: ${{ matrix.image }}
+ strategy:
+ fail-fast: false
+ matrix:
+ include:
+ # CY2026: EL8 / glibc 2.28 also gives the .rpm for RHEL 8, 9, 10 and Fedora.
+ - { label: 'RPM + VFX CY2026', suffix: vfx2026, cy: CY2026, generators: 'RPM;TGZ', image: 'rockylinux:8', arch: x86_64, ccarch: x86_64, os: "${{ vars.SF_RUNNER_LINUX || 'ubuntu-24.04' }}" }
+ - { label: 'RPM + VFX CY2026', suffix: vfx2026, cy: CY2026, generators: 'RPM;TGZ', image: 'rockylinux:8', arch: arm64, ccarch: aarch64, os: "${{ vars.SF_RUNNER_LINUX_ARM || 'ubuntu-24.04-arm' }}" }
+ - { label: 'VFX CY2027', suffix: vfx2027, cy: CY2027, generators: 'TGZ', image: 'rockylinux:9', arch: x86_64, ccarch: x86_64, os: "${{ vars.SF_RUNNER_LINUX || 'ubuntu-24.04' }}" }
+ - { label: 'VFX CY2027', suffix: vfx2027, cy: CY2027, generators: 'TGZ', image: 'rockylinux:9', arch: arm64, ccarch: aarch64, os: "${{ vars.SF_RUNNER_LINUX_ARM || 'ubuntu-24.04-arm' }}" }
+ steps:
+ - run: dnf -y install git tar gzip zstd
+ - uses: actions/checkout@v7
+ with: { ref: '${{ env.REF }}' }
+ - name: Tag (the release's, or v<project version>)
+ run: echo "TAG=${{ inputs.tag }}" | sed "s/^TAG=$/TAG=v$(sed -n 's/^project(SculptForge VERSION \([0-9.]*\).*/\1/p' CMakeLists.txt)/" >> "$GITHUB_ENV"
+ - run: ./packaging/linux/install-build-deps.sh
+ - name: ccache (the static release binary, pinned by hash)
+ run: |
+ f=ccache-4.14.2-linux-${{ matrix.ccarch }}-musl-static.tar.gz
+ curl -fsSLO "https://github.com/ccache/ccache/releases/download/v4.14.2/$f"
+ case ${{ matrix.ccarch }} in
+ x86_64) sum=d540ba01f160addbd3dd5e18eda9bd34005591b095c09ac8ae9d0a1b655e7ef5 ;;
+ aarch64) sum=2be524bbccfc7e9ff0085d110da7dc9964de983bd92d29acf3b872e557194945 ;;
+ esac
+ echo "$sum $f" | sha256sum -c
+ tar xzf "$f" -C /opt
+ echo "/opt/${f%.tar.gz}" >> "$GITHUB_PATH"
+ echo "CCACHE_DIR=$GITHUB_WORKSPACE/.ccache" >> "$GITHUB_ENV"
+ echo "CCACHE_BASEDIR=$GITHUB_WORKSPACE" >> "$GITHUB_ENV"
+ - uses: actions/cache/restore@v5
+ with:
+ path: .ccache
+ key: ccache-pkg-${{ matrix.suffix }}-${{ matrix.arch }}.${{ github.sha }}
+ # CI's job for the same image and compiler (x86_64) shares most object files.
+ restore-keys: |
+ ccache-pkg-${{ matrix.suffix }}-${{ matrix.arch }}.
+ ccache-ci-${{ matrix.cy }}.
+ - name: Python 3.13
+ run: |
+ curl -LsSf https://astral.sh/uv/0.9.5/install.sh | sh
+ ~/.local/bin/uv venv --python 3.13 /opt/py313
+ ~/.local/bin/uv pip install --python /opt/py313/bin/python numpy
+ echo "PYTHON313=/opt/py313/bin/python" >> "$GITHUB_ENV"
+ - name: Build with GCC 14
+ run: |
+ source /opt/rh/gcc-toolset-14/enable
+ cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr -DSCULPTFORGE_USE_SYSTEM_SDL=OFF \
+ -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+ -DSCULPTFORGE_BUILD_PYTHON=ON -DPython_EXECUTABLE="$PYTHON313" -DSCULPTFORGE_PYTHON_INSTALL_DIR=lib/sculptforge/python
+ cmake --build build --parallel 4
+ ccache -s
+ - if: env.SAVE_CACHE == 'true'
+ uses: actions/cache/save@v5
+ with:
+ path: .ccache
+ key: ccache-pkg-${{ matrix.suffix }}-${{ matrix.arch }}.${{ github.sha }}
+ - name: Test and package
+ run: |
+ # UI tests need a display; they run under Xvfb in the Linux jobs above and in CI.
+ ctest --test-dir build --output-on-failure -LE ui -j 4
+ cd build
+ cpack -G TGZ -D CPACK_PACKAGE_FILE_NAME=SculptForge-${TAG#v}-linux-${{ matrix.arch }}-${{ matrix.suffix }}
+ if [ "${{ matrix.generators }}" = "RPM;TGZ" ]; then cpack -G RPM; fi
+ - uses: actions/upload-artifact@v7
+ with:
+ name: vfx-${{ matrix.suffix }}-${{ matrix.arch }}
+ path: |
+ build/*.rpm
+ build/*.tar.gz
+
+ macos:
+ name: macOS (universal .dmg)
+ runs-on: ${{ vars.SF_RUNNER_MAC || 'macos-15' }}
+ steps:
+ - uses: actions/checkout@v7
+ with: { ref: '${{ env.REF }}' }
+ - name: ccache (the release binary, pinned by hash)
+ run: |
+ curl -fsSLO https://github.com/ccache/ccache/releases/download/v4.14.2/ccache-4.14.2-darwin.tar.gz
+ echo "cf240009630b605b775c7c5c7b7105a3b196c79f31af322c1557969aa28003fc ccache-4.14.2-darwin.tar.gz" | shasum -a 256 -c
+ tar xzf ccache-4.14.2-darwin.tar.gz -C "$RUNNER_TEMP"
+ echo "$RUNNER_TEMP/ccache-4.14.2-darwin" >> "$GITHUB_PATH"
+ echo "CCACHE_DIR=$GITHUB_WORKSPACE/.ccache" >> "$GITHUB_ENV"
+ echo "CCACHE_BASEDIR=$GITHUB_WORKSPACE" >> "$GITHUB_ENV"
+ - uses: actions/cache/restore@v5
+ with:
+ path: .ccache
+ key: ccache-pkg-macos.${{ github.sha }}
+ restore-keys: ccache-pkg-macos.
+ - name: Build
+ run: |
+ cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DSCULPTFORGE_USE_SYSTEM_SDL=OFF \
+ -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64" -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 \
+ -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+ cmake --build build --parallel 4
+ ccache -s
+ - if: env.SAVE_CACHE == 'true'
+ uses: actions/cache/save@v5
+ with:
+ path: .ccache
+ key: ccache-pkg-macos.${{ github.sha }}
+ - name: Test
+ # UI tests need a display; they run under Xvfb in the Linux jobs above and in CI.
+ run: ctest --test-dir build --output-on-failure -LE ui -j 4
+ - name: Package (signed ad-hoc inside CPack, see cmake/MacSign.cmake)
+ run: cd build && cpack -G DragNDrop
+ - uses: actions/upload-artifact@v7
+ with:
+ name: macos
+ path: build/*.dmg
+
+ windows:
+ name: Windows x64 (installer, .zip)
+ runs-on: ${{ vars.SF_RUNNER_WIN || 'windows-2022' }}
+ steps:
+ - uses: actions/checkout@v7
+ with: { ref: '${{ env.REF }}' }
+ - name: ccache (the release binary, pinned by hash, standing in for cl.exe)
+ shell: pwsh
+ run: |
+ $zip = 'ccache-4.14.2-windows-x86_64.zip'
+ Invoke-WebRequest "https://github.com/ccache/ccache/releases/download/v4.14.2/$zip" -OutFile $zip
+ if ((Get-FileHash $zip -Algorithm SHA256).Hash -ne '6993CE645E53192CEC592EE23186200B574AC4C59097ECDE8D9CFD681B47AE84') {
+ throw 'ccache archive hash mismatch'
+ }
+ Expand-Archive $zip -DestinationPath $env:RUNNER_TEMP
+ $dir = "$env:RUNNER_TEMP\ccache-4.14.2-windows-x86_64"
+ "$dir" >> $env:GITHUB_PATH
+ $cl = "$env:RUNNER_TEMP\ccache-as-cl"
+ New-Item -ItemType Directory $cl | Out-Null
+ Copy-Item "$dir\ccache.exe" "$cl\cl.exe"
+ "SF_CCACHE_CL=$($cl -replace '\\', '/')" >> $env:GITHUB_ENV
+ "CCACHE_DIR=$env:GITHUB_WORKSPACE\.ccache" >> $env:GITHUB_ENV
+ "CCACHE_BASEDIR=$env:GITHUB_WORKSPACE" >> $env:GITHUB_ENV
+ - uses: actions/cache/restore@v5
+ with:
+ path: .ccache
+ key: ccache-pkg-windows.${{ github.sha }}
+ # CI's Windows job (same compiler; it adds the Python module) shares most object files.
+ restore-keys: |
+ ccache-pkg-windows.
+ ccache-ci-windows.
+ - name: Build (Visual Studio generator; ccache as cl.exe, one compiler per file)
+ run: |
+ cmake -S . -B build -DSCULPTFORGE_USE_SYSTEM_SDL=OFF `
+ -DCMAKE_VS_GLOBALS="CLToolExe=cl.exe;CLToolPath=${{ env.SF_CCACHE_CL }};TrackFileAccess=false;UseMultiToolTask=true;EnforceProcessCountAcrossBuilds=true"
+ cmake --build build --config Release --parallel 4
+ ccache -s
+ - if: env.SAVE_CACHE == 'true'
+ uses: actions/cache/save@v5
+ with:
+ path: .ccache
+ key: ccache-pkg-windows.${{ github.sha }}
+ - name: Test
+ # UI tests need a display; they run in CI with Mesa's software OpenGL.
+ run: ctest --test-dir build -C Release --output-on-failure -LE ui -j 4
+ - name: Package
+ run: cd build && cpack -C Release -G "NSIS;ZIP"
+ - uses: actions/upload-artifact@v7
+ with:
+ name: windows
+ path: |
+ build/*.exe
+ build/*.zip
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 32e7e961..c613ec50 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,5 +1,21 @@
name: Release
+# A v* tag publishes a GitHub release (docs/releasing.md has the whole process; scripts/release.sh drives it).
+#
+# locate the tagged commit must carry the version the tag names (CMakeLists.txt). If CI and the Packages
+# workflow (packages.yml) both succeeded on a push to main for exactly this commit, the release uses those
+# packages: built and tested once, promoted unchanged. Otherwise:
+# build the Packages workflow runs here, from the tag (compiler cache restored from main, never saved).
+# smoke every package installed or unpacked on a fresh runner: the app opens a model and sculpts
+# (tests/ui/release_smoke.sfui), sculptforge-cli opens, sculpts, saves and reopens (tests/release_smoke.py).
+# publish only after every smoke test passed: checksums, notes from CHANGELOG.md, the GitHub release.
+#
+# Only publish holds a token that can write (contents: write); every other job reads. Build and smoke jobs take their
+# runner from the SF_RUNNER_* repository variables (standard GitHub runners when unset); locate and publish always run
+# on GitHub's own runners.
+# workflow_dispatch rebuilds and republishes an existing tag; dry_run does everything but publish, and promote_run
+# (dry runs only) smoke-tests the packages of any Packages run, so the pipeline can be tried from a branch.
+
on:
push:
tags: ['v*']
@@ -8,174 +24,197 @@ on:
tag:
description: Existing tag to (re)build, e.g. v0.1.0
required: true
+ dry_run:
+ description: Everything but publishing
+ type: boolean
+ default: false
+ promote_run:
+ description: (dry runs only) smoke-test the packages of this Packages run id
+ required: false
permissions:
- contents: write
+ contents: read
env:
TAG: ${{ github.event.inputs.tag || github.ref_name }}
jobs:
- linux:
- name: Linux ${{ matrix.arch }} (.deb, AppImage, .tar.gz)
- runs-on: ${{ matrix.os }}
- strategy:
- fail-fast: false
- matrix:
- include:
- - { arch: x86_64, os: ubuntu-22.04, ld: x86_64 }
- - { arch: arm64, os: ubuntu-22.04-arm, ld: aarch64 }
+ locate:
+ name: Locate tested packages
+ runs-on: ubuntu-24.04
+ permissions:
+ contents: read
+ actions: read
+ outputs:
+ run-id: ${{ steps.find.outputs.run-id }}
+ sha: ${{ steps.find.outputs.sha }}
steps:
- uses: actions/checkout@v7
with: { ref: '${{ env.TAG }}' }
- - run: sudo ./packaging/linux/install-build-deps.sh
- - name: Build and test
- run: |
- cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr -DSCULPTFORGE_USE_SYSTEM_SDL=OFF
- cmake --build build --parallel 4
- ctest --test-dir build --output-on-failure -LE ui -j 4
- - name: UI tests (real app, Xvfb + Mesa)
- run: |
- sudo apt-get install -y xvfb libgl1-mesa-dri
- xvfb-run -a -s "-screen 0 1920x1080x24" env LIBGL_ALWAYS_SOFTWARE=1 \
- ctest --test-dir build --output-on-failure -L ui -j 4
- - name: .deb and .tar.gz
- run: cd build && cpack -G "DEB;TGZ"
- - name: AppImage
+ - id: find
+ env:
+ GH_TOKEN: ${{ github.token }}
+ REPO: ${{ github.repository }}
+ DRY_RUN: ${{ inputs.dry_run }}
+ PROMOTE_RUN: ${{ inputs.promote_run }}
run: |
- DESTDIR=$PWD/AppDir cmake --install build
- # Named the AppImage way (SculptForge-1.2.3-x86_64.AppImage, no "linux"), with update information so
- # AppImageUpdate and similar tools can update it from the newest GitHub release (the .zsync file). The
- # AppDir's root gets PNG icons (AppImage managers cannot use the SVG), and appimagetool checks it (#17).
- packaging/linux/build-appimage.sh AppDir "${TAG#v}" ${{ matrix.ld }} build
- - uses: actions/upload-artifact@v7
- with:
- name: linux-${{ matrix.arch }}
- path: |
- build/*.deb
- build/*.tar.gz
- build/*.AppImage
- build/*.AppImage.zsync
+ sha=$(git rev-parse HEAD)
+ echo "sha=$sha" >> "$GITHUB_OUTPUT"
+ version=$(sed -n 's/^project(SculptForge VERSION \([0-9.]*\).*/\1/p' CMakeLists.txt)
+ if [ "v$version" != "$TAG" ]; then
+ echo "::error::$TAG tags a commit whose CMakeLists.txt says $version. Fix: delete the tag, bump the version (or tag v$version), tag again."
+ exit 1
+ fi
+ if [ "$DRY_RUN" = true ] && [ -n "$PROMOTE_RUN" ]; then
+ run=$(gh api "repos/$REPO/actions/runs/$PROMOTE_RUN" \
+ --jq 'select(.path == ".github/workflows/packages.yml" and .conclusion == "success") | .id')
+ [ -n "$run" ] || { echo "::error::$PROMOTE_RUN is not a successful Packages run"; exit 1; }
+ echo "Dry run: smoke-testing the packages of run $run (not of $sha)"
+ echo "run-id=$run" >> "$GITHUB_OUTPUT"
+ exit 0
+ fi
+ # Successful runs on a push to main for exactly this commit, from this repository's own workflow files.
+ runs() {
+ gh api "repos/$REPO/actions/workflows/$1/runs?head_sha=$sha&event=push&branch=main&status=success&per_page=5" \
+ --jq '.workflow_runs[] | select(.head_sha == "'"$sha"'" and .head_branch == "main" and .event == "push"
+ and .path == ".github/workflows/'"$1"'" and .head_repository.full_name == "'"$REPO"'") | .id' | head -1
+ }
+ ci=$(runs ci.yml || true)
+ pkg=$(runs packages.yml || true)
+ if [ -n "$ci" ] && [ -n "$pkg" ]; then
+ echo "Promoting the packages of Packages run $pkg (CI run $ci passed for $sha)"
+ echo "run-id=$pkg" >> "$GITHUB_OUTPUT"
+ else
+ echo "No successful CI ($ci) and Packages ($pkg) runs on main for $sha: building the packages here"
+ fi
- flatpak:
- name: Flatpak ${{ matrix.arch }}
- runs-on: ${{ matrix.os }}
- strategy:
- fail-fast: false
- matrix:
- include:
- - { arch: x86_64, os: ubuntu-24.04 }
- - { arch: aarch64, os: ubuntu-24.04-arm }
- steps:
- - uses: actions/checkout@v7
- with: { ref: '${{ env.TAG }}' }
- - name: flatpak and flatpak-builder
- run: sudo apt-get update && sudo apt-get install -y flatpak flatpak-builder xvfb
- - name: Build the bundle (packaging/flatpak/org.sculptforge.SculptForge.yml)
- run: packaging/flatpak/build.sh dist
- - name: Install it and run a UI test inside the sandbox (Xvfb, Mesa from the runtime)
- run: |
- flatpak install --user -y --noninteractive dist/*.flatpak
- xvfb-run -a -s "-screen 0 1920x1080x24" \
- flatpak run --env=LIBGL_ALWAYS_SOFTWARE=1 org.sculptforge.SculptForge \
- --ui-test "$PWD/tests/ui/sculpt_basics.sfui" --ui-out "$PWD/flatpak-ui"
- - uses: actions/upload-artifact@v7
- with:
- name: flatpak-${{ matrix.arch }}
- path: dist/*.flatpak
+ build:
+ name: Build
+ needs: locate
+ if: needs.locate.outputs.run-id == ''
+ uses: ./.github/workflows/packages.yml
+ with:
+ ref: ${{ needs.locate.outputs.sha }}
+ tag: ${{ github.event.inputs.tag || github.ref_name }}
- vfx:
- name: ${{ matrix.label }} ${{ matrix.arch }}
+ smoke:
+ name: Smoke test ${{ matrix.name }}
+ needs: [locate, build]
+ if: ${{ !cancelled() && needs.locate.result == 'success' && (needs.build.result == 'success' || needs.build.result == 'skipped') }}
runs-on: ${{ matrix.os }}
container: ${{ matrix.image }}
+ permissions:
+ contents: read
+ actions: read # the packages may be another run's artifacts
strategy:
fail-fast: false
matrix:
include:
- # CY2026: EL8 / glibc 2.28 also gives the .rpm for RHEL 8, 9, 10 and Fedora.
- - { label: 'RPM + VFX CY2026', suffix: vfx2026, generators: 'RPM;TGZ', image: 'rockylinux:8', arch: x86_64, os: ubuntu-24.04 }
- - { label: 'RPM + VFX CY2026', suffix: vfx2026, generators: 'RPM;TGZ', image: 'rockylinux:8', arch: arm64, os: ubuntu-24.04-arm }
- - { label: 'VFX CY2027', suffix: vfx2027, generators: 'TGZ', image: 'rockylinux:9', arch: x86_64, os: ubuntu-24.04 }
- - { label: 'VFX CY2027', suffix: vfx2027, generators: 'TGZ', image: 'rockylinux:9', arch: arm64, os: ubuntu-24.04-arm }
+ - { name: Windows installer and .zip, kind: windows, artifact: windows, os: "${{ vars.SF_RUNNER_WIN || 'windows-2022' }}" }
+ - { name: macOS .dmg, kind: macos, artifact: macos, os: "${{ vars.SF_RUNNER_MAC || 'macos-15' }}" }
+ - { name: Linux x86_64 .deb and AppImage, kind: linux, artifact: linux-x86_64, os: "${{ vars.SF_RUNNER_LINUX || 'ubuntu-24.04' }}" }
+ - { name: Linux arm64 .deb and AppImage, kind: linux, artifact: linux-arm64, os: "${{ vars.SF_RUNNER_LINUX_ARM || 'ubuntu-24.04-arm' }}" }
+ - { name: .rpm (Rocky Linux 9), kind: rpm, artifact: vfx-vfx2026-x86_64, os: "${{ vars.SF_RUNNER_LINUX || 'ubuntu-24.04' }}", image: 'rockylinux:9' }
steps:
- - run: dnf -y install git
+ - if: matrix.kind == 'rpm'
+ run: dnf -y install git tar python3 xorg-x11-server-Xvfb mesa-dri-drivers
+ # The smoke scripts and the test model come from the workflow's own commit (the tag, when a tag runs this).
- uses: actions/checkout@v7
- with: { ref: '${{ env.TAG }}' }
- - run: ./packaging/linux/install-build-deps.sh
- - name: Python 3.13
+ with:
+ sparse-checkout: |
+ tests/release_smoke.py
+ tests/ui/release_smoke.sfui
+ tests/data/marble-bust.glb
+ sparse-checkout-cone-mode: false
+ - uses: actions/download-artifact@v8
+ with:
+ name: ${{ matrix.artifact }}
+ path: pkg
+ run-id: ${{ needs.locate.outputs.run-id || github.run_id }}
+ github-token: ${{ github.token }}
+ - name: Windows installer (silent) and .zip
+ if: matrix.kind == 'windows'
+ shell: pwsh
run: |
- curl -LsSf https://astral.sh/uv/0.9.5/install.sh | sh
- ~/.local/bin/uv venv --python 3.13 /opt/py313
- ~/.local/bin/uv pip install --python /opt/py313/bin/python numpy
- echo "PYTHON313=/opt/py313/bin/python" >> "$GITHUB_ENV"
- - name: Build, test and package with GCC 14
+ $installer = Get-ChildItem pkg/SculptForge-*-windows-x86_64.exe | Select-Object -First 1
+ Start-Process $installer.FullName -ArgumentList '/S', '/D=C:\SFInstalled' -Wait
+ Expand-Archive (Get-ChildItem pkg/SculptForge-*-windows-x86_64.zip | Select-Object -First 1).FullName -DestinationPath zip
+ $zipbin = (Get-ChildItem zip -Recurse -Filter sculptforge.exe | Select-Object -First 1).DirectoryName
+ # No GPU driver on the runner: Mesa's software OpenGL (pal1000/mesa-dist-win), pinned by hash, next to the exe.
+ $url = 'https://github.com/pal1000/mesa-dist-win/releases/download/26.2.4/mesa3d-26.2.4-release-msvc.7z'
+ Invoke-WebRequest $url -OutFile mesa.7z
+ if ((Get-FileHash mesa.7z -Algorithm SHA256).Hash -ne '351FC8C8B695878FFB3EAA044B3EAD08672A48B1A045E3C3E3975811DF0F6695') {
+ throw 'mesa3d archive hash mismatch'
+ }
+ $env:GALLIUM_DRIVER = 'llvmpipe'
+ foreach ($bin in @('C:\SFInstalled\bin', $zipbin)) {
+ Write-Host "== $bin"
+ 7z e mesa.7z x64/opengl32.dll x64/libgallium_wgl.dll "-o$bin" -y | Out-Null
+ & "$bin\sculptforge.exe" --ui-test "$PWD\tests\ui\release_smoke.sfui" --ui-out "$PWD\shots\$(Split-Path $bin -Leaf)"
+ if ($LASTEXITCODE -ne 0) { throw "the app's smoke test failed in $bin" }
+ python tests/release_smoke.py --cli "$bin\sculptforge-cli.exe" --out "smoke-$(Split-Path $bin -Leaf)"
+ if ($LASTEXITCODE -ne 0) { throw "the CLI smoke test failed in $bin" }
+ }
+ - name: macOS .dmg
+ if: matrix.kind == 'macos'
run: |
- source /opt/rh/gcc-toolset-14/enable
- cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr -DSCULPTFORGE_USE_SYSTEM_SDL=OFF \
- -DSCULPTFORGE_BUILD_PYTHON=ON -DPython_EXECUTABLE="$PYTHON313" -DSCULPTFORGE_PYTHON_INSTALL_DIR=lib/sculptforge/python
- cmake --build build --parallel 4
- # UI tests need a display; they run under Xvfb in the Linux jobs above and in CI.
- ctest --test-dir build --output-on-failure -LE ui -j 4
- cd build
- cpack -G TGZ -D CPACK_PACKAGE_FILE_NAME=SculptForge-${TAG#v}-linux-${{ matrix.arch }}-${{ matrix.suffix }}
- if [ "${{ matrix.generators }}" = "RPM;TGZ" ]; then cpack -G RPM; fi
- - uses: actions/upload-artifact@v7
- with:
- name: vfx-${{ matrix.suffix }}-${{ matrix.arch }}
- path: |
- build/*.rpm
- build/*.tar.gz
-
- macos:
- name: macOS (universal .dmg)
- runs-on: macos-15
- steps:
- - uses: actions/checkout@v7
- with: { ref: '${{ env.TAG }}' }
- - name: Build and test
+ mnt=$(mktemp -d)
+ hdiutil attach -nobrowse -readonly -mountpoint "$mnt" pkg/*.dmg
+ cp -R "$mnt/SculptForge.app" "$RUNNER_TEMP/"
+ hdiutil detach "$mnt"
+ app="$RUNNER_TEMP/SculptForge.app/Contents/MacOS"
+ codesign --verify --deep "$RUNNER_TEMP/SculptForge.app"
+ python3 tests/release_smoke.py --cli "$app/sculptforge-cli" --out smoke
+ "$app/sculptforge" --ui-test "$PWD/tests/ui/release_smoke.sfui" --ui-out "$PWD/shots"
+ - name: Linux .deb and AppImage
+ if: matrix.kind == 'linux'
run: |
- cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DSCULPTFORGE_USE_SYSTEM_SDL=OFF \
- -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64" -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0
- cmake --build build --parallel 4
- # UI tests need a display; they run under Xvfb in the Linux jobs above and in CI.
- ctest --test-dir build --output-on-failure -LE ui -j 4
- - name: Package (signed ad-hoc inside CPack, see cmake/MacSign.cmake)
- run: cd build && cpack -G DragNDrop
- - uses: actions/upload-artifact@v7
- with:
- name: macos
- path: build/*.dmg
-
- windows:
- name: Windows x64 (installer, .zip)
- runs-on: windows-2022
- steps:
- - uses: actions/checkout@v7
- with: { ref: '${{ env.TAG }}' }
- - name: Build and test
+ sudo apt-get update
+ sudo apt-get install -y --no-install-recommends ./pkg/sculptforge_*.deb xvfb libgl1-mesa-dri
+ ui() { xvfb-run -a -s "-screen 0 1920x1080x24" env LIBGL_ALWAYS_SOFTWARE=1 "$@" \
+ --ui-test "$PWD/tests/ui/release_smoke.sfui"; }
+ echo "== .deb"
+ ui /usr/bin/sculptforge --ui-out "$PWD/shots/deb"
+ python3 tests/release_smoke.py --cli /usr/bin/sculptforge-cli --out smoke-deb
+ echo "== AppImage (extracted: runners have no FUSE)"
+ chmod +x pkg/*.AppImage
+ (cd "$RUNNER_TEMP" && "$GITHUB_WORKSPACE"/pkg/*.AppImage --appimage-extract >/dev/null)
+ ui "$RUNNER_TEMP/squashfs-root/AppRun" --ui-out "$PWD/shots/appimage"
+ python3 tests/release_smoke.py --cli "$RUNNER_TEMP/squashfs-root/usr/bin/sculptforge-cli" --out smoke-appimage
+ - name: .rpm
+ if: matrix.kind == 'rpm'
run: |
- cmake -S . -B build -DSCULPTFORGE_USE_SYSTEM_SDL=OFF
- cmake --build build --config Release --parallel 4
- # UI tests need a display; they run under Xvfb in the Linux jobs above and in CI.
- ctest --test-dir build -C Release --output-on-failure -LE ui -j 4
- - name: Package
- run: cd build && cpack -C Release -G "NSIS;ZIP"
- - uses: actions/upload-artifact@v7
+ dnf -y install ./pkg/sculptforge-*.rpm
+ python3 tests/release_smoke.py --cli /usr/bin/sculptforge-cli --out smoke-rpm
+ Xvfb :99 -screen 0 1920x1080x24 & sleep 2
+ DISPLAY=:99 LIBGL_ALWAYS_SOFTWARE=1 /usr/bin/sculptforge \
+ --ui-test "$PWD/tests/ui/release_smoke.sfui" --ui-out "$PWD/shots/rpm"
+ - name: Screenshots
+ if: always()
+ uses: actions/upload-artifact@v7
with:
- name: windows
- path: |
- build/*.exe
- build/*.zip
+ name: smoke-shots-${{ matrix.artifact }}
+ path: shots
+ if-no-files-found: ignore
publish:
name: Publish GitHub Release
- needs: [linux, flatpak, vfx, macos, windows]
+ needs: [locate, build, smoke]
+ if: ${{ !cancelled() && needs.smoke.result == 'success' && inputs.dry_run != true }}
runs-on: ubuntu-24.04
+ permissions:
+ contents: write
+ actions: read
steps:
- uses: actions/checkout@v7
with: { ref: '${{ env.TAG }}' }
- uses: actions/download-artifact@v8
- with: { path: dist, merge-multiple: true }
+ with:
+ path: dist
+ merge-multiple: true
+ pattern: '{linux,flatpak,vfx,macos,windows}*'
+ run-id: ${{ needs.locate.outputs.run-id || github.run_id }}
+ github-token: ${{ github.token }}
- name: Version-less copies (fixed links such as releases/latest/download/SculptForge-macos.dmg)
run: |
cd dist