Merge pull request #83 from tamirelazar/dev

Release 0.1.1

Author: tamirelazar

.dockerignore

@@ -0,0 +1,14 @@
+# Keep the build context tiny. Exclude every target dir (root + nested crates
+# like tslime-wasm), the Nix `result` symlink, and all dev-meta. Only source,
+# Cargo manifests, and embedded assets reach the build.
+**/target
+result
+tslime-wasm
+.git
+.meta.git
+.claude
+.superpowers
+docs
+assets/demos
+.ws6_preview
+.github

.github/workflows/release.yml

@@ -26,15 +26,17 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
         include:
           - os: ubuntu-latest
+            target: x86_64-unknown-linux-musl
             artifact_name: tslime
             asset_name: tslime-linux-x86_64
           - os: macos-latest
+            target: aarch64-apple-darwin
             artifact_name: tslime
-            asset_name: tslime-macos-x86_64
+            asset_name: tslime-macos-arm64
           - os: windows-latest
+            target: x86_64-pc-windows-msvc
             artifact_name: tslime.exe
             asset_name: tslime-windows-x86_64.exe
 
@@ -44,6 +46,12 @@ jobs:
 
     - name: Install Rust toolchain
       uses: dtolnay/rust-toolchain@stable
+      with:
+        targets: ${{ matrix.target }}
+
+    - name: Install musl tools (Linux)
+      if: runner.os == 'Linux'
+      run: sudo apt-get update -qq && sudo apt-get install -y --no-install-recommends musl-tools
 
     - name: Cache cargo registry
       uses: actions/cache@v4
@@ -64,26 +72,34 @@ jobs:
         key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
 
     - name: Build release binary
-      run: cargo build --release --verbose
+      run: cargo build --release --verbose --target ${{ matrix.target }}
 
     - name: Check binary size
       if: runner.os == 'Linux'
       run: |
-        size target/release/tslime
-        SIZE=$(stat -c%s target/release/tslime)
-        # Headroom over the ~3.1MB Linux release binary.
+        BIN="target/${{ matrix.target }}/release/tslime"
+        size "$BIN" || true
+        SIZE=$(stat -c%s "$BIN")
         MAX_SIZE=4000000
         if [ "$SIZE" -gt "$MAX_SIZE" ]; then
           echo "Binary size $SIZE exceeds $MAX_SIZE limit"
           exit 1
         fi
         echo "Binary size $SIZE is under $MAX_SIZE limit"
 
+    # Stage the binary under its release asset name so the downloaded artifact
+    # is named correctly for `gh release create` (no post-download rename).
+    - name: Stage binary
+      shell: bash
+      run: |
+        mkdir -p dist
+        cp "target/${{ matrix.target }}/release/${{ matrix.artifact_name }}" "dist/${{ matrix.asset_name }}"
+
     - name: Upload artifact
       uses: actions/upload-artifact@v4
       with:
         name: ${{ matrix.asset_name }}
-        path: target/release/${{ matrix.artifact_name }}
+        path: dist/${{ matrix.asset_name }}
 
   gui-build:
     name: GUI Build
@@ -148,3 +164,90 @@ jobs:
       with:
         name: ${{ matrix.asset_name }}
         path: target/release/${{ matrix.artifact_name }}
+
+  # Publish a GitHub Release with the CLI binaries attached and notes pulled
+  # from the matching CHANGELOG section. Tag pushes only (skipped for manual
+  # workflow_dispatch runs, which have no tag to release).
+  release:
+    name: Publish GitHub Release
+    needs: build
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Download Linux binary
+      uses: actions/download-artifact@v4
+      with:
+        name: tslime-linux-x86_64
+        path: dist
+
+    - name: Download Windows binary
+      uses: actions/download-artifact@v4
+      with:
+        name: tslime-windows-x86_64.exe
+        path: dist
+
+    - name: Extract release notes from CHANGELOG
+      shell: bash
+      run: |
+        version="${GITHUB_REF_NAME#v}"
+        awk -v v="$version" '
+          $0 ~ ("^## \\[" v "\\]") { found=1; next }
+          found && /^## \[/ { exit }
+          found { print }
+        ' CHANGELOG.md > RELEASE_NOTES.md
+        if [ ! -s RELEASE_NOTES.md ]; then
+          printf 'tslime %s\n' "$GITHUB_REF_NAME" > RELEASE_NOTES.md
+        fi
+
+    - name: Create GitHub Release
+      env:
+        GH_TOKEN: ${{ github.token }}
+      shell: bash
+      run: |
+        gh release create "$GITHUB_REF_NAME" \
+          --repo "$GITHUB_REPOSITORY" \
+          --title "tslime $GITHUB_REF_NAME" \
+          --notes-file RELEASE_NOTES.md \
+          dist/tslime-linux-x86_64 \
+          dist/tslime-windows-x86_64.exe
+
+  # Publish a container image to GHCR so users can `docker run --rm -it
+  # ghcr.io/<owner>/tslime` without installing anything. Self-contained build
+  # (the Dockerfile compiles the static musl binary onto a scratch image). Tag
+  # pushes only. linux/amd64; arm64 is a follow-up.
+  docker:
+    name: Publish Docker image
+    needs: hygiene
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Log in to GitHub Container Registry
+      uses: docker/login-action@v3
+      with:
+        registry: ghcr.io
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Build and push image
+      uses: docker/build-push-action@v6
+      with:
+        context: .
+        platforms: linux/amd64
+        push: true
+        tags: |
+          ghcr.io/${{ github.repository }}:latest
+          ghcr.io/${{ github.repository }}:${{ github.ref_name }}

.gitignore

@@ -23,3 +23,7 @@ tslime_frame_*.png
 
 # Git worktrees
 .worktrees/
+
+# Nix build result symlinks
+result
+result-*

CHANGELOG.md

@@ -4,7 +4,34 @@ All notable changes to this project will be documented in this file.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/);
 versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.1.0] - TBD
+## [0.1.1] - 2026-06-26
+
+Distribution and release-pipeline fixes.
+
+### Changed
+- Linux release binary is now statically linked (musl target), so the single
+  `tslime-linux-x86_64` download runs on any x86_64 Linux distribution
+  regardless of glibc version.
+- Install documentation now leads with `cargo install` and a Homebrew tap;
+  see the README for per-platform paths.
+
+### Fixed
+- macOS distribution: prebuilt macOS binaries are no longer published (the
+  previous one was Gatekeeper-blocked and mislabeled as x86_64 while actually
+  being arm64). Install on macOS via `brew install tamirelazar/tslime/tslime`
+  or `cargo install tslime`, both of which avoid Gatekeeper.
+
+### Added
+- Homebrew tap `tamirelazar/homebrew-tslime` (source build).
+- One-paste install blocks for Linux and Windows in the README: they fetch the
+  latest release binary, install it to a user directory, put it on `PATH`, and
+  (on Windows) clear the Mark-of-the-Web so SmartScreen stays quiet.
+- Nix flake: `nix run github:tamirelazar/tslime` runs tslime ephemerally without
+  installing; `nix build` and `nix profile install` are also supported.
+- Docker image on GHCR: `docker run --rm -it ghcr.io/tamirelazar/tslime` runs
+  tslime ephemerally without installing (published on release; linux/amd64).
+
+## [0.1.0] - 2026-06-26
 
 First public release.
 

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "tslime"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 authors = ["tslime contributors"]
 description = "A lightweight terminal screensaver simulating slime mold growth patterns"
@@ -12,6 +12,9 @@ license = "MIT"
 keywords = ["terminal", "screensaver", "slime-mold", "generative-art", "physarum"]
 categories = ["command-line-utilities", "visualization", "simulation"]
 rust-version = "1.70"
+# Only the explicitly declared [[example]] targets are built; this stops cargo
+# from auto-discovering stray local files under examples/ (e.g. dev prototypes).
+autoexamples = false
 exclude = [
     ".github/",
     "assets/demos/*.gif",

Cargo.toml

@@ -0,0 +1,12 @@
+# Self-contained build: rust:alpine targets x86_64-unknown-linux-musl by
+# default, so a plain release build produces a static binary that runs on an
+# empty `scratch` image. Final image is just the ~3.6MB binary — no OS layer.
+FROM rust:alpine AS build
+RUN apk add --no-cache musl-dev
+WORKDIR /src
+COPY . .
+RUN cargo build --release
+
+FROM scratch
+COPY --from=build /src/target/release/tslime /tslime
+ENTRYPOINT ["/tslime"]

Dockerfile

@@ -10,13 +10,77 @@ binary, runs on Linux, macOS, Windows, and over SSH.
 
 ## Install
 
-From crates.io:
+### Any platform — cargo
 
 ```bash
 cargo install tslime
 ```
 
-From source (requires Rust 1.70 or later):
+Builds from source (requires Rust 1.70 or later). This is the universal path
+and sidesteps macOS Gatekeeper entirely.
+
+### Try it without installing — Nix
+
+If you have Nix with flakes, run tslime ephemerally — nothing is installed:
+
+```bash
+nix run github:tamirelazar/tslime
+```
+
+### Try it without installing — Docker
+
+No Nix? Run the published container instead — nothing is installed on the host:
+
+```bash
+docker run --rm -it ghcr.io/tamirelazar/tslime
+```
+
+### macOS — Homebrew
+
+```bash
+brew install tamirelazar/tslime/tslime
+```
+
+### Linux — prebuilt binary
+
+The Linux binary is statically linked (musl) and runs on any x86_64 distribution.
+Paste this to install it to `~/.local/bin`:
+
+```bash
+mkdir -p ~/.local/bin
+curl -fsSL https://github.com/tamirelazar/tslime/releases/latest/download/tslime-linux-x86_64 -o ~/.local/bin/tslime
+chmod +x ~/.local/bin/tslime
+~/.local/bin/tslime --version
+```
+
+If `tslime` isn't found afterwards, add `~/.local/bin` to your `PATH`:
+
+```bash
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.profile && export PATH="$HOME/.local/bin:$PATH"
+```
+
+### Windows — prebuilt binary
+
+Paste this into **PowerShell**. It downloads the binary, clears the
+Mark-of-the-Web so SmartScreen stays quiet, and adds it to your `PATH`:
+
+```powershell
+$dir = "$env:LOCALAPPDATA\Programs\tslime"
+New-Item -ItemType Directory -Force -Path $dir | Out-Null
+Invoke-WebRequest "https://github.com/tamirelazar/tslime/releases/latest/download/tslime-windows-x86_64.exe" -OutFile "$dir\tslime.exe"
+Unblock-File "$dir\tslime.exe"
+$userPath = [Environment]::GetEnvironmentVariable("Path", "User")
+if ($userPath -notlike "*$dir*") { [Environment]::SetEnvironmentVariable("Path", "$userPath;$dir", "User") }
+& "$dir\tslime.exe" --version
+```
+
+Open a new terminal afterwards so the `PATH` change takes effect (or run
+`$env:Path += ";$dir"` in the current one), then just run `tslime`.
+
+> macOS prebuilt binaries are not published — use Homebrew or `cargo install`
+> (both avoid Gatekeeper). ARM Linux (aarch64): use `cargo install`.
+
+### From source
 
 ```bash
 git clone https://github.com/tamirelazar/tslime.git
@@ -25,8 +89,6 @@ cargo build --release
 ./target/release/tslime
 ```
 
-Prebuilt binaries for Linux, macOS, and Windows accompany each release.
-
 ## Usage
 
 Run with no arguments for the interactive mode: