v0.3.1

stable-diffusion-go v0.3.1 — pure-Go binding + prebuilt native libraries.

Built from leejet/stable-diffusion.cpp @ e92e86f (upstream pin: master-802-e92e86f).

go get github.com/pendra-ai/stable-diffusion-go@v0.3.1 for the
binding; the lib archives attached here match this exact tag. Each archive
contains a self-contained libstable-diffusion (ggml statically linked,
hidden visibility — exports only the sd_* symbols pkg/sd/load.go registers).

CUDA archives require a matching host CUDA runtime; Vulkan archives require
a Vulkan loader/ICD on the host. The Windows archive carries the per-CPU/GPU
(avx2/avx512/avx/noavx/vulkan/cuda13) subdir tree the binding selects from.

The GitHub org was renamed Pendra-Cloud → Pendra-AI, so this repo now lives at github.com/pendra-ai/stable-diffusion-go. The go.mod module path still declared the old org, which works only for as long as GitHub's redirect survives — and that redirect dies the moment anyone re-registers the old org name.

Changes

File	What
go.mod	module path → github.com/pendra-ai/stable-diffusion-go
stable_diffusion.go, maps_test.go	internal imports of /pkg/sd
examples/txt2img, examples/txt2vid	imports
README.md (5), CLAUDE.md	go get, release URLs, import snippets, the module-path statement
csrc/sd_devmem.cpp	provenance comment
.github/workflows/build-libs.yml	the go get line in the generated release notes

Lowercase pendra-ai throughout: GitHub resolves case-insensitively, it matches the GHCR namespace and the already-published github.com/pendra-ai/pendra-go, and it avoids Go's !-escaping for uppercase module paths.

Please do NOT add release:skip

This PR needs its release train run. A module path rename makes this a new module to Go, and the existing v0.3.0 tag's go.mod still declares Pendra-Cloud/stable-diffusion-go — so go get github.com/pendra-ai/stable-diffusion-go@v0.3.0 fails with a module-path mismatch, redirect or not. Only a new tag cut after this merge makes the renamed path resolvable.

Merging therefore publishes v0.3.1 (patch) with the full lib matrix.

Downstream follow-up in pendra-ai/pendra

Once v0.3.1 exists, the worker needs all of these moved in lockstep — they're deliberately coupled, since one tag serves both the Go module and the runtime-downloaded native archives:

• packages/worker/go.mod → require github.com/pendra-ai/stable-diffusion-go v0.3.1
• internal/stablediffusioninstall.DefaultVersion → v0.3.1
• internal/stablediffusioninstall/checksums.json → new version and new hashes
• .stable-diffusion-go-version

packages/worker/scripts/bump-stable-diffusion-go.sh automates exactly this — note its MODULE= still points at the old org and needs updating in the same change.

The hashes genuinely change: this release rebuilds the archives rather than re-uploading v0.3.0's, so every per-variant SHA-256 is new. That's expected, not a red flag.

Testing

go build ./..., go vet ./..., go test ./... — 2 packages ok, no failures.

What's Changed

• refactor: rename the module path to github.com/pendra-ai/stable-diffusion-go by @tomcrawf90 in #30

Full Changelog: v0.3.0...v0.3.1

v0.3.0

stable-diffusion-go v0.3.0 — pure-Go binding + prebuilt native libraries.

Built from leejet/stable-diffusion.cpp @ e92e86f (upstream pin: master-802-e92e86f).

go get github.com/Pendra-Cloud/stable-diffusion-go@v0.3.0 for the
binding; the lib archives attached here match this exact tag. Each archive
contains a self-contained libstable-diffusion (ggml statically linked,
hidden visibility — exports only the sd_* symbols pkg/sd/load.go registers).

CUDA archives require a matching host CUDA runtime; Vulkan archives require
a Vulkan loader/ICD on the host. The Windows archive carries the per-CPU/GPU
(avx2/avx512/avx/noavx/vulkan/cuda13) subdir tree the binding selects from.

What & why

Adds whitelisted sd_*-prefixed wrappers around ggml's device-memory registry, compiled into libstable-diffusion, plus a GpuDevices() binding.

This lets a host that only dlopens libstable-diffusion (which statically links ggml with hidden visibility) read per-device free/total VRAM in-process — the same measurement llama.cpp / whisper.cpp already expose through their own libggml.

Without it, a Pendra worker measuring a stable-diffusion model's footprint on a discrete GPU has no per-device VRAM reading, falls back to a process-RSS delta that misses dedicated VRAM, and reports ~0.1 GB — so the model's real weights land un-attributed in the console memory map (Pendra-Cloud/pendra#1489). The worker-side consumer of GpuDevices() is a follow-up PR in the pendra repo.

Changes

• csrc/sd_devmem.cpp — SD_API wrappers: sd_backend_dev_count / get / memory / name / type, thin passthroughs to the hidden ggml_backend_dev_*.
• scripts/inject-devmem-wrapper.sh — drops the wrapper into upstream/src before the build; picked up by upstream's src/*.cpp CONFIGURE_DEPENDS glob (no CMakeLists edit, survives upstream refactors).
• build-libs.yml — inject step in all four build jobs (linux, linux-cuda, macos, windows).
• lib/expected-symbols.txt — the fail-closed gate now requires the 5 new symbols and still forbids any exported ggml_*, so ggml stays static + hidden (no base-name collision with another in-process ggml backend).
• pkg/sd — registerDevMemFunctions (optional: recovers so it never fails Load against an older lib, e.g. a PENDRA_SD_LIB override) + GpuDevices() (panic-safe enumeration).

Verification

Built locally on Apple Silicon (Metal) with the wrapper injected:

• nm -gU shows all 5 _sd_backend_dev_* exported; no ggml_* leak (only the allowed ggml_metallib_start/end markers).
• scripts/check-symbols.sh → OK — all 54 expected symbols exported, no ggml leakage.
• Runtime: sd.Load() + sd.GpuDevices() returns real MTL0 free/total (~12.1 GiB), plus BLAS/CPU devices with correct types.
• go test ./pkg/sd -run TestExpectedSymbolsMatchBinding (drift gate) passes.

The full CI matrix build is the remaining gate. Recommend a workflow_dispatch gating run (only=linux-amd64-cuda) to validate the injection on the CUDA leg before merge.

🤖 Generated with Claude Code

What's Changed

• feat(devmem): export sd_backend_dev_* wrappers for in-process VRAM reads by @tomcrawf90 in #29

Full Changelog: v0.2.4...v0.3.0

v0.2.4

stable-diffusion-go v0.2.4 — pure-Go binding + prebuilt native libraries.

Built from leejet/stable-diffusion.cpp @ e92e86f (upstream pin: master-802-e92e86f).

go get github.com/Pendra-Cloud/stable-diffusion-go@v0.2.4 for the
binding; the lib archives attached here match this exact tag. Each archive
contains a self-contained libstable-diffusion (ggml statically linked,
hidden visibility — exports only the sd_* symbols pkg/sd/load.go registers).

CUDA archives require a matching host CUDA runtime; Vulkan archives require
a Vulkan loader/ICD on the host. The Windows archive carries the per-CPU/GPU
(avx2/avx512/avx/noavx/vulkan/cuda13) subdir tree the binding selects from.

Root cause

The engine bump to upstream master-802-e92e86f (#27 — Krea2 + many new architectures) grew the single translation unit upstream/src/stable-diffusion.cpp past MSVC's COFF object-file section limit. Every Windows CPU and Vulkan matrix leg hard-failed with:

upstream\src\stable-diffusion.cpp : fatal error C1128: number of sections exceeded object file format limit: compile with /bigobj

(see the post-merge main build, run 30522367716). Those legs are mandatory, so the windows matrix failed, windows_assemble's symbol gate had no DLLs to pass, and the release job was skipped — no release can publish.

Fix

Add /bigobj to the MSVC compile via step-level CXXFLAGS/CFLAGS environment variables on the Windows "Build variant" step only.

Why env vars and not -DCMAKE_CXX_FLAGS=/bigobj: CMake initializes CMAKE_<LANG>_FLAGS as "$ENV{<LANG>FLAGS} <platform defaults>", so the env route appends /bigobj alongside MSVC's defaults (/DWIN32 /D_WINDOWS /EHsc /GR), whereas the cache-variable route would replace them and silently drop /EHsc (breaking C++ exception unwinding). SD_BASE_FLAGS is untouched — it is shared with the Linux/macOS GCC/Clang legs, where /bigobj is not a valid flag.

Verification (Windows-only gating run — manual runs never publish)

Dispatched build-libs.yml on this branch with only=windows-amd64: run 30524022593 — overall conclusion success.

Leg	Result
windows (avx2, cpu)	✅ success — 0 C1128 occurrences in log
windows (avx512, cpu)	✅ success — 0 C1128
windows (avx, cpu)	✅ success — 0 C1128
windows (noavx, cpu)	✅ success — 0 C1128
windows (vulkan)	✅ success — 0 C1128
windows (cuda13)	❌ pre-existing, optional (continue-on-error): cuda_runtime.h(82): fatal error C1083 — the known CUDA-13-on-windows-2022 include failure, unchanged by this PR
windows_assemble	✅ success — Windows symbol verification OK (5 variants) and Packaged stable-diffusion-libs-windows-amd64.tar.gz
release	⏭ skipped (manual gating runs never publish)

Merging this restores the Windows leg of the release pipeline; the cuda13 C1083 remains a separate known issue.

🤖 Generated with Claude Code

What's Changed

• Bump engine to master-802-e92e86f (Krea2 support) + full ABI re-port by @tomcrawf90 in #27
• ci(windows): compile with /bigobj to fix C1128 at upstream master-802 by @tomcrawf90 in #28

Full Changelog: v0.2.3...v0.2.4

v0.2.3

stable-diffusion-go v0.2.3 — pure-Go binding + prebuilt native libraries.

Built from leejet/stable-diffusion.cpp @ 19bdfe2 (upstream pin: master-685-19bdfe2).

go get github.com/Pendra-Cloud/stable-diffusion-go@v0.2.3 for the
binding; the lib archives attached here match this exact tag. Each archive
contains a self-contained libstable-diffusion (ggml statically linked,
hidden visibility — exports only the sd_* symbols pkg/sd/load.go registers).

CUDA archives require a matching host CUDA runtime; Vulkan archives require
a Vulkan loader/ICD on the host. The Windows archive carries the per-CPU/GPU
(avx2/avx512/avx/noavx/vulkan/cuda13) subdir tree the binding selects from.

Problem

On a Windows GPU host, image generation runs entirely on CPU even though a working GPU build is bundled. Confirmed live on a GCP NVIDIA L4 / Windows Server 2022 worker (Pendra v3.40.2): SDXL loaded with VRAM 0.00MB / RAM 4590MB, pegging the CPU for 5+ minutes with zero nvidia-smi activity.

Root cause

windowsLibCandidates builds the wrong candidate order:

if SD_VK_DEVICE == "true" { ...vulkan only if vulkaninfo detects a GPU... }
else if GetGPUName() == "NVIDIA" { candidates += "cuda13/..." }   // ← our host
candidates += GetCpuAVX()                                          // avx2 fallback

• The Pendra Windows installer bundles no cuda13 SD build (only avx*/noavx + vulkan), so the NVIDIA branch dead-ends and falls through to avx2 (CPU).
• The working vulkan build is gated behind SD_VK_DEVICE=true and GetVulkanGPU(), which shells out to vulkaninfo — a Vulkan-SDK tool that GPU drivers don't install. So the GPU path is effectively unreachable by default.

Fix

Select the Vulkan build for any detected GPU when the Vulkan loader is present:

• Order candidates vendor-optimal (cuda13/rocm) → vulkan → CPU. Load() already opens the first candidate whose file exists and skips the rest, so listing an unbundled variant (e.g. cuda13) is free — the NVIDIA host now lands on vulkan.
• Detect the loader via vulkan-1.dll in %SystemRoot%\System32 (installed by every vendor's Windows driver) instead of the vulkaninfo CLI.
• Keep SD_VK_DEVICE=true as an explicit force override.

Verified

• End-to-end on hardware: routing the L4 to the bundled vulkan build drove the GPU at 91–99% SM utilisation and finished generations in seconds (vs 5+ min on CPU).
• Unit tests (no GPU / no native lib needed — detection injected via package vars): NVIDIA & AMD prefer Vulkan-before-CPU; no Vulkan loader ⇒ no Vulkan offered; no GPU ⇒ CPU-only; SD_VK_DEVICE=true forces Vulkan.
• go build ./..., go test ./..., and GOOS=windows/GOOS=darwin cross-builds all pass.

Downstream

After this is tagged (e.g. v0.2.3), bump the dependency in Pendra-Cloud/pendra (packages/worker/go.mod) so the worker picks up GPU image generation on Windows.

What's Changed

• fix(windows): prefer the bundled Vulkan GPU build on a GPU host by @tomcrawf90 in #26

Full Changelog: v0.2.2...v0.2.3

v0.2.2

stable-diffusion-go v0.2.2 — pure-Go binding + prebuilt native libraries.

Built from leejet/stable-diffusion.cpp @ 19bdfe2 (upstream pin: master-685-19bdfe2).

go get github.com/Pendra-Cloud/stable-diffusion-go@v0.2.2 for the
binding; the lib archives attached here match this exact tag. Each archive
contains a self-contained libstable-diffusion (ggml statically linked,
hidden visibility — exports only the sd_* symbols pkg/sd/load.go registers).

CUDA archives require a matching host CUDA runtime; Vulkan archives require
a Vulkan loader/ICD on the host. The Windows archive carries the per-CPU/GPU
(avx2/avx512/avx/noavx/vulkan/cuda13) subdir tree the binding selects from.

Why

The Windows CUDA SD build (cuda12 leg) fails on windows-latest, and because windows_assemble needs the windows job and the auto-release job needs windows_assemble, that single leg has been blocking every release — no new tag or lib artifacts have published since the toolchain drift began. (This is why v0.2.2 with the image-gen callback fix never got tagged.)

Root cause: GitHub's windows-latest image now ships Visual Studio 18 / MSVC 14.51, and CUDA 12.9.1's nvcc rejects it:

host_config.h(170): fatal error C1189: unsupported Microsoft Visual Studio version!

This is environmental (a runner image bump), not a code change. The fix isn't to chase whatever VS the runner ships — it's to make the build deterministic and stop a no-consumer variant from gating releases.

What

• Align Windows CUDA to 13.0.0 — matching the Linux CUDA build (nvidia/cuda:13.0.0) and the worker's CUDA 13 runtime requirement (libcudart.so.13). Renames the variant subdir cuda12 → cuda13 consistently across the workflow, the loader (pkg/sd/load.go windowsLibCandidates), README.md, and .gitignore.
• Pin the CUDA leg to windows-2022 (per-leg runs-on), whose VS2022 host compiler CUDA 13's nvcc supports — rather than inheriting whatever Visual Studio the latest runner happens to have.
• Make the CUDA leg best-effort (continue-on-error). Nothing Pendra ships bundles Windows CUDA SD — NVIDIA-on-Windows uses the Vulkan build (cudart is a separate ~half-GiB non-redistributable). So a future host/CUDA mismatch must never block a release again. windows_assemble now requires the 5 mandatory CPU/Vulkan DLLs and treats cuda13 as optional (5 or 6 both valid).

Effect

The 5 variants the product actually ships always build and publish; the CUDA leg ships when the pinned toolchain builds it and is harmless when it doesn't. Merging this unblocks the auto-tag + release that was stuck.

🤖 Generated with Claude Code

What's Changed

• ci(pr-agent): sync to v0.36.1 with var-driven model + comment de-dup by @tomcrawf90 in #23
• fix: return uintptr from C-ABI callbacks so Windows image gen works by @tomcrawf90 in #22
• ci(windows): align CUDA SD to 13, pin VS2022 host, de-gate the release by @tomcrawf90 in #24

Full Changelog: v0.2.1...v0.2.2

v0.2.1

stable-diffusion-go v0.2.1 — pure-Go binding + prebuilt native libraries.

Built from leejet/stable-diffusion.cpp @ 19bdfe2 (upstream pin: master-685-19bdfe2).

go get github.com/Pendra-Cloud/stable-diffusion-go@v0.2.1 for the
binding; the lib archives attached here match this exact tag. Each archive
contains a self-contained libstable-diffusion (ggml statically linked,
hidden visibility — exports only the sd_* symbols pkg/sd/load.go registers).

CUDA archives require a matching host CUDA runtime; Vulkan archives require
a Vulkan loader/ICD on the host. The Windows archive carries the per-CPU/GPU
(avx2/avx512/avx/noavx/vulkan/cuda12) subdir tree the binding selects from.

Problem

The v0.2.0 CUDA libstable-diffusion.so carries a hard libnccl.so.2
NEEDED dependency (v0.1.15 did not). On a clean CUDA host without the
separate libnccl2 package installed, the library fails to dlopen — so a
downstream consumer's CUDA image backend can't load at all. Reproduced on an
RTX A4000 / CUDA 13 box: the lib only loaded after apt install libnccl2.

Root cause

ggml's GGML_CUDA_NCCL option defaults ON (ggml/CMakeLists.txt). The
build runs in nvidia/cuda:13.0.0-devel, which ships NCCL, so cmake's
find_package(NCCL) succeeds and links it into ggml-cuda. Because ggml is
statically linked into libstable-diffusion.so (SD_BUILD_SHARED_GGML_LIB=OFF),
that propagates as a NEEDED libnccl.so.2 entry.

NCCL is multi-GPU collective communication only (all-reduce across GPUs).
Single-GPU / single-context image (and video) generation never invokes it, so
it is safe to drop — and dropping it is better than bundling a ~100 MB lib.

Change

• Pass -DGGML_CUDA_NCCL=OFF on the Linux CUDA and Windows cuda12
  build legs.
• Add a fail-closed readelf guard on the Linux CUDA job asserting the
  built lib has no libnccl NEEDED entry, so this can't silently
  regress if an upstream default flips.

The remaining NEEDED CUDA deps (libcudart/libcublas/libcuda) are the
expected "matching host CUDA runtime" the release notes already require.

Verification

• gofmt/go vet/go build/go test ./... all clean (Go untouched;
  exported symbol set unchanged, so check-symbols.sh is unaffected).
• The new readelf guard verifies the rebuilt CUDA lib in CI.
• Confirmed the current v0.2.0 CUDA lib references libnccl.so.2; the cmake
  conditional means GGML_CUDA_NCCL=OFF removes that link path.

Patch-level fix → cuts the next patch release; the Pendra worker will then
re-pin to it.

What's Changed

• ci: add PR Agent review workflow backed by Pendra inference by @tomcrawf90 in #21
• fix(cuda): build without NCCL so the CUDA lib loads without libnccl2 by @tomcrawf90 in #20

Full Changelog: v0.2.0...v0.2.1

v0.2.0

stable-diffusion-go v0.2.0 — pure-Go binding + prebuilt native libraries.

Built from leejet/stable-diffusion.cpp @ 19bdfe2 (upstream pin: master-685-19bdfe2).

go get github.com/Pendra-Cloud/stable-diffusion-go@v0.2.0 for the
binding; the lib archives attached here match this exact tag. Each archive
contains a self-contained libstable-diffusion (ggml statically linked,
hidden visibility — exports only the sd_* symbols pkg/sd/load.go registers).

CUDA archives require a matching host CUDA runtime; Vulkan archives require
a Vulkan loader/ICD on the host. The Windows archive carries the per-CPU/GPU
(avx2/avx512/avx/noavx/vulkan/cuda12) subdir tree the binding selects from.

Highlights

Re-syncs the binding to leejet/stable-diffusion.cpp master-685 (from master-453 — 232 upstream commits) and surfaces the new image-generation capabilities, most notably CPU→GPU weight streaming for running models that don't fit in VRAM.

This is a minor release (v0.2.0): it adds significant features and contains one breaking API change (see below).

✨ VRAM weight streaming — run models larger than your GPU

• ContextParams.StreamLayers bool — stream model weights from CPU during generation (residency + prefetch).
• ContextParams.MaxVRAM float32 — GiB budget for graph-cut segmented parameter offload. 0 disables, -1 auto-detects (free VRAM minus 1 GiB).
• ContextParams.Backend / ParamsBackend string — runtime backend selection (upstream switched to runtime backend discovery).

StreamLayers has no effect unless MaxVRAM is also set. This is weight streaming for memory-constrained inference — not token/output streaming.

🔍 Hi-res fix (second high-resolution pass)

New ImgGenParams fields: HiresEnabled, HiresUpscaler (latent / model / lanczos / latent_bicubic / …), HiresModelPath, HiresScale, HiresTargetWidth, HiresTargetHeight, HiresSteps, HiresDenoisingStrength, HiresUpscaleTileSize, HiresCustomSigmas. Disabled by default; unset numeric fields keep the library's defaults.

🎛️ New samplers, schedulers, caches, quant types

• Samplers: res_multistep, res_2s, er_sde, euler_cfg_pp, euler_a_cfg_pp, euler_ge.
• Schedulers: bong_tangent, ltx2.
• Cache: SD_CACHE_SPECTRUM mode + spectrum tuning fields on SDCacheParams.
• Quant types: nvfp4, q1_0.
• Other context options: VAEFormat (auto/flux/sd3/flux2), FlashAttn (whole-model flash attention), new model/loader paths (UncondDiffusionModelPath, EmbeddingsConnectorsPath, AudioVAEPath), and per-generation FlowShift / ExtraSampleArgs.

The upstream commit range also adds support for many new models that the prebuilt libs in this release now carry — Flux.2 Klein, HiDream, Anima, ERNIE-image, Longcat, Ideogram4, SDXS, Z-Image, Chroma Radiance, plus Qwen-image fixes and assorted performance work.

⚠️ Breaking change

ContextParams.FlowShift has been removed. Upstream moved flow_shift from a context-level setting to a per-generation sampler parameter. Migrate by setting it on the generation params instead:

// before
sd.NewStableDiffusion(&ContextParams{ /* ... */ FlowShift: 3.0 })

// after — set it per generation
sd.GenerateImage(&ImgGenParams{ /* ... */ FlowShift: 3.0 }, out) // images
// (VidGenParams.FlowShift / HighNoiseFlowShift for video)

When left unset (0), the binding now passes the upstream "auto" sentinel so each model uses its own appropriate shift — preserving the old "library default" behaviour rather than silently forcing shift = 0 (which would degrade flow models like Flux/SD3).

🧱 ABI resync (why this PR touches so much)

The Go structs are a hand-maintained mirror of the C structs and are populated by the native *_init functions through a pointer, so they must match the new C layout exactly or memory corrupts. Several C structs gained fields mid-struct (e.g. temporal_tiling is now field #2 of sd_tiling_params_t), and two native signatures changed:

• generate_video now returns bool and yields frames and an audio buffer. The audio buffer is freed (this binding is image-focused); the public Go (*SDContext).GenerateVideo → ([]SDImage, int) signature is unchanged, so video callers are unaffected.
• new_upscaler_ctx gained backend / params_backend args, surfaced via UpscalerParams.Backend / ParamsBackend.

Six new native symbols are bound: sd_ctx_supports_image_generation, sd_ctx_supports_video_generation, sd_hires_upscaler_name, str_to_sd_hires_upscaler, sd_hires_params_init, free_sd_audio.

Scope: image generation only. Video is kept compiling and correct (full ABI resync + signature fix, audio discarded) but gains no new features; no LTX2 audio pipeline.

🛠️ Build

• lib/version.txt → master-685-19bdfe2.
• Forces SD_WEBP=OFF / SD_WEBM=OFF: upstream now vendors libwebp/libwebm as submodules that clone-upstream.sh initialises recursively (which would otherwise default them ON). The binding does its own image I/O (PNG via the Go stdlib), so this keeps the build lean and identical in scope to before.
• Single self-contained shared-lib model is preserved (SD_BUILD_SHARED_LIBS=ON, static ggml, hidden visibility), so packaging and the symbol gate are unchanged.

✅ Verification

gofmt -l . clean · go vet ./... · go test ./... · cross-builds for windows/amd64, darwin/arm64, linux/amd64 — all pass with no native library present. The CI symbol gate (lib/expected-symbols.txt, now 47 symbols) and the enum-ABI table (pkg/sd/enums_test.go) guard that the resync stayed faithful to the C ABI; a new maps_test.go covers the added string→enum map entries.

The native libs are built and symbol-verified by this release pipeline. An end-to-end generation against the freshly built master-685 libs (e.g. with StreamLayers: true) is the remaining manual smoke test — CI has no GPU/lib.

---

🤖 Generated with Claude Code

What's Changed

• feat: upgrade stable-diffusion.cpp to master-685 (VRAM weight streaming + image features) by @tomcrawf90 in #19

Full Changelog: v0.1.15...v0.2.0

v0.1.15

stable-diffusion-go v0.1.15 — pure-Go binding + prebuilt native libraries.

Built from leejet/stable-diffusion.cpp @ 4ff2c8c (upstream pin: master-453-4ff2c8c).

go get github.com/Pendra-Cloud/stable-diffusion-go@v0.1.15 for the
binding; the lib archives attached here match this exact tag. Each archive
contains a self-contained libstable-diffusion (ggml statically linked,
hidden visibility — exports only the sd_* symbols pkg/sd/load.go registers).

CUDA archives require a matching host CUDA runtime; Vulkan archives require
a Vulkan loader/ICD on the host. The Windows archive carries the per-CPU/GPU
(avx2/avx512/avx/noavx/vulkan/cuda12) subdir tree the binding selects from.

What's Changed

• ci: unify into a single vX.Y.Z release train that carries the libs by @tomcrawf90 in #17
• ci: match release sentinels on the commit subject only by @tomcrawf90 in #18

Full Changelog: v0.1.14...v0.1.15

v0.1.14

What's Changed

• ci: build Windows variants in parallel (one matrix leg per output) by @tomcrawf90 in #16

Full Changelog: v0.1.13...v0.1.14

v0.1.13

What's Changed

• ci: trim Windows CUDA arch list to keep the build practical by @tomcrawf90 in #15

Full Changelog: v0.1.12...v0.1.13