Snapshot of the Umamo working tree as it is

Uploaded as-is from /home/litruv/dev/vtsmaker/umamo on 2026-11-03. 1347 files.
Includes the uncommitted work in progress in :edit, :runtime, and :ui, and the
untracked files under module/edit/src/jvmAndroidMain/.

History is not carried over. The source repo is https://github.com/umamoorg/umamo.
This commit is contained in:
litruv
2026-11-03 18:20:25 +11:00
commit 8bd8fa7a0b
1347 changed files with 246161 additions and 0 deletions
+15
View File
@@ -0,0 +1,15 @@
# These are supported funding model platforms
github: Alexia
patreon: c/Azxiana
open_collective: # Replace with a single Open Collective username
ko_fi: azxiana
tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
liberapay: # Replace with a single Liberapay username
issuehunt: # Replace with a single IssueHunt username
lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
polar: # Replace with a single Polar username
buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
thanks_dev: # Replace with a single thanks.dev username
custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
+38
View File
@@ -0,0 +1,38 @@
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: ''
assignees: ''
---
**Describe the bug**
A clear and concise description of what the bug is.
**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error
**Expected behavior**
A clear and concise description of what you expected to happen.
**Screenshots**
If applicable, add screenshots to help explain your problem.
**Desktop (please complete the following information):**
- OS: [e.g. iOS]
- Browser [e.g. chrome, safari]
- Version [e.g. 22]
**Smartphone (please complete the following information):**
- Device: [e.g. iPhone6]
- OS: [e.g. iOS8.1]
- Browser [e.g. stock browser, safari]
- Version [e.g. 22]
**Additional context**
Add any other context about the problem here.
+20
View File
@@ -0,0 +1,20 @@
---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: ''
assignees: ''
---
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.
+30
View File
@@ -0,0 +1,30 @@
# Continuous integration: runs the shared verification suite on every push/PR.
# The suite itself lives in verification.yml so release.yml can run the identical thing — see the
# comment at the top of that file for why it is factored out rather than inlined here.
name: CI
on:
push:
branches: [master, develop]
pull_request:
types: [opened, synchronize, reopened, ready_for_review]
# Least-privilege default: checkout is all this workflow needs. GitHub reports each
# job's pass/fail as a PR status check natively, no extra `checks`/`statuses` scope required.
permissions:
contents: read
# Cancel superseded runs on the same ref to save runner minutes.
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
jobs:
verify:
# Skip draft PRs to avoid burning runner minutes on WIP; ready_for_review re-triggers it.
# This guard lives here rather than in verification.yml because the release workflow calls the
# same suite with no pull-request context at all.
if: github.event_name != 'pull_request' || github.event.pull_request.draft == false
uses: ./.github/workflows/verification.yml
permissions:
contents: read
+433
View File
@@ -0,0 +1,433 @@
# Release: pushing a semver tag verifies the version, runs the full test suite, and publishes
# self-contained app images plus runnable uber jars for all five supported desktop targets.
#
# Deliberately out of scope until alpha: code signing, notarization, native installers
# (.msi/.dmg/.deb/.rpm) and auto-update. What ships here is an unzip-and-run app image with a
# bundled JRE, plus a jar for people who already have a JVM. See RELEASING.md.
name: Release
on:
push:
# These are GitHub filter patterns, not regex: `+` means "one or more of the preceding
# character", so `[0-9]+` is one-or-more digits and `.` is a literal dot. Two patterns rather
# than one trailing `*` so it is obvious that prerelease tags are supported ON PURPOSE —
# ProjectInfo.kt declares 0.1.0-dev today, so `v0.1.0-dev` has to be a legal release tag, and
# gradle/project-version.gradle.kts already strips the suffix for jpackage. The verify job
# re-checks the tag against a strict semver regex, so these globs are only a coarse filter.
tags:
- "v[0-9]+.[0-9]+.[0-9]+"
- "v[0-9]+.[0-9]+.[0-9]+-*"
# Dry run. Builds and tests everything and uploads all five targets as workflow artifacts, but
# publishes nothing — so the whole pipeline can be exercised from a branch before any tag exists.
workflow_dispatch:
# Least privilege at the workflow level; only the `release` job widens it, and only to contents:write.
permissions:
contents: read
# Serialise per ref, but NEVER cancel in progress: unlike CI, a cancelled run here can leave a
# half-uploaded release behind. A superseded release run is cheap; a torn one is not.
concurrency:
group: release-${{ github.ref }}
cancel-in-progress: false
jobs:
# -----------------------------------------------------------------------------------------------
# 1. The version gate. ProjectInfo.kt IS the version (its docblock forbids a second definition),
# so this workflow VERIFIES the tag against it and never injects a version. Runs first and
# alone: a mismatch should cost ~30 seconds, not a five-way packaging matrix.
# -----------------------------------------------------------------------------------------------
verify:
name: Verify version
runs-on: ubuntu-latest
timeout-minutes: 5
outputs:
version: ${{ steps.resolve.outputs.version }}
tag: ${{ steps.resolve.outputs.tag }}
prerelease: ${{ steps.resolve.outputs.prerelease }}
publish: ${{ steps.resolve.outputs.publish }}
steps:
- uses: actions/checkout@v7
- name: Resolve and cross-check the version
id: resolve
shell: bash
run: |
set -euo pipefail
project_info="module/ui/src/commonMain/kotlin/org/umamo/ui/help/ProjectInfo.kt"
# The same constant gradle/project-version.gradle.kts parses. POSIX sed with a
# bracket-expression for whitespace, so this needs nothing installed and behaves the same
# on every runner image.
declared="$(sed -n 's/.*VERSION[[:space:]]*=[[:space:]]*"\([^"]*\)".*/\1/p' "${project_info}" | head -n1)"
if [ -z "${declared}" ]; then
echo "::error file=${project_info}::VERSION constant not found — the build derives its version from it"
exit 1
fi
echo "ProjectInfo.VERSION = ${declared}"
if [ "${GITHUB_EVENT_NAME}" = "push" ]; then
tag="${GITHUB_REF_NAME}"
publish=true
else
# workflow_dispatch: no tag exists. Synthesise the one this commit WOULD ship under, so a
# dry run produces identically-named artifacts, and publish nothing.
tag="v${declared}"
publish=false
fi
echo "tag = ${tag} (publish=${publish})"
case "${tag}" in
v*) version="${tag#v}" ;;
*) echo "::error::tag '${tag}' must start with 'v'"; exit 1 ;;
esac
# Strict semver. The push filter above is a glob and would happily accept 'v1.2.3nonsense'.
if ! printf '%s' "${version}" | grep -Eq '^[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$'; then
echo "::error::tag '${tag}' is not a semantic version"
exit 1
fi
# THE gate. Fail loudly and say exactly what to do, because the fix is never "re-run".
if [ "${version}" != "${declared}" ]; then
echo "::error file=${project_info}::tag '${tag}' does not match ProjectInfo.VERSION '${declared}'. Bump the constant (and CHANGELOG.md), commit, delete the tag, and re-tag. This workflow never injects a version."
exit 1
fi
# A semver prerelease is anything with a '-' after MAJOR.MINOR.PATCH. 0.1.0-dev qualifies,
# which is correct: everything before alpha should be marked as such on the release page.
case "${version}" in
*-*) prerelease=true ;;
*) prerelease=false ;;
esac
{
echo "version=${version}"
echo "tag=${tag}"
echo "prerelease=${prerelease}"
echo "publish=${publish}"
} >> "${GITHUB_OUTPUT}"
# -----------------------------------------------------------------------------------------------
# 2. The quality gate — literally the same suite every push and PR runs, called as a reusable
# workflow so the two cannot drift. Nothing is packaged until this is green.
# -----------------------------------------------------------------------------------------------
test:
name: Verification suite
needs: verify
uses: ./.github/workflows/verification.yml
permissions:
contents: read
# -----------------------------------------------------------------------------------------------
# 3. Packaging, one leg per shipped target. Each leg produces exactly two files:
# umamo-<target>-<version>.{tar.gz|zip} — self-contained app image (bundled JRE)
# umamo-<target>-<version>.jar — uber jar, needs a JDK/JRE 21 on the machine
# Every leg builds ON its own OS/arch: an app image jlinks the HOST JDK into itself, so unlike
# the uber jar it genuinely cannot be cross-produced.
# -----------------------------------------------------------------------------------------------
package:
name: Package ${{ matrix.target }}
needs: [verify, test]
runs-on: ${{ matrix.runner }}
timeout-minutes: 60
strategy:
# One platform failing should not hide whether the other four work — on a release run that is
# the difference between one fix-and-retag and four.
fail-fast: false
# appImage gates createDistributable and the archive/assert steps that depend on it. It is
# false on macOS ONLY because of a jpackage bug, not anything about the app:
# jdk.jpackage.internal.CFBundleVersion rejects a CFBundleVersion whose first component is
# zero, so any 0.x version fails createDistributable on macOS alone. JDK-8380634 deleted that
# check on 2026-03-30, but it landed after JDK 26 forked — 21, 25 (LTS) and 26 (latest GA) all
# still carry it, so there is no released JDK to move to. Rather than mangle the version or
# ship an early-access runtime, the macOS legs publish the uber jar only until JDK 27 is GA
# (~September 2026). TO RESTORE: set these two back to true. Nothing else needs to change.
matrix:
include:
- { target: linux-x64, runner: ubuntu-latest, appImage: true }
- { target: linux-arm64, runner: ubuntu-24.04-arm, appImage: true }
- { target: windows-x64, runner: windows-latest, appImage: true }
- { target: macos-arm64, runner: macos-latest, appImage: false }
# macos-15-intel is the last x86-64 macOS image GitHub will offer; it retires in August
# 2027, after which this leg has to go and Intel Mac users fall back to the uber jar under
# an x64 JDK. (The older macos-13 label was retired in December 2025 — do not resurrect it.)
- { target: macos-x64, runner: macos-15-intel, appImage: false }
env:
UMAMO_VERSION: ${{ needs.verify.outputs.version }}
UMAMO_TARGET: ${{ matrix.target }}
UMAMO_APP_IMAGE: ${{ matrix.appImage }}
steps:
- uses: actions/checkout@v7
# jlink and jpackage come from the JVM the Gradle DAEMON runs on, not from jvmToolchain(21) —
# the Compose plugin defaults its javaHome to the `java.home` system property, and
# gradle/gradle-daemon-jvm.properties pins the daemon to 21. Temurin specifically: the plugin's
# checkRuntime task hard-errors on a Homebrew JDK, which is what a bare `brew install` leaves
# on PATH.
- name: Set up JDK 21
uses: actions/setup-java@v5
with:
distribution: temurin
java-version: "21"
# No Android SDK step here, unlike the verification suite. Every KMP library module applies
# AGP's com.android.kotlin.multiplatform.library and Gradle configures all projects even for a
# :desktop-only task graph, so this looked like it would be required — but it measurably is
# not: `env -u ANDROID_HOME -u ANDROID_SDK_ROOT ./gradlew :desktop:createDistributable
# --dry-run --no-configuration-cache` configures all seven android targets and resolves the
# task graph cleanly. Skipping it saves ~40 s per leg and avoids the arm64-Linux problem that
# Google ships only x86-64 build-tools binaries.
- name: Set up Gradle (with caching)
uses: gradle/actions/setup-gradle@v6
with:
# A tag build is read-only by default (it is not the default branch), but say so
# explicitly: five legs racing to write one cache is pure waste, and a release must never
# be the run that poisons the cache every PR then reads.
cache-read-only: true
# -Pumamo.target is passed EXPLICITLY rather than left to host detection, for two reasons:
# * the uber jar's name embeds it (see :desktop's archiveFileName override), so artifact
# names become a function of the matrix instead of a function of what the runner reported;
# * paired with -Pumamo.requireTargetIsHost it turns a runner-image surprise — an unexpected
# os.arch — into a build failure rather than a jar full of the wrong natives.
#
# Do NOT add `check` or `build` to this job. `check` pulls compileKotlinIosArm64 in :format,
# :runtime, and :render, and ubuntu-24.04-arm is not a supported Kotlin/Native host. The
# verification suite above is where testing happens.
#
# The heap overrides are not cosmetic: gradle.properties asks for a 4 GB Gradle daemon and the
# Kotlin daemon mirrors it, which is ~8 GB against the arm64 macOS runner's ~7 GB. 2 GB each
# fits every runner in the matrix and is ample for a :desktop-only task graph.
- name: Build the app image and the uber jar
shell: bash
run: |
set -euo pipefail
tasks=":desktop:packageUberJarForCurrentOS"
if [ "${UMAMO_APP_IMAGE}" = "true" ]; then
tasks=":desktop:createDistributable ${tasks}"
else
echo "::notice::${UMAMO_TARGET}: app image skipped, publishing the uber jar only (see the matrix comment in this workflow)"
fi
# shellcheck disable=SC2086 # tasks is a deliberate word-split list of Gradle task paths.
./gradlew --stacktrace \
-Dorg.gradle.jvmargs="-Xmx2g -Dfile.encoding=UTF-8" \
-Pkotlin.daemon.jvmargs=-Xmx2g \
-Pumamo.target="${UMAMO_TARGET}" \
-Pumamo.requireTargetIsHost=true \
${tasks}
# jlink writes a `release` descriptor listing MODULES into every runtime image and jpackage
# copies it into the app image verbatim, so this is a launch-free check that :desktop's
# modules(...) list still covers what the app actually uses. Without it a missing module is
# invisible until a user hits NoClassDefFoundError, because nothing in CI ever starts the
# packaged binary. The descriptor's depth differs per OS (macOS nests the runtime inside the
# .app bundle), so find it rather than hard-coding a path.
- name: Assert the bundled runtime carries the modules the app needs
if: matrix.appImage
shell: bash
run: |
set -euo pipefail
root="app/desktop/build/compose/binaries/main/app"
release_file="$(find "${root}" -maxdepth 8 -type f -name release | head -n1)"
if [ -z "${release_file}" ]; then
echo "::error::no jlink release descriptor under ${root} — did createDistributable actually run?"
exit 1
fi
echo "runtime descriptor: ${release_file}"
modules_line="$(grep '^MODULES=' "${release_file}")"
echo "${modules_line}"
for module in java.base java.desktop java.instrument java.logging java.sql java.xml jdk.security.auth jdk.unsupported; do
case "${modules_line}" in
*"${module}"*) ;;
*)
echo "::error::bundled runtime is missing ${module} — add it to nativeDistributions.modules in app/desktop/build.gradle.kts"
exit 1
;;
esac
done
# tar, not zip, on Linux: it is the only one of the three archivers here that preserves the
# execute bit on bin/umamo and the runtime's helper binaries. -C so the archive root is
# `umamo/` rather than the whole build path.
- name: Archive the app image (Linux)
if: matrix.appImage && runner.os == 'Linux'
shell: bash
run: |
set -euo pipefail
mkdir -p dist
tar -C "app/desktop/build/compose/binaries/main/app" \
-czf "dist/umamo-${UMAMO_TARGET}-${UMAMO_VERSION}.tar.gz" umamo
# Currently inert — matrix.appImage is false on both macOS legs (see the matrix comment). Kept
# rather than deleted so restoring macOS app images at JDK 27 GA is only a matrix flip.
#
# ditto, not zip: a .app is a bundle of symlinks, execute bits and extended attributes, and
# /usr/bin/zip flattens enough of that to produce something Finder refuses to open.
# `-c -k --keepParent` is Apple's own recipe and keeps `umamo.app` as the archive root.
- name: Archive the app image (macOS)
if: matrix.appImage && runner.os == 'macOS'
shell: bash
run: |
set -euo pipefail
mkdir -p dist
ditto -c -k --keepParent \
"app/desktop/build/compose/binaries/main/app/umamo.app" \
"dist/umamo-${UMAMO_TARGET}-${UMAMO_VERSION}.zip"
# 7z, not Compress-Archive: the app image is ~230 MB spread over several thousand files, a
# shape Compress-Archive takes minutes on. 7z ships on the windows runner image.
#
# Push-Location into the app-image directory first and archive the bare "umamo" name — 7z's
# default is to preserve whatever relative path you hand it inside the archive, so pointing it
# at the full build path bakes app\desktop\build\compose\binaries\main\app\umamo\ into every
# entry, which is what a user then has to click through after unzipping. cd'ing there first
# keeps the archive root flat, matching the Linux (`tar -C`) and macOS (`ditto --keepParent`)
# legs, which already avoid this.
- name: Archive the app image (Windows)
if: matrix.appImage && runner.os == 'Windows'
shell: pwsh
run: |
$ErrorActionPreference = "Stop"
New-Item -ItemType Directory -Force -Path dist | Out-Null
$distPath = (Resolve-Path dist).Path
Push-Location "app\desktop\build\compose\binaries\main\app"
try {
7z a -tzip -mx=5 "$distPath\umamo-$env:UMAMO_TARGET-$env:UMAMO_VERSION.zip" umamo | Out-Null
} finally {
Pop-Location
}
# An exact path, not a glob: the name is pinned by :desktop's archiveFileName override, so if
# that convention ever changes this fails here instead of shipping a release with a hole in it.
- name: Collect the uber jar
shell: bash
run: |
set -euo pipefail
mkdir -p dist
cp "app/desktop/build/compose/jars/umamo-${UMAMO_TARGET}-${UMAMO_VERSION}.jar" dist/
ls -lh dist/
- name: Upload this target's artifacts
uses: actions/upload-artifact@v7
with:
# Must be unique per matrix leg — the action errors rather than merging same-named uploads.
# The release job re-merges them with `pattern` + `merge-multiple`.
name: umamo-${{ matrix.target }}
path: dist/*
# A leg that produced nothing must fail here, not quietly ship a four-asset release.
if-no-files-found: error
# Everything in dist/ is already a compressed archive or a jar (itself a zip); re-deflating
# incompressible bytes would cost minutes per leg and save nothing.
compression-level: 0
# These are intermediates — the release page is the durable copy. Long enough to debug a
# failed publish, short enough not to hoard ~1.4 GB per run.
retention-days: 7
# -----------------------------------------------------------------------------------------------
# 4. Publish. Uses the gh CLI rather than a marketplace action on purpose: gh is preinstalled on
# every GitHub-hosted runner, so this — the only job holding contents:write — hands that token
# to no third-party code. It is also one less action version to pin and audit, and the
# behaviour on a re-run is ours to define rather than something to discover.
# -----------------------------------------------------------------------------------------------
release:
name: Publish GitHub release
needs: [verify, package]
# Dry runs stop after `package`: the artifacts are on the run page, nothing is published, and
# there is nothing to clean up afterwards.
if: needs.verify.outputs.publish == 'true'
runs-on: ubuntu-latest
timeout-minutes: 20
permissions:
# The only elevated permission anywhere in this workflow, scoped to the one job that needs it.
# Creating a release and uploading its assets is all contents:write buys; nothing here wants
# packages:, id-token: or actions:.
contents: write
steps:
- uses: actions/checkout@v7
- name: Download every target's artifacts
uses: actions/download-artifact@v8
with:
pattern: umamo-*
merge-multiple: true
path: dist
# Computed here, once, on one machine, in one format — rather than five per-OS variants of
# sha256sum/shasum/Get-FileHash that would then have to agree on output shape. The explicit
# `umamo-*` prefix keeps the checksum file from ever hashing itself.
- name: Generate SHA-256 checksums
working-directory: dist
run: |
set -euo pipefail
sha256sum umamo-* | tee SHA256SUMS.txt
ls -lh
- name: Create the release
env:
GH_TOKEN: ${{ github.token }}
TAG: ${{ needs.verify.outputs.tag }}
VERSION: ${{ needs.verify.outputs.version }}
PRERELEASE: ${{ needs.verify.outputs.prerelease }}
run: |
set -euo pipefail
# The unsigned-build warnings are not boilerplate: without them the first thing most users
# meet is an OS refusing to run the download. Unsigned is a deliberate pre-alpha choice, so
# the consequence belongs at the point of download.
notes="$(mktemp)"
cat > "${notes}" <<'NOTES'
## Downloads
| File | Note |
| ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
| `umamo-<target>-<version>.zip` / `.tar.gz` | Java SDK not required, just run it directly. |
| `umamo-<target>-<version>.jar` | You will need Java SDK 21 or higher to run. Either open through the file browser or through the command line. `java -jar umamo-...jar` |
Targets: `linux-x64`, `linux-arm64`, `windows-x64`, `macos-arm64`, `macos-x64`.
Verify your download against `SHA256SUMS.txt`.
**MacOS ships as the jar only for now.** A jpackage bug rejects any app version starting with `0`, and the fix is not in any released JDK yet, so there is no macOS app image until JDK 27 arrives. Install a JDK 21 or newer and run `java -jar umamo-….jar`.
## These builds are not signed
Code signing and notarization arrive at alpha. Until then:
* Windows: SmartScreen shows "Windows protected your PC". Choose *More info* → *Run anyway*.
* MacOS: The JAR is unaffected by Gatekeeper quarantine, so nothing extra is needed while MacOS ships as a JAR.
* Linux: No equivalent prompt. Extract `tar xzf umamo-*.tar.gz` and run `umamo/bin/umamo`.
There are no installers yet and no auto-update: to upgrade, delete the old folder and unpack the new one.
## Status
Umamo is early alpha. Keep backups of your project files and work on copies.
NOTES
assets=(dist/*)
# A re-run of a failed publish must converge, not collide.
if gh release view "${TAG}" > /dev/null 2>&1; then
echo "release ${TAG} already exists — replacing its assets"
gh release upload "${TAG}" "${assets[@]}" --clobber
else
args=(
--title "Umamo ${VERSION}"
--notes-file "${notes}"
# Appends the auto-generated commit/PR list after the hand-written notes above.
--generate-notes
# DRAFT on purpose. A draft is invisible to non-collaborators, notifies nobody, stays
# out of the releases Atom feed, and is never "latest" — so a bad build can be deleted
# as though it had never existed. Publishing is one click, or:
# gh release edit <tag> --draft=false
--draft
)
if [ "${PRERELEASE}" = "true" ]; then
args+=(--prerelease)
fi
gh release create "${TAG}" "${args[@]}" "${assets[@]}"
fi
gh release view "${TAG}"
+71
View File
@@ -0,0 +1,71 @@
# The verification suite: lint + build + test on JDK 21 with a real headless GL context.
#
# This is a reusable workflow (`workflow_call`) rather than a job inside ci.yml, because two things
# need to run EXACTLY this and must not be allowed to drift apart: every push/PR (ci.yml) and every
# release (release.yml). A release that ran a subtly different suite than the branch gate is a
# release whose green tick means less than it looks like it does.
name: Verification
on:
workflow_call:
# Least-privilege default: checkout is all this workflow needs. GitHub reports each
# job's pass/fail as a PR status check natively, no extra `checks`/`statuses` scope required.
permissions:
contents: read
jobs:
build:
runs-on: ubuntu-latest
timeout-minutes: 45
steps:
- uses: actions/checkout@v7
- name: Set up JDK 21
uses: actions/setup-java@v5
with:
distribution: temurin
java-version: "21"
# Provides ANDROID_HOME + sdkmanager; needed for the :android app + android targets.
# `packages` is overridden because the action's default list includes the legacy `tools`
# package, which current cmdline-tools no longer resolve, and sdkmanager exits 1 on it.
- name: Set up Android SDK
uses: android-actions/setup-android@v4
with:
packages: platform-tools
- name: Install Android SDK packages
run: sdkmanager "platforms;android-36" "build-tools;36.0.0"
- name: Set up Gradle (with caching)
uses: gradle/actions/setup-gradle@v6
# :render's GL tests drive a real GLFW / OpenGL 3.3 core context and assert on read-back pixels,
# so without a display they cover exactly nothing. Xvfb + Mesa's llvmpipe give the runner a real
# context. libgl1-mesa-dri is the load-bearing one — it carries swrast/llvmpipe, and Mesa cannot
# do software GL without it. The GLFW X11 libs are listed explicitly rather than trusted to the
# runner image, so an image change fails here instead of silently degrading the suite.
- name: Install headless OpenGL (Xvfb + Mesa software GL)
run: |
sudo apt-get update
sudo apt-get install -y --no-install-recommends \
xvfb libgl1 libgl1-mesa-dri libglx-mesa0 libegl1 \
libxrandr2 libxinerama1 libxcursor1 libxi6 libxext6
# umamo.requireGl turns the GL tests' missing-context skip into a hard failure (HeadlessGlGate),
# so if this Xvfb setup ever stops yielding a context, CI says so instead of going green on a
# suite that ran nothing. That is the whole point of the step above — without this flag a broken
# Xvfb is indistinguishable from a pass. LIBGL_ALWAYS_SOFTWARE pins Mesa to llvmpipe, since the
# runner has no GPU.
#
# NOTE: the golden corpus (test/corpus/, gitignored) is absent here, so every corpus-gated test
# either skips or — for the ~76 print-and-return sites — reports PASSED while asserting nothing.
# This suite therefore proves markedly less than the same command does locally. See
# RELEASING.md § "What this gate does not prove".
- name: Build, test, and lint
env:
LIBGL_ALWAYS_SOFTWARE: "1"
run: >
xvfb-run -a --server-args="-screen 0 1280x1024x24"
./gradlew build --stacktrace -Dumamo.requireGl=true