AI media harness for planning, generating, and editing locally
TypeScript
Build and package a Linux worker
Bitti351d9b6879d1
diff --git a/.gitattributes b/.gitattributesindex 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=lfdiff --git a/README.md b/README.mdindex 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.cmdindex 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 :failcall :package_worker || goto :fail+call :package_linux_worker || goto :failecho.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 fromecho there. It is rebuilt from scratch on every package run.@@ -139,6 +142,7 @@ exit /b 0rem The LAN worker ships as its own package: the headless worker and therem 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='Stopecho 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.cmdindex 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 :failcall :package_worker || goto :fail+call :package_linux_worker || goto :failecho.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 fromecho there. It is rebuilt from scratch on every package run.@@ -214,6 +217,7 @@ exit /b 1rem The LAN worker ships as its own package: the headless worker and therem 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='Stopecho 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.shnew file mode 100644index 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.mjsindex 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.mjsindex 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.rsindex 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.rsindex 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.rsindex 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, Referenpub 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.rsindex 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.rsindex 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