Creative AI Briefing: Monday, September 7, 2026

Type "loud crackling campfire with crickets" into a pad on a 16-pad drum machine, hit the matching MIDI key, and the sample renders on your Mac's GPU in a couple of seconds, offline, with no account and nothing leaving the laptop. That app exists now, it is notarized, and the model weights are inside the download. It is one of half a dozen ports that landed in this window, and ports are the whole story: no frontier lab shipped anything for creators in the last 48 hours. What shipped instead is generative media being moved onto hardware people already own, by individuals who then wrote down every setting that breaks it. Some of those settings are not the defaults.

New models

Foundry is the most finished artifact of the window and it is not a model, it is a drum machine. It went up September 2 as a single 3.39 GB .dmg for Apple silicon, signed with a Developer ID and notarized with the ticket stapled, and it declares no network access after download. Sixteen pads, a text prompt field on each one, and each pad renders its own sample from stabilityai/stable-audio-3-small-sfx running locally at fp32 on MPS: eight steps, CFG 1.0, two seconds clamped between one and three.

The parts around the model are where the craft is. There is a morph pad that takes four corner prompts and blends them bilinearly. Per-pad editing covers waveform trim, pitch envelope, transient, warp, choke group, loop and latch. Tuning is not an afterthought either: 12-TET plus KORA PYTH 7, JUST 27 and PYTH 31, and it will load any .scl Scala file, with detected pitch shifted onto the scale degree. CoreMIDI in on notes 36 to 51, omni or filtered to one channel, velocity passed through. Export is 24-bit WAV per pad plus an Ableton .adg Drum Rack with a DrumCell per pad already mapped to its note.

One retry rule tells you the author actually used it: three attempts, triggered by a spectral-flatness floor of 0.55, which is a numeric way of saying "that came back as noise, do it again." The app's own source is MIT; the bundled weights carry the Stability AI Community License and the T5Gemma text encoder adds the Gemma Terms of Use, and both license texts ship inside the app bundle beside the weights (download and card, upstream model).

Stable Audio 3 in Apple's Core AI format is the substrate under that. On September 1 someone published .aimodel conversions of all three Stable Audio 3 tiers for iOS 27 and macOS 27, and the model card that came with them is the best piece of technical writing to cross this desk in a week. Each asset is a single .aimodel holding four named functions: conditioner, dit, a ladder of fixed-length decoder_N graphs and matching encoder_N graphs for audio-in, continuation and inpainting. The small SFX build is 2.9 GB, the medium is 9.8 GB, both float32.

Three settings in that card are labelled non-optional, and the reason to trust them is that each one is attached to a measurement. The sampler must be pingpong, because Euler on this flow model drives output to +7.8 dBFS and squeezes about 10 dB out of the gap between the loudest and quietest parts. You must generate at 256 latent frames, 23.8 seconds, or longer, because the model's own min_length is 256 and below it 16 to 27 percent of output energy lands above 10 kHz against roughly 1 percent for correct output. And eight steps at CFG 1.0, the family's own defaults. End-to-end fidelity against the PyTorch reference is cosine 0.999999981 at 74.1 dB SNR.

Then the part that explains the file sizes. Float16 crashes Apple's Neural Engine on these graphs, ANE inference operation failed, Code -19, retested on macOS 27.0 build 26A5416b, and you cannot route around it because allowed_compute_unit_kinds always includes the Neural Engine and has no setter. Shipping float32 sidesteps the bug precisely because the Neural Engine cannot execute float32 at all, so the work falls to the GPU by construction. That is a workaround written down as a workaround, which is rarer than it should be (SFX, medium, music).

Two things to know before you download. Both cards quote the same performance block, 2.21 seconds for 23.8 seconds of stereo and roughly 10.8 times realtime, and both quote the same memory guide "for the 2 B model," so the 0.6 B card is carrying the 2 B model's numbers and you should measure the small build yourself. And Stability gates stable-audio-3-small-sfx and stable-audio-3-medium behind a registration form on the Hub; these conversions are ungated. Redistribution with attribution is what the Community License allows, and the conversions do attribute correctly and ship both license files, but the practical effect is that the gate is now optional.

Image

FLUX.2 Klein 4B runs in a browser tab. The weights went up September 5 and the engine shipped the same day as an npm package. The transformer is hand-written WGSL on WebGPU; the distilled 0.6B text encoder and BFL's distilled VAE run through onnxruntime-web on the wasm backend. Two builds behind one entry point: desktop keeps an int8 transformer resident on the GPU at about 3.8 GB, and mobile streams int4 weights, group 64 asymmetric, from the origin private file system through a three-slot GPU ring, holding roughly 0.6 GB resident at a time. First visit downloads about 5 GB on desktop or 3.2 GB on a phone; a second visit starts in seconds because the files stay in OPFS and are validated against the Hub's ETag.

The reasoning in the package README is the useful part. ONNX stays on wasm on desktop because the page has one GPU budget, roughly 5 GB in Chrome, and the transformer already owns most of it. On iOS the whole tab is capped at 2 GB, ORT's WebGPU path measured slower than wasm threads and got the tab killed during decode, and a terminated Worker is the only way to hand a wasm heap back to the OS, which is why every ONNX job on mobile runs in a fresh one. Output size is bounded by the attention scores buffer, 24 heads by tokens squared at fp16, computed from the device's storage-binding limit, with iPhones capped at 512 by 512 on top of that. Parity against the f32-dequantized reference is rel-L2 around 1e-2. Four steps stock, or two with a separate 96 MB rank-64 LoRA applied at run time.

Code is MIT, weights carry the FLUX.2 Klein license, and there is a live hosted demo. Note one gap: a cache-busted shields.io read of github.com/radames/flux-klein.js returns "repo not found" and the GitHub API returns nothing, while the npm package the README points at is published and installable. You do not need the repo to use it (weights, demo, package).

Video

Quiet window, and worth saying plainly rather than padding. kinetic_cuts landed September 7 and is interesting for its cost rather than its output: a rank-16 MiniMax H3 LoRA trained with ai-toolkit on twelve clips of up to 1.62 seconds, 39 frames at 24 fps, cut from a single source video with a 10 percent edge crop, 380 steps, 41 minutes on one A100. Audio was in the training objective. The captioning discipline is the transferable bit: captions named only subjects, actions and on-screen words, so the look, the editing rhythm and the sound all bind to the trigger by exclusion. Load it with LoraLoaderModelOnly after the H3 model and its turbo LoRA at strength 1.0 (weights, trainer).

Yesterday's lead is still climbing: OpenVDN/vdn-minimax-h3 read 328 stars on a cache-busted shields.io check this morning against 291 yesterday and 261 on September 5.

A scanning warning, because the H3 mirror farms are getting worse. B4100/vh5tape-vhs-lora-minimax-h3 shows a September 5 creation date and is a copy of KennethFal/vh5tape-vhs-lora-minimax-h3, API createdAt August 31, now 51 likes and past 2,200 downloads. At least four bare MiniMax-H3 re-uploads appeared under different accounts in the same window. None of them are releases.

Audio and music

loudr-1-turbo arrived September 7 under a real Apache 2.0, and it is the most creator-shaped voice release in a while. Twenty-eight voice profiles across ten languages, and the roster records the source, licence and consent basis for every single one, built from recordings donated for speech technology or from CC0 and CC-BY corpora. No scraped celebrity voices ship with it. The turbo change is two speech tokens per forward instead of one, plus a renderer distilled to one pass instead of several, and the card says outright where you lose: naturalness on long, quiet or heavily punctuated passages, and audible sentence joins at the roughly ten-second window boundaries, "a little more so than loudr-1." Backends cover PyTorch, ONNX Runtime and Core ML from Python, Swift, Go, Rust and TypeScript; downloads run 0.72 GB for Torch up to 2.97 GB for Core ML with cloning. Lineage is Chatterbox (26k stars) by way of loudr-1. Saved WAVs carry unsigned C2PA Content Credentials by default recording model, voice, seed, backend and an audio hash (weights).

Kokoro-82M converted to Core ML with variable-length inputs went up September 6, and it solves a problem anyone doing narration timing has hit. Because it splits the model in two at exactly the point where Kokoro repeats each phoneme's features by its predicted frame count, the conversion returns a duration for every phoneme alongside the audio, from the same pass. That is word- and phoneme-accurate timing, which the card notes AVSpeechSynthesizer declares and does not report. Two packages, 36.0 MB and 114.3 MB, plus a 28.2 MB memory-mappable Voices.bin holding 54 voices as 510 style vectors each. On an M4 Pro, three seconds of audio in about 47 ms, roughly 63 times realtime, but only if you set compute units per model: the default placement runs the prosody half 5.6 times slower than the CPU alone, because a small BERT-and-LSTM graph over a few dozen tokens costs more to ship to another unit than to just do.

The calibration paragraph in that card should be standard practice. Spectral correlation against the PyTorch reference is 0.977; two runs of the reference itself score 0.998 because the vocoder adds random noise to unvoiced excitation; and a conversion carrying a known modulo bug scores 0.801 while still producing audio of the right length, envelope and word timing. In other words, a broken conversion sounds plausible, and 0.801 is what broken looks like. Apache 2.0, NOTICE lists the seven conversion changes (weights).

MOSS SoundEffect v2 also got a Core AI bundle, September 6, with a Swift CLI: 48 kHz mono, up to 30 seconds, three float16 .aimodel components. The author labels it experimental, reports 58.75 dB PSNR against the MLX reference and a 20-step latent cosine of 0.9988 after a stride correction, states that measured compute placement is the GPU and explicitly does not claim Neural Engine execution, and lists the blinded review as pending. Apache 2.0 all the way down (bundle, upstream, free demo).

Open and local

The pattern under all of it: this window's shipping was almost entirely conversion work, and conversion work is now where the honest measurements live. Star totals are cache-busted shields.io reads taken September 7.

• ostris/ai-toolkit: the trainer behind most community H3 LoRAs, including the 41-minute one above (12k) (repo)
• resemble-ai/chatterbox: the MIT voice-cloning base that loudr-1 and its turbo student descend from (26k) (repo)
• thewh1teagle/kokoro-onnx: source of the redistributed Kokoro voice vectors, and still the reference for running the model off Apple's stack (2.7k) (repo)
• OpenVDN/vdn-minimax-h3: hybrid-attention MiniMax H3, all four training stages open, 328 stars and climbing daily (repo)
• nunchaku-tech/nunchaku: the W4A4 kernel the four-bit image and video builds still dispatch to (3.9k) (repo)
• caguilar-dev/moss-soundeffect-coreai: conversion recipes, tests and the Swift runtime for the MOSS bundle, including a patch against Apple's BSD-3-Clause coreai-models runtime (0) (repo)

Creative workflows

1. Build a drum kit from text prompts and export it straight into Ableton. App at petalsfm/foundry. File: Foundry.dmg, 3,391,504,096 bytes, Apple silicon.

The steps. Install and open it; no account, no API key, no network. Write a prompt into a pad, one per sound: "tight room snare, close mic, short decay", "dusty vinyl kick". Render, then use the per-pad editor to trim the waveform, set the pitch envelope, shape the transient and assign a choke group so the open and closed hats cut each other. Pick a tuning if you want one, or drop in a .scl file. Play it from a controller over CoreMIDI on notes 36 to 51. Export the .adg Drum Rack and open it in Ableton with every pad already mapped to its note, or export 24-bit WAVs if you are going somewhere else.

How it works. Each pad is an independent eight-step Stable Audio 3 Small SFX generation at CFG 1.0, two seconds by default, rendered at fp32 on MPS with CPU fallback. The morph pad is the interesting one: four corner prompts, bilinearly blended, so you get a continuous field between "brushed" and "gated" instead of two takes. Repitch works by detecting the sample's pitch and shifting it onto the scale degree, which is why the tuning list is more than decoration. The render path uses OfflineAudioContext with the same buffer and FX graph as playback, so what you export is what you heard.

Why it is good. The whole loop from idea to a mapped drum rack happens on one machine with no per-generation cost and no upload, and the output is a normal sample you own the file of. Three retries on a spectral-flatness floor of 0.55 means the obvious failure, a pad that comes back as hiss, mostly resolves itself before you notice.

Where it breaks. Two seconds, clamped to a three-second maximum, so this is percussion and one-shots and nothing else. Apple silicon only. The Stability Community License terminates above one million dollars in annual revenue and asks you to register for commercial use, and the Gemma Terms of Use apply on top because of the bundled text encoder; installing the app is accepting both. And be aware that the model underneath is Stability's SFX tier, so tonal material is not what it was trained for.

2. Generate sound design on a Mac from the command line, with the settings that actually work. Assets at arraypress/stable-audio-3-small-sfx-coreai. Files: small-sfx.aimodel (2.9 GB), tokenizer/ (34 MB), example.py (self-contained, roughly 120 lines).

The steps. pip install coreai-torch tokenizers numpy, which brings the Core AI runtime and nothing else; no stable-audio-tools, no PyTorch. Then python3 example.py "loud crackling campfire with crickets" out.wav --seconds 24. To continue or repair existing audio, pass --init-audio in.wav --keep 12, which holds twelve seconds as context and regenerates everything after it from the prompt. Before you do anything at volume, precompile: xcrun coreai-build compile small-sfx.aimodel --platform macOS --preferred-compute gpu.

How it works. The DiT accepts any length; the encoder and decoder are compiled at fixed sizes, so the asset ships a ladder of decoder graphs and you pick the smallest one your clip fits. That matters more than it sounds: decoding the same 24 seconds costs 0.30 s and 0.5 GB through the 47.6 s graph but 2.38 s and 2.1 GB through the 380.4 s one. Classifier-free guidance is a host-side blend, v_cond + (cfg_scale - 1) * (v_cond - v_uncond), run by calling the DiT twice per step. The ping-pong sampler is four lines and they are printed in the card.

Why it is good. Twenty-four seconds of 44.1 kHz stereo in about 2.21 seconds on an M-series Mac, roughly twice as fast as the same model under MLX with 8-bit weights, and the audio-in path gives you continuation and inpainting rather than only text-to-audio. Every fidelity claim in the card comes with a number.

Where it breaks. Compile time on first load is brutal and grows fast: on the 2 B decoder, 23.8 seconds of audio compiles in 12 s, 47.6 s in 44 s, 95.1 s in 8.5 minutes, and 190.2 s in over an hour. Precompiling produces an .aimodelc that runs only on the architecture it was built for. Memory, not disk, is the real ceiling, roughly 7.7 GB fixed plus 0.32 GB per second of audio on the 2 B model, and the small model's card repeats that same figure without measuring it separately. You cannot generate shorter than 23.8 seconds and get clean output, so short cues mean generating long and trimming. And the reference implementation defaults to adaptive projected guidance, which this conversion does not implement, so a prompt tuned against the original at apg_scale=1.0 will not behave identically here.

Worth testing

• MOSS SoundEffect v2 in its official free Space, no install, the fastest way to judge whether text-to-foley is usable for your material before committing to a 30 GB local stack. Tradeoff: the hosted version is the PyTorch original, not the Core AI bundle, so it tells you about the model and nothing about the conversion (demo).
• FLUX.2 Klein in a browser tab, zero install, zero account, and it survives going offline after the first download. Tradeoff: about 5 GB of first-visit download on desktop or 3.2 GB on a phone, and iPhones are hard-capped at 512 by 512 (demo).
• Stable Audio 3 in Stability's own hosted Space if you want to compare the three tiers before choosing which one to convert. Tradeoff: the small SFX and medium repos are gated behind a registration form on the Hub even though the community conversions are not (demo).
• loudr-1-turbo against loudr-1 on your own text, which is what the card asks you to do rather than trusting its own summary. Tradeoff: turbo's join artifacts show up on exactly the long, quiet passages that narration work consists of, so a short test will flatter it (weights).

What actually matters from today's signal

The center of gravity moved. For three years the interesting work in creative AI was training, and the interesting artifact was a checkpoint. This window produced no checkpoint worth naming and five conversions worth reading, and the conversions are where the useful knowledge now is. A model card written by a lab tells you what the model can do. A conversion card written by somebody who spent a week fighting Apple's compiler tells you that fp16 crashes the Neural Engine with error code -19, that the default compute placement makes half of Kokoro 5.6 times slower, that a broken conversion scores 0.801 on spectral correlation while sounding fine, and that Euler on a flow model will clip your audio by 7.8 dB. None of that is in any lab's documentation, and all of it decides whether the thing works on your machine.

For a creator the practical shift is cost structure. A drum machine that renders its own samples, an image model in a browser tab, a narration voice with per-phoneme timing on a laptop: none of these bills per generation, none of them needs an account, and none of them sends your work anywhere. That changes what you are willing to iterate on. Nobody generates two hundred snare variations at a nickel apiece; everybody does it when it is free and the machine is right there.

The counter-signal is fragility, and it is worth naming. These are one-person ports of somebody else's weights, mostly with zero or one GitHub star, in some cases against an operating system that is itself new. The FLUX.2 Klein engine points at a GitHub repository that does not resolve. The Stable Audio conversion cards copy performance numbers between two models that differ by a factor of four in size. The MOSS bundle's own author says the blinded listening review is still pending. What makes this batch trustworthy is not that it is polished, it is that every one of these authors wrote down what they had not verified. Treat that as the standard. If a conversion card tells you only what works, you have not been told the part you need.

---

Source access notes: All dates are Hugging Face API createdAt values in UTC, never listing "Updated" timestamps. Three date traps caught and excluded: Poif1482/QIE-2511-Studio-DeLight appeared September 6 and is a mirror of prithivMLmods/QIE-2511-Studio-DeLight, createdAt January 28, 2026; B4100/vh5tape-vhs-lora-minimax-h3 appeared September 5 and mirrors an August 31 original; and the niobures account uploaded eight mirror repos inside twenty-six minutes on September 7, five MOSS models between 01:34 and 01:55 UTC and all three Stable Audio 3 tiers between 03:59 and 04:00, every one of them a copy of a May 2026 release. The Stable Audio 3 and MOSS SoundEffect base models themselves date to May 2026, so they appear here only as the substrate for this window's conversions, never as new releases. blog.comfy.org is a JavaScript wall and was skipped. The GitHub trending page served a cached listing from 2018 and was discarded. The ComfyUI GitHub releases and tags API endpoints both returned responses over the fetch size limit. github.com/radames/flux-klein.js returns "repo not found" from a cache-busted shields.io read and nothing from the GitHub API, reported above as a finding; the npm registry entry for the same package is live and complete. Bucket A was quiet on creative work: OpenAI's window was GPT-6 Astra and safety posts, Replicate last posted August 4 and fal August 27. Writing is omitted because nothing qualified. An adversarial fact-check subagent ran against this draft and caught one substantive error: an earlier version said the niobures account mirrored Stable Audio 3 and two MOSS models on September 7, when the API shows eight mirror repos created in a single twenty-six-minute batch. It also flagged that the vh5tape download counter had moved past 2,200 since the research pass, which the video section now reflects. Every other load-bearing figure, date, quotation and star count in this briefing survived the pass unchanged, including the identical performance blocks across two differently sized Stable Audio 3 conversion cards and the gated-upstream against ungated-conversion split.