Add Alpine/musl release builds

The Linux artifacts are dynamically linked against glibc, so they do not
run on musl systems: the loader is missing and the shell reports it as
`sh: ./scratch-run: not found`. `gcompat` does not help either — it gets
past the loader and then fails on `Error relocating: fcntl64`.

@yao-pkg/pkg already ships prebuilt musl Node bases for the pinned
node22.22.2, so `alpine-x64`/`alpine-arm64` build like any other target.
The existing targets are untouched.

The musl binary is cross-compiled on the glibc runner, which cannot exec
it, so the test job runs the same suite inside an Alpine container and
points it at the binary through SCRATCH_RUN.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: matbrgz

.github/workflows/main.yml

@@ -16,6 +16,8 @@ jobs:
         include:
           - { os: ubuntu-24.04,     target: linux-x64,   outdir: linux-amd64 }
           - { os: ubuntu-24.04-arm, target: linux-arm64, outdir: linux-arm64 }
+          - { os: ubuntu-24.04,     target: alpine-x64,   outdir: alpine-amd64, musl: true }
+          - { os: ubuntu-24.04-arm, target: alpine-arm64, outdir: alpine-arm64, musl: true }
           - { os: macos-26-intel,   target: macos-x64,   outdir: macos-amd64 }
           - { os: macos-26,         target: macos-arm64, outdir: macos-arm64 }
           - { os: windows-2025,     target: win-x64,     outdir: win-amd64, ext: .exe }
@@ -50,9 +52,20 @@ jobs:
         run: codesign --force --sign - "bin/${{ matrix.outdir }}/scratch-run"
 
       - name: Test
+        if: ${{ !matrix.musl }}
         shell: bash
         run: python tests/test.py
 
+      # The musl build is cross-compiled on a glibc runner, which cannot exec
+      # it, so run the same suite inside Alpine.
+      - name: Test (Alpine)
+        if: ${{ matrix.musl }}
+        env:
+          OUT: ${{ matrix.outdir }}
+        run: |
+          docker run --rm -v "$PWD:/w" -w /w -e "SCRATCH_RUN=/w/bin/$OUT/scratch-run" \
+            alpine:3.22 sh -c 'apk add --no-cache python3 >/dev/null && python3 tests/test.py'
+
       - name: Package
         shell: bash
         run: |

README.md

@@ -4,14 +4,16 @@ scratch-run is a headless command-line interpreter for Scratch projects, built o
 
 It was created to **judge solutions written in Scratch**: a project reads from standard input and writes to standard output, so it can be graded like any other program. scratch-run powers Scratch problems on our online judge [VNOJ](https://github.com/VNOI-Admin/OJ), but it works standalone too.
 
-- **No runtime dependencies** — a single self-contained executable, packed with [@yao-pkg/pkg](https://github.com/yao-pkg/pkg).
+- **No runtime dependencies** — a single self-contained executable, packed with [@yao-pkg/pkg](https://github.com/yao-pkg/pkg). Linux builds are linked against the system C library, so there is a glibc build and a musl one.
 - **Fast** — runs in turbo mode through the scratch-vm compiler, with no rendering, audio, or extensions.
 - **Supports `.sb`, `.sb2`, `.sb3`, and raw `project.json`.**
 
 ## Installation
 
 Download a prebuilt binary for your platform from [Releases](https://github.com/VNOI-Admin/scratch-run/releases). Builds are provided for Linux, macOS, and Windows, on both x64 and arm64.
 
+On a musl-based distribution — Alpine, and the `alpine` container images built on it — take the `alpine_*` artifact. The `linux_*` ones need glibc and fail there with `sh: ./scratch-run: not found`, which looks like a missing file rather than a missing loader.
+
 ## Usage
 
 ```bash

build.sh

@@ -3,7 +3,7 @@ set -e
 
 # Build standalone executables with @yao-pkg/pkg (standard mode).
 #
-#   ./build.sh                       build all 6 targets (cross-compile) + zip
+#   ./build.sh                       build all 8 targets (cross-compile) + zip
 #   ./build.sh <arch> <outdir> [ext] build a single target (binary only)
 #
 # CI builds one native target per runner (no cross-compile, native macOS
@@ -37,6 +37,8 @@ if [ "$#" -ge 2 ]; then
 else
   build linux-x64    linux-amd64;       zip_target linux-amd64
   build linux-arm64  linux-arm64;       zip_target linux-arm64
+  build alpine-x64   alpine-amd64;      zip_target alpine-amd64
+  build alpine-arm64 alpine-arm64;      zip_target alpine-arm64
   build macos-x64    macos-amd64;       zip_target macos-amd64
   build macos-arm64  macos-arm64;       zip_target macos-arm64
   build win-x64      win-amd64    .exe; zip_target win-amd64 .exe

tests/test.py

@@ -8,6 +8,12 @@
 
 
 def get_executable():
+    # SCRATCH_RUN points the suite at a specific binary. Used to test the musl
+    # build, which is cross-compiled on a glibc runner and can only be run
+    # inside an Alpine container.
+    if os.environ.get('SCRATCH_RUN'):
+        return os.environ['SCRATCH_RUN']
+
     # platform.machine() reports the arch under different names per OS:
     # Linux aarch64, macOS arm64, Windows ARM64 — all mean arm64.
     machine = platform.machine().lower()