sloppify 🫠

All the algorithm, none of the artists.

"Why license music when you can hallucinate it for free?" — sloppify Engineering Blog, Issue 1

sloppify is a Spotify-inspired desktop music player with a catalog of exactly zero real songs. Every track is synthesized on demand by an LLM writing Strudel pattern code, and rendered live via the Web Audio engine inside its own app window. There is no audio file anywhere in this repository, because there is no audio — there is only vibes, JSON, and a JavaScript live-coding runtime doing its best.

By default it runs entirely on your machine against Ollama — no API key, no cloud, no bill. Point it at OpenAI, Anthropic, or any OpenAI-compatible endpoint instead if you'd rather pay for your slop.

sloppify ships as a portable desktop app: download one file, run it, no installer, no admin prompt, nothing written outside your user folder.

Key differentiators:

• Zero licensed music — 100% model-native audio synthesis, disclosed and on purpose
• Multi-provider intelligence substrate — Ollama by default, OpenAI/Anthropic/any-OpenAI-compatible-endpoint on request
• Local-first: works fully offline once a model is pulled
• Ships as a single portable executable for Linux (AppImage), Windows (portable .exe), and macOS (.app in a .zip) — no install wizard, no package manager, no admin rights
• Zero build step for development — no bundler, no native modules, npm install finishes in seconds
• Graceful degradation: if the model writes broken Strudel, sloppify quietly swaps in a hand-tuned backup pattern rather than playing silence
• Spotify-shaped UI: sidebar, library, generator, now-playing bar — all serving music that has never been heard by a human before it reached your speakers

How it works

1. You describe a vibe ("anxious dubstep for a Monday standup that could have been an email") or pick an invented genre chip (Corporate Lo-Fi, Blockchain Ambient, Onboarding Chillhop, ...).
2. sloppify sends a prompt to your configured LLM asking for a title, artist, genre, BPM, and one Strudel pattern expression.
3. The server sanity-checks the returned code (JSON parses, no dangerous JS APIs) and saves the track to your local library at ~/.sloppify/library.json.
4. Your browser loads @strudel/web plus a drum/instrument sample pack (tidalcycles/dirt-samples) and evaluates the pattern live via the Web Audio API — that's the actual "song." Both are fetched from their CDN/GitHub on first launch and cached by the browser after that, so the app needs internet access at least once even when the LLM itself is fully local.
5. If the model's code fails to evaluate (small local models occasionally write invalid Strudel), the browser sends the real error message straight back to the LLM and asks it to fix its own mistake — self-correction, not just a shrug. If that fix also fails, only then does the frontend fall back to one of a few known-good local patterns, so playback never just... stops. A successful self-correction is saved back to the track automatically, so it's actually fixed for next time, not just patched for one play.

The prompt also explicitly asks for music that's genuinely worth listening to — layered drums/bass/melody, movement over time, real chord/scale usage — not just the smallest pattern that technically satisfies the schema. The comedy is meant to live entirely in the branding (titles, artists, genres), not in the audio being deliberately bad.

Every saved track can also be hand-edited — click the ✏️ on a track card to rewrite its title, artist, genre, BPM, or the raw Strudel code yourself, or send it back to the model with a free-text instruction ("add a bassline," "double the tempo") and review its suggestion before committing. It's live-coding software; touching up the model's homework is the normal workflow, not an escape hatch. All of this — generation, self-correction, and hand-edits — goes through the same safety check before anything is saved.

Strudel itself is a separate open-source project (AGPL-3.0) loaded at runtime from its CDN bundle, not vendored into this repo — see strudel.cc and the Strudel repo for details and credit.

Requirements

• For the default local provider: Ollama installed and running, with a model pulled:

  ollama pull qwen2.5-coder:7b

  Any Ollama model works; code-tuned models tend to write more valid Strudel patterns.
• For a cloud provider instead: an API key for OpenAI, Anthropic, or whatever OpenAI-compatible endpoint you point custom at.

That's it for running a pre-built app — it bundles its own runtime and browser engine, nothing else to install. Building from source additionally requires Node.js 18+.

Run the app

Option A: download a portable build (no install)

Grab the file for your OS from the project's Releases page (or build one yourself, see below) and run it directly:

OS	File	How to run
Linux	sloppify-<version>-linux-x64.AppImage	chmod +x sloppify-*.AppImage && ./sloppify-*.AppImage
Windows	sloppify-<version>-win-x64.exe	Double-click. It's a portable exe — nothing is installed, no admin prompt.
macOS	sloppify-<version>-mac-x64.zip	Unzip, then open sloppify.app. First launch: right-click → Open to bypass Gatekeeper's unsigned-app warning (the build isn't notarized/code-signed — see below).

No Node.js needed for this path. sloppify still talks to Ollama (or whatever provider you configure) over plain HTTP, so Ollama itself is a separate install either way.

Option B: run from source

git clone <this-repo>
cd sloppify
npm install
npm run electron

This launches the same desktop app straight from source, useful for development.

If you'd rather run it headless (e.g. on a server, or in a browser tab instead of a native window), npm start still boots the plain Express server without Electron — open http://localhost:7777.

Building your own portable executable

npm run dist:linux   # -> dist/sloppify-*.AppImage
npm run dist:win     # -> dist/sloppify-*.exe   (portable, no installer)
npm run dist:mac     # -> dist/sloppify-*.zip   (contains sloppify.app)
npm run dist         # -> build for the current OS

Cross-compiling for macOS generally requires running on macOS (Apple's tooling isn't available on Linux/Windows CI). These builds aren't code-signed or notarized (that requires a paid Apple/Microsoft certificate), so macOS Gatekeeper and Windows SmartScreen will both flag an unfamiliar-publisher warning on first run — expected for a self-built app, not a sign of corruption.

Config and your generated library live outside the repo/app bundle, at:

OS	Path
Linux	~/.sloppify/
macOS	~/.sloppify/
Windows	C:\Users\<you>\.sloppify\

Delete that folder to reset everything back to the seed library and default (Ollama) settings.

Switching LLM providers

Open ⚙️ Settings in the app, or edit ~/.sloppify/config.json directly (see config.example.json for the full shape). Ollama is the default and requires no key:

{
  "provider": "ollama",
  "providers": {
    "ollama": { "baseUrl": "http://localhost:11434", "model": "qwen2.5-coder:7b" }
  }
}

To use an external LLM instead, switch provider (or the Settings dropdown) to openai, anthropic, or custom and fill in baseUrl, model, and apiKey. custom accepts any OpenAI-compatible chat-completions endpoint (LM Studio, vLLM, OpenRouter, etc.) — same shape as the openai provider, just pointed elsewhere.

API keys are stored in plaintext in ~/.sloppify/config.json on your own machine, the same way most local dev tools handle them. Don't commit that file (it already lives outside the repo, but the same caution applies if you copy it elsewhere).

A note on the generated code

Strudel's live-coding model means the LLM's code field is arbitrary JavaScript, executed in your browser via Strudel's evaluate() — that's the entire point of Strudel, and it's the same trust model as pasting code into the official Strudel REPL. The server blocks an obvious denylist of dangerous APIs (fetch, document, localStorage, eval, etc.) before anything reaches the browser, but this is a courtesy filter, not a sandbox. Only point sloppify at LLM providers and models you trust — which, running against your own local Ollama, is presumably the whole appeal.

Roadmap

• "Slop Radio" — auto-generate and queue an endless stream of tracks
• Shareable pattern links
• AI-generated fake liner notes and press quotes per track
• Genre-mixing ("give me Corporate Lo-Fi and Blockchain Ambient, fight to the death")

Contributing

See CONTRIBUTING.md.

License

MIT — see LICENSE. Strudel itself is AGPL-3.0-licensed and used here only as an unmodified runtime dependency loaded from its CDN; see the Strudel project for its own license terms.