AI media harness for planning, generating, and editing locally
Desktop updates
Installed release builds check on startup and expose Settings → Updates for manual checks, release notes, download progress, and installation. Installation is explicit and restarts Slopus. Close the project and finish or cancel queued work first; unsaved project changes or videos also block installation. Failed checks and downloads can be retried from Settings.
Browser previews and debug builds do not check for updates. On Windows, release
builds enable installer updates only when a Slopus NSIS or MSI uninstall entry
registers the running executable's exact installation folder. Detection checks
both user and machine registrations and both registry views, including custom
installation folders and existing installations. Unregistered copies of
Slopus.exe and slopfab.dll are portable automatically; no marker file is needed.
They check on startup and in Settings, show
available versions and release notes, and offer Open releases to open
https://github.com/bitti-ai/slopus/releases in the default browser. They never
download or run an installer, and opening the page does not require closing a
project or stopping background work.
To update a portable copy, download the newer portable ZIP, close Slopus, and
replace Slopus.exe and slopfab.dll together in the existing folder. Settings,
projects and downloaded models are preserved. A portable copy remains portable
even if another copy of Slopus is installed elsewhere on the same computer.
Pre-release tests
release.cmd runs npm run test:release after installing dependencies and before
building any release artifacts. A failed check stops the script, including when
using --publish. Run the same command separately to check without building or
publishing anything.
The generation URL tests use the app's fresh-install generator and LoRA catalogs.
They check every model URL, GPU/VRAM download variant, additional conditioning
file and bundled LoRA, combining duplicate URLs into a single request. Hugging
Face blob links are converted to the same resolve links used by the app.
Checks follow redirects and require a successful, nonempty file response rather
than an HTML page. They use HEAD first; when the server does not support it or
omits the size, they request bytes=0-0 and cancel after the first streamed chunk.
Even if the server ignores the range, the response is never read in full or saved.
Checks run three at a time, with a 20-second timeout per attempt and one retry
for network failures, timeouts, rate limits or server errors. Internet access is
required; unavailable files or persistent connection failures block the release.
Add future release checks as tests/release/**/*.test.ts. The dedicated
vitest.release.config.ts discovers them automatically. Regular npm test runs
exclude these live checks; the URL probe's local HTTP regression tests run in the
regular suite as scripts/release-downloads.test.ts.
Signing key
The public key is committed in src-tauri/tauri.conf.json. The matching private
key was generated locally at %USERPROFILE%\.tauri\slopus-updater.key, outside
the repository, without a password. Back it up securely: existing installations
trust this key, and losing it prevents signing updates they will accept. Never
commit or upload the private key as a release asset.
release.cmd uses this path by default. On another build machine, restore the
same key and set these environment variables as appropriate:
$env:TAURI_SIGNING_PRIVATE_KEY = 'C:\secure\slopus-updater.key'
# Set this only if the key is password-protected:
$env:TAURI_SIGNING_PRIVATE_KEY_PASSWORD = 'your-key-password'
For a new app identity before distributing any builds, a key can be generated
with npx tauri signer generate --write-keys C:\secure\slopus-updater.key.
Put the complete contents of the resulting .pub file in plugins.updater.pubkey.
Do not regenerate the key for each release.
Publish a Windows update
To build and publish automatically, install GitHub CLI
and sign in once with gh auth login, using an account with write access to
bitti-ai/slopus. After updating the version as described below, commit the
release changes (including the Cargo lockfile and runtime DLL, if changed),
then push the matching tag. For example, for version 0.2.0:
git tag v0.2.0
git push origin v0.2.0
.\release.cmd --publish
The command checks that the working tree is clean, the remote tag points to the current commit, the repository is public, and the stable version is newer than all published stable releases. It then builds using the existing updater signing key and validates the manifest's version, URLs and signature contents against the local artifacts. The private key remains on the build machine.
Publishing creates a draft, uploads only this version's installers and portable
ZIP, then uploads latest.json. Signature files (.sig) stay local for manifest
validation; the updater reads the signatures embedded in latest.json.
After verifying that every
expected asset is uploaded with the correct size, it publishes the draft as the
latest stable release. This is when the existing updater endpoint begins serving
the new manifest. Release notes from UPDATE_NOTES_FILE appear in both the app
and the GitHub release. Installation still requires the user's action in the app.
If an upload fails, the release stays a draft and the previous latest release
remains available. Run release.cmd --publish again to rebuild and retry, or
node scripts/publish-release.mjs --publish to retry with the same artifacts.
Published versions are never overwritten. Automatic publishing supports the
single Windows architecture produced by release.cmd; prereleases and releases
combining architectures need a separate publishing workflow.
For a local build followed by manual publishing, use the existing steps:
- Set the same new version in
package.json,package-lock.json,src-tauri/Cargo.toml, andsrc-tauri/tauri.conf.json. Update the configured window title too. Cargo updates its lockfile during the build. - Update
RELEASE_NOTES.md, which supplies the release notes by default. Keep notes focused on release changes; omit Getting started and Known limitations sections. SetUPDATE_NOTES_FILEto use another UTF-8 text file instead. - Run
release.cmd. It builds signed installers, copies their.sigfiles, and writesartifacts/latest.jsonwith the version, signatures and download URLs. - Create a GitHub Release in
bitti-ai/slopuswith tagv<version>, matching the manifest URLs. Uploadlatest.json, the setup EXE, and the MSI if produced. Upload the portable ZIP as a separate download. Keep the.sigfiles local; their contents are already embedded inlatest.json. Publish the release as the latest stable release after all assets are present.
The app requests
https://github.com/bitti-ai/slopus/releases/latest/download/latest.json over
HTTPS and verifies each installer with the embedded public key. These assets
must be publicly downloadable; the app does not embed GitHub credentials. Until
the first release containing latest.json is published, checks will report an
error and leave the current app running.
The manifest generated by release.cmd covers the current Windows architecture
with NSIS/MSI-specific targets, and linux-x86_64 for the signed AppImage built
in WSL (see linux.md). The .deb and .rpm are published alongside but
are not updater targets: those installs open the releases page instead, like
portable Windows copies. When publishing more architectures or operating
systems, merge their platform entries into one latest.json before uploading it.
package.cmd still builds portable binaries without bundling, so it does not
need the signing key. Direct installer builds (npm run tauri -- build) require
TAURI_SIGNING_PRIVATE_KEY in the environment.
Before public distribution, test with two installed versions: publish the newer signed build, launch the older updater-enabled build, then check, install and verify the restarted version. A live upgrade cannot be tested until a newer release is hosted.
References: Tauri updater documentation, GitHub CLI release creation, publishing a draft.