Skip to content

AI media harness for planning, generating, and editing locally

TypeScript

Build and package a Linux worker

Bitti351d9b6879d1
diff --git a/.gitattributes b/.gitattributes
index a1a5eba..6a7caf4 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -106,3 +106,6 @@ fixtures/*.json text eol=lf
*.xlsx filter=lfs diff=lfs merge=lfs -text
*.ppt filter=lfs diff=lfs merge=lfs -text
*.pptx filter=lfs diff=lfs merge=lfs -text
+
+# Shell scripts run in Linux/WSL bash, which rejects CRLF line endings.
+*.sh text eol=lf
diff --git a/README.md b/README.md
index c018f53..86a711e 100644
--- a/README.md
+++ b/README.md
@@ -47,13 +47,16 @@ Local video generation requires separately installed model weights and GPU suppo
### Generating on another computer
-Unpack the Slopus worker package (`Slopus-<version>-windows-x64-worker.zip`, containing `slopus-worker.exe` and `slopfab.dll`) on a computer with a capable GPU on the same network and run:
+Workers run on Windows or Linux. On a computer with a capable GPU on the same network, unpack the worker package and start it:
-```
-slopus-worker.exe --weights D:\Models
-```
+| Platform | Package | Start |
+| --- | --- | --- |
+| Windows x64 | `Slopus-<version>-windows-x64-worker.zip` (`slopus-worker.exe`, `slopfab.dll`) | `slopus-worker.exe --weights D:\Models` |
+| Linux x86_64 | `Slopus-<version>-linux-x64-worker.tar.gz` (`slopus-worker`, `libslopfab.so`) | `./slopus-worker --weights ~/models` |
-Allow it through Windows Firewall when asked. In Slopus, open **Settings → Workers** and click **Use** next to the worker. Generators whose weights have download links become usable even if they are not downloaded on this computer; the worker downloads missing weights into its weights folders on first use. Run `slopus-worker.exe --help` for options: `--port`, `--name`, `--token` (require an access token), `--data`, `--weights` (repeatable), `--backend` and `--no-mdns`. The worker uses CUDA when it is available (CUDA 13 if installed, otherwise CUDA 12) and otherwise falls back to Vulkan, printing a warning if an NVIDIA GPU is present without a usable CUDA installation. `--backend cuda13`, `--backend cuda12`, `--backend cuda` or `--backend vulkan` overrides the choice. Choose **This computer** to generate locally again.
+The Linux worker needs no desktop or UI libraries, but it does need an NVIDIA GPU with the NVIDIA driver and CUDA 13 cuBLAS (`libcublas.so.13`); it looks for cuBLAS in `/usr/local/cuda*` if the system linker does not find it. Allow the worker through the firewall (TCP 47321, and UDP 5353 for discovery).
+
+In Slopus, open **Settings → Workers** and click **Use** next to the worker. Generators whose weights have download links become usable even if they are not downloaded on this computer; the worker downloads missing weights into its weights folders on first use. Run `slopus-worker --help` for options: `--port`, `--name`, `--token` (require an access token), `--data`, `--weights` (repeatable), `--backend` and `--no-mdns`. The worker uses CUDA when it is available and otherwise falls back to Vulkan, printing a warning if an NVIDIA GPU is present without a usable CUDA installation. On Windows it uses CUDA 13 if installed, otherwise CUDA 12; the Linux runtime uses CUDA 13. `--backend cuda13`, `--backend cuda12`, `--backend cuda` or `--backend vulkan` overrides the choice. Choose **This computer** to generate locally again.
The project's GPU setup recommendations are:
diff --git a/package.cmd b/package.cmd
index 737d992..32ca233 100644
--- a/package.cmd
+++ b/package.cmd
@@ -57,6 +57,7 @@ rem after, and kept there afterwards so the build is runnable without unpacking.
set "OUTPUT_DIR=%ARTIFACTS_DIR%\%OUTPUT_STEM%-portable"
set "WORKER_ZIP=%ARTIFACTS_DIR%\%OUTPUT_STEM%-worker.zip"
set "WORKER_DIR=%ARTIFACTS_DIR%\%OUTPUT_STEM%-worker"
+set "LINUX_WORKER_NAME=Slopus-%APP_VERSION%-linux-x64-worker.tar.gz"
echo.
echo [1/5] Installing locked frontend dependencies...
@@ -118,6 +119,7 @@ rem Disable updates only in the unpacked folder used for local testing.
> "%OUTPUT_DIR%\slopus-portable" echo Local test build - automatic updates disabled.
if errorlevel 1 goto :fail
call :package_worker || goto :fail
+call :package_linux_worker || goto :fail
echo.
echo Package complete.
@@ -125,6 +127,7 @@ echo %OUTPUT_ZIP%
echo %OUTPUT_DIR%\
echo %WORKER_ZIP%
echo %WORKER_DIR%\
+if exist "%ARTIFACTS_DIR%\%LINUX_WORKER_NAME%" echo %ARTIFACTS_DIR%\%LINUX_WORKER_NAME%
echo.
echo The unpacked folder beside the zip is this build - run it straight from
echo there. It is rebuilt from scratch on every package run.
@@ -139,6 +142,7 @@ exit /b 0
rem The LAN worker ships as its own package: the headless worker and the
rem runtime it loads, nothing else. Copy it to the computer that generates.
if exist "%WORKER_DIR%" rd /s /q "%WORKER_DIR%"
+if exist "%ARTIFACTS_DIR%\%LINUX_WORKER_NAME%" del /q "%ARTIFACTS_DIR%\%LINUX_WORKER_NAME%"
if exist "%WORKER_DIR%" (
echo ERROR: could not clear %WORKER_DIR%.
echo Close anything running out of that folder and retry.
@@ -162,6 +166,17 @@ powershell.exe -NoProfile -NonInteractive -Command "$ErrorActionPreference='Stop
echo Worker: %OUTPUT_STEM%-worker\
exit /b 0
+:package_linux_worker
+rem The Linux worker is built inside WSL, which has the Linux toolchain, and
+rem packed with lib\slopfab\libslopfab.so. See scripts\package-linux-worker.sh.
+where.exe wsl.exe >nul 2>nul || (
+ echo Linux: skipped - WSL was not found. Releases require it.
+ exit /b 0
+)
+wsl.exe --cd "%ROOT_DIR%" -e bash scripts/package-linux-worker.sh "%APP_VERSION%" "artifacts/%LINUX_WORKER_NAME%" || exit /b 1
+echo Linux: %LINUX_WORKER_NAME%
+exit /b 0
+
:write_readme
> "%~1" echo Slopus %APP_VERSION% ^(windows-%PACKAGE_ARCH%, portable^)
>>"%~1" echo.
diff --git a/release.cmd b/release.cmd
index 3adae0d..777e2d0 100644
--- a/release.cmd
+++ b/release.cmd
@@ -80,6 +80,7 @@ rem after, and kept there afterwards so the build is runnable without unpacking.
set "OUTPUT_DIR=%ARTIFACTS_DIR%\%OUTPUT_STEM%-portable"
set "WORKER_ZIP=%ARTIFACTS_DIR%\%OUTPUT_STEM%-worker.zip"
set "WORKER_DIR=%ARTIFACTS_DIR%\%OUTPUT_STEM%-worker"
+set "LINUX_WORKER_NAME=Slopus-%APP_VERSION%-linux-x64-worker.tar.gz"
echo.
echo [1/6] Installing locked frontend dependencies...
@@ -171,6 +172,7 @@ rem Disable updates only in the unpacked folder used for local testing.
> "%OUTPUT_DIR%\slopus-portable" echo Local test build - automatic updates disabled.
if errorlevel 1 goto :fail
call :package_worker || goto :fail
+call :package_linux_worker || goto :fail
echo.
echo Package complete.
@@ -182,6 +184,7 @@ echo %OUTPUT_ZIP%
echo %OUTPUT_DIR%\
echo %WORKER_ZIP%
echo %WORKER_DIR%\
+if exist "%ARTIFACTS_DIR%\%LINUX_WORKER_NAME%" echo %ARTIFACTS_DIR%\%LINUX_WORKER_NAME%
echo.
echo The unpacked folder beside the zip is this build - run it straight from
echo there. It is rebuilt from scratch on every package run.
@@ -214,6 +217,7 @@ exit /b 1
rem The LAN worker ships as its own package: the headless worker and the
rem runtime it loads, nothing else. Copy it to the computer that generates.
if exist "%WORKER_DIR%" rd /s /q "%WORKER_DIR%"
+if exist "%ARTIFACTS_DIR%\%LINUX_WORKER_NAME%" del /q "%ARTIFACTS_DIR%\%LINUX_WORKER_NAME%"
if exist "%WORKER_DIR%" (
echo ERROR: could not clear %WORKER_DIR%.
echo Close anything running out of that folder and retry.
@@ -237,6 +241,18 @@ powershell.exe -NoProfile -NonInteractive -Command "$ErrorActionPreference='Stop
echo Worker: %OUTPUT_STEM%-worker\
exit /b 0
+:package_linux_worker
+rem The Linux worker is built inside WSL, which has the Linux toolchain, and
+rem packed with lib\slopfab\libslopfab.so. See scripts\package-linux-worker.sh.
+where.exe wsl.exe >nul 2>nul || (
+ echo ERROR: WSL was not found. Releases include the Linux worker, which is built in WSL.
+ echo Install WSL with Ubuntu and Rust, then retry.
+ exit /b 1
+)
+wsl.exe --cd "%ROOT_DIR%" -e bash scripts/package-linux-worker.sh "%APP_VERSION%" "artifacts/%LINUX_WORKER_NAME%" || exit /b 1
+echo Linux: %LINUX_WORKER_NAME%
+exit /b 0
+
:write_readme
> "%~1" echo Slopus %APP_VERSION% ^(windows-%PACKAGE_ARCH%, portable^)
>>"%~1" echo.
diff --git a/scripts/package-linux-worker.sh b/scripts/package-linux-worker.sh
new file mode 100644
index 0000000..9326404
--- /dev/null
+++ b/scripts/package-linux-worker.sh
@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+# Builds the Linux LAN worker and packs it with the Linux SlopFab runtime.
+#
+# bash scripts/package-linux-worker.sh <version> <output.tar.gz>
+#
+# Runs on Linux, including WSL, where package.cmd and release.cmd call it. The
+# worker crate depends only on slopus-core, so no UI libraries are needed to
+# build or run it. Cargo builds on the Linux filesystem: a Windows checkout
+# mounted under /mnt cannot hold ELF permissions and is slow to compile on.
+set -euo pipefail
+
+if (($# != 2)); then
+ printf 'Usage: bash %s <version> <output.tar.gz>\n' "$0" >&2
+ exit 2
+fi
+version=$1
+output=$2
+root=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
+
+if [[ $(uname -s) != Linux || $(uname -m) != x86_64 ]]; then
+ printf 'package-linux-worker: run on x86_64 Linux (including WSL).\n' >&2
+ exit 2
+fi
+# rustup installs into ~/.cargo; a non-login WSL shell has not sourced it.
+if ! command -v cargo >/dev/null && [[ -f $HOME/.cargo/env ]]; then
+ # shellcheck source=/dev/null
+ source "$HOME/.cargo/env"
+fi
+if ! command -v cargo >/dev/null; then
+ printf 'package-linux-worker: cargo was not found. Install Rust in this Linux environment:\n' >&2
+ printf ' curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal\n' >&2
+ exit 1
+fi
+
+runtime="$root/lib/slopfab/libslopfab.so"
+if [[ $(head -c 4 "$runtime" 2>/dev/null | od -An -c | tr -d ' ') != '177ELF' ]]; then
+ printf 'package-linux-worker: %s is missing or a Git LFS pointer. Run git lfs pull.\n' "$runtime" >&2
+ exit 1
+fi
+
+target_dir=${SLOPUS_LINUX_TARGET_DIR:-"$HOME/.cache/slopus/linux-worker-target"}
+CARGO_TARGET_DIR=$target_dir cargo build --release --locked \
+ --manifest-path "$root/src-tauri/Cargo.toml" -p slopus-worker
+
+cargo_version=$(sed -n '/^\[workspace.package\]/,/^\[/s/^version *= *"\(.*\)"/\1/p' "$root/src-tauri/Cargo.toml")
+if [[ $cargo_version != "$version" ]]; then
+ printf 'package-linux-worker: version %s does not match src-tauri/Cargo.toml (%s).\n' "$version" "$cargo_version" >&2
+ exit 1
+fi
+
+stage=$(mktemp -d /tmp/slopus-linux-worker.XXXXXXXX)
+trap 'rm -rf -- "$stage"' EXIT
+name="Slopus-$version-linux-x64-worker"
+package="$stage/$name"
+mkdir -p "$package"
+install -m 0755 "$target_dir/release/slopus-worker" "$package/slopus-worker"
+install -m 0755 "$runtime" "$package/libslopfab.so"
+cat > "$package/README.txt" <<EOF
+Slopus worker $version (linux-x64)
+
+Run ./slopus-worker to let Slopus generate on this computer over the local network.
+Slopus finds it automatically; choose it in Settings, Workers. Open TCP port 47321
+(or the --port you choose) and UDP port 5353 (mDNS) in the firewall.
+Keep libslopfab.so beside slopus-worker.
+
+REQUIREMENTS
+ x86_64 Linux with glibc, an NVIDIA GPU, the NVIDIA driver (libcuda.so.1) and
+ CUDA 13 cuBLAS (libcublas.so.13). The worker finds cuBLAS in /usr/local/cuda*
+ if the system linker does not. The Vulkan backend (--backend vulkan) also needs
+ the NVIDIA driver and cuBLAS, because the runtime links them. FFmpeg 8 shared
+ libraries enable video references.
+
+WEIGHTS
+ Weights with download links are downloaded here on first use. Add folders that
+ already hold Slopus downloads with --weights. Other model files are sent from Slopus.
+
+Run ./slopus-worker --help for options such as --port, --token, --weights and --backend.
+EOF
+mkdir -p -- "$(dirname -- "$output")"
+tar -C "$stage" --owner=0 --group=0 -czf "$stage/$name.tar.gz" "$name"
+cp -- "$stage/$name.tar.gz" "$output"
+printf 'package-linux-worker: wrote %s\n' "$output"
diff --git a/scripts/publish-release.mjs b/scripts/publish-release.mjs
index c7591d4..634ae42 100644
--- a/scripts/publish-release.mjs
+++ b/scripts/publish-release.mjs
@@ -58,6 +58,7 @@ export function releaseFiles(root, version) {
if (!manifest.platforms[`${target}-nsis`]) throw new Error('Missing NSIS updater target.');
names.add(`${stem}-portable.zip`);
names.add(`${stem}-worker.zip`);
+ names.add(`Slopus-${version}-linux-x64-worker.tar.gz`);
// Upload the manifest last. Only this explicit list can become release assets.
names.add('latest.json');
const files = [...names].map((name) => {
diff --git a/scripts/publish-release.test.mjs b/scripts/publish-release.test.mjs
index 0d3e02b..e97bfc5 100644
--- a/scripts/publish-release.test.mjs
+++ b/scripts/publish-release.test.mjs
@@ -32,6 +32,7 @@ function fixture() {
}
writeFileSync(join(root, 'artifacts/Slopus-0.2.0-windows-x64-portable.zip'), 'zip');
writeFileSync(join(root, 'artifacts/Slopus-0.2.0-windows-x64-worker.zip'), 'zip');
+ writeFileSync(join(root, 'artifacts/Slopus-0.2.0-linux-x64-worker.tar.gz'), 'tar');
// Unrelated artifacts and secrets must never be included by a wildcard upload.
writeFileSync(join(root, 'artifacts/private.key'), 'secret');
writeFileSync(join(root, 'artifacts/Slopus-0.1.0-windows-x64-setup.exe'), 'old');
diff --git a/src-tauri/core/build.rs b/src-tauri/core/build.rs
index 89a9cae..90aacdc 100644
--- a/src-tauri/core/build.rs
+++ b/src-tauri/core/build.rs
@@ -2,12 +2,14 @@ fn main() {
// Stage the SlopFab runtime beside this build's executables (the worker,
// and test binaries, which look one folder up from deps/). The desktop
// app stages it through Tauri resources as well; the copy is identical.
- let source = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab/slopfab.dll");
+ let windows = std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows");
+ let name = if windows { "slopfab.dll" } else { "libslopfab.so" };
+ let source = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(name);
println!("cargo:rerun-if-changed={}", source.display());
let out = std::path::PathBuf::from(std::env::var("OUT_DIR").unwrap());
// OUT_DIR is target/<profile>/build/<crate>-<hash>/out.
if let Some(profile) = out.ancestors().nth(3) {
- let destination = profile.join("slopfab.dll");
+ let destination = profile.join(name);
let stale = std::fs::metadata(&destination).ok().map(|meta| meta.len()) != std::fs::metadata(&source).ok().map(|meta| meta.len());
if source.is_file() && stale {
let _ = std::fs::copy(&source, destination);
diff --git a/src-tauri/core/src/slopfab/ffi/raw/mod.rs b/src-tauri/core/src/slopfab/ffi/raw/mod.rs
index 6176565..db63b2a 100644
--- a/src-tauri/core/src/slopfab/ffi/raw/mod.rs
+++ b/src-tauri/core/src/slopfab/ffi/raw/mod.rs
@@ -618,8 +618,55 @@ unsafe fn load_library(path: &Path) -> Result<Library, libloading::Error> {
#[cfg(not(windows))]
unsafe fn load_library(path: &Path) -> Result<Library, libloading::Error> {
+ preload_cublas();
unsafe { Library::new(path) }
}
+
+/// The Linux runtime links CUDA 13 cuBLAS by soname, with a search path that
+/// only matches the machine it was built on. When the system linker cannot
+/// find it, load it once from the usual CUDA install folders; the runtime then
+/// binds to the already loaded copy. A missing cuBLAS is reported by the
+/// runtime load itself.
+#[cfg(not(windows))]
+fn preload_cublas() {
+ use std::sync::Once;
+ static ONCE: Once = Once::new();
+ ONCE.call_once(|| {
+ const SONAME: &str = "libcublas.so.13";
+ let global = libloading::os::unix::RTLD_NOW | libloading::os::unix::RTLD_GLOBAL;
+ let open = |name: &std::ffi::OsStr| unsafe { libloading::os::unix::Library::open(Some(name), global) };
+ if open(SONAME.as_ref()).map(std::mem::forget).is_ok() {
+ return;
+ }
+ for directory in cuda_library_directories() {
+ let candidate = directory.join(SONAME);
+ if candidate.is_file() && open(candidate.as_os_str()).map(std::mem::forget).is_ok() {
+ return;
+ }
+ }
+ });
+}
+
+#[cfg(not(windows))]
+fn cuda_library_directories() -> Vec<std::path::PathBuf> {
+ let mut roots: Vec<std::path::PathBuf> = ["CUDA_HOME", "CUDA_PATH"].iter()
+ .filter_map(|name| std::env::var_os(name).map(Into::into)).collect();
+ roots.push("/usr/local/cuda".into());
+ // Versioned installs, newest first: /usr/local/cuda-13.3 before cuda-13.0.
+ let mut versioned: Vec<_> = std::fs::read_dir("/usr/local").into_iter().flatten().flatten()
+ .map(|entry| entry.path())
+ .filter(|path| path.file_name().and_then(|name| name.to_str()).is_some_and(|name| name.starts_with("cuda-13")))
+ .collect();
+ versioned.sort();
+ roots.extend(versioned.into_iter().rev());
+ let mut directories = Vec::new();
+ for root in roots {
+ directories.push(root.join("lib64"));
+ directories.push(root.join("targets/x86_64-linux/lib"));
+ }
+ directories.extend(["/usr/lib/x86_64-linux-gnu", "/usr/lib64"].map(std::path::PathBuf::from));
+ directories
+}
unsafe fn c_string(value: *const c_char) -> String {
if value.is_null() {
String::new()
diff --git a/src-tauri/core/src/slopfab/mod.rs b/src-tauri/core/src/slopfab/mod.rs
index 7f681b0..d552693 100644
--- a/src-tauri/core/src/slopfab/mod.rs
+++ b/src-tauri/core/src/slopfab/mod.rs
@@ -30,7 +30,10 @@ pub use icons::{generate_reference_icon_batch, ReferenceIconBatchConfig, Referen
pub use planning::resolve_plan;
pub use platform::{probe_backend, BackendProbe};
pub use status::{status, worker_status};
+#[cfg(windows)]
const DLL_FILE_NAME: &str = "slopfab.dll";
+#[cfg(not(windows))]
+const DLL_FILE_NAME: &str = "libslopfab.so";
/// Tauri stages the repository's runtime resources in development and release
/// builds. Installers and portable folders use the same relative layout.
pub fn default_dll_path() -> PathBuf {
diff --git a/src-tauri/core/src/worker/server.rs b/src-tauri/core/src/worker/server.rs
index cd31b3c..9096e99 100644
--- a/src-tauri/core/src/worker/server.rs
+++ b/src-tauri/core/src/worker/server.rs
@@ -78,6 +78,7 @@ pub fn choose_backend(requested: Backend, probe: &slopfab::BackendProbe) -> Resu
_ => "--backend cuda",
};
let install = match requested {
+ _ if !cfg!(windows) => "Install the NVIDIA driver and CUDA 13 cuBLAS (the Linux runtime is built for CUDA 13)",
Backend::Cuda13 => "Install the CUDA 13 toolkit",
Backend::Cuda12 => "Install the CUDA 12.8 toolkit",
_ => "Install CUDA 12.8 (RTX 30/40) or CUDA 13 (RTX 50)",
@@ -88,7 +89,8 @@ pub fn choose_backend(requested: Backend, probe: &slopfab::BackendProbe) -> Resu
(backend, None) if backend.is_cuda() && probe.nvidia_gpu => Err(format!("{flag}: CUDA is not available ({problem}). {install}, or use --backend vulkan.")),
(backend, None) if backend.is_cuda() => Err(format!("{flag}: no NVIDIA GPU was found. Use --backend vulkan.")),
(Backend::Auto, None) if probe.nvidia_gpu => Ok((true, Some(format!(
- "WARNING: This NVIDIA GPU supports CUDA, but CUDA was not detected ({problem}). Using the slower Vulkan backend. Install CUDA 12.8 (RTX 30/40) or CUDA 13 (RTX 50) for faster generation."
+ "WARNING: This NVIDIA GPU supports CUDA, but CUDA was not detected ({problem}). Using the slower Vulkan backend. {} for faster generation.",
+ if cfg!(windows) { "Install CUDA 12.8 (RTX 30/40) or CUDA 13 (RTX 50)" } else { "Install CUDA 13 cuBLAS" }
)))),
(_, None) => Ok((true, None)),
}
@@ -213,11 +215,15 @@ fn parsed_header<T: std::str::FromStr>(request: &Request, name: &str) -> Result<
fn data_directory(options: &WorkerOptions) -> PathBuf {
options.data.clone().unwrap_or_else(|| {
- std::env::var_os("LOCALAPPDATA")
- .map(PathBuf::from)
- .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".local/share")))
- .unwrap_or_else(std::env::temp_dir)
- .join("Slopus Worker")
+ if cfg!(windows) {
+ std::env::var_os("LOCALAPPDATA").map(PathBuf::from).unwrap_or_else(std::env::temp_dir).join("Slopus Worker")
+ } else {
+ // XDG base directories: $XDG_DATA_HOME, else ~/.local/share.
+ std::env::var_os("XDG_DATA_HOME").map(PathBuf::from)
+ .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".local/share")))
+ .unwrap_or_else(std::env::temp_dir)
+ .join("slopus-worker")
+ }
})
}
@@ -239,6 +245,8 @@ pub fn computer_name() -> String {
std::env::var("COMPUTERNAME")
.or_else(|_| std::env::var("HOSTNAME"))
.ok()
+ // Shells set HOSTNAME without exporting it, so services rarely see it.
+ .or_else(|| fs::read_to_string("/etc/hostname").ok().map(|name| name.trim().to_string()))
.filter(|name| !name.trim().is_empty())
.unwrap_or_else(|| "Slopus worker".into())
}
@@ -644,7 +652,8 @@ mod tests {
assert_eq!("cuda13".parse::<Backend>().unwrap(), Backend::Cuda13);
assert_eq!(choose_backend(Backend::Cuda12, &probe(true, Some("CUDA 12"))).unwrap(), (false, None));
let error = choose_backend(Backend::Cuda13, &probe(true, None)).unwrap_err();
- assert!(error.starts_with("--backend cuda13") && error.contains("CUDA 13 toolkit"), "{error}");
+ let hint = if cfg!(windows) { "CUDA 13 toolkit" } else { "CUDA 13 cuBLAS" };
+ assert!(error.starts_with("--backend cuda13") && error.contains(hint), "{error}");
}
#[test]
diff --git a/src-tauri/worker/src/main.rs b/src-tauri/worker/src/main.rs
index c03b50d..37338c4 100644
--- a/src-tauri/worker/src/main.rs
+++ b/src-tauri/worker/src/main.rs
@@ -11,7 +11,8 @@ const USAGE: &str = r"Usage: slopus-worker [options]
--port <number> TCP port to listen on (default 47321)
--name <text> Name shown in Slopus (default: computer name)
--token <text> Require this access token from clients
- --data <folder> Uploads, job files and logs (default: %LOCALAPPDATA%\Slopus Worker)
+ --data <folder> Uploads, job files and logs (default: %LOCALAPPDATA%\Slopus Worker on
+ Windows, ~/.local/share/slopus-worker on Linux)
--weights <folder> Extra weights folder to search and download into; repeatable
--backend <name> GPU backend: auto (default: CUDA 13, then CUDA 12, else Vulkan),
cuda (CUDA 13, then 12), cuda13, cuda12 or vulkan