aiserver-sd-bundles

AutoDroid Studio — Stable Diffusion bundles for Snapdragon NPUs

Stable Diffusion compiled ahead of time for the Qualcomm Hexagon NPU, in the format AutoDroid Studio loads directly. Generation runs entirely on the phone.

These are not general-purpose checkpoints. Each is a set of QAIRT context binaries compiled for one Hexagon version at one fixed resolution, plus two small CPU graphs and a tokenizer. They are useful only to an app that speaks this format.

Bundles

Openjourney needs its trigger token mdjrny-v4 style at the start of the prompt; without it you get plain SD 1.5.

Waifu Diffusion 1.3 reads booru tags rather than sentences: 1girl, solo, smile, brown hair, shoulder-length hair, upper body, looking at viewer. It was chosen because its rights chain is clean: its team fine-tuned it from Stable Diffusion 1.4 on 680k anime images in October 2022, before the NovelAI leak most SD 1.5 anime checkpoints descend from. Calibrated with booru-tag prompts (tools/sd/anime_prompts.txt); SHA-256 of the zip ac3b7b2a9a02a99da060ad8f8e93fa42e7a7f47eb21e3b9f46fa6bdd88f2c7e7.

AniPlus v1 is soft-painted, realistically lit anime (2.5D). It takes the same booru tags plus its own semirealistic tag; leave "photo, realistic" out of the negative prompt, which fights the style. Its card names its ingredients: Stable Diffusion 1.5, Waifu Diffusion 1.3, TrinArt Characters v1 (trained by Bit192 for the AI Novelist service, unrelated to NovelAI) and the author's own Dreambooth models. Calibrated with tools/sd/anime_semi_prompts.txt; SHA-256 of the zip 0a58283df033650c5ca39fa1d76aa9038c957e4d1addf9ffa8d3ef05a5f83a91.

The two -inpaint bundles redraw part of a picture with the rest of it in view. Their UNet takes 9 input channels (noisy latent, mask, latent of the masked picture) where the others take 4, which bundle.json records as "unetInChannels": 9, "inpaint": true. A 4-channel UNet only sees noise inside the mask, so a replaced garment or a filled-in hole cannot follow what surrounds it; these can. The app's avatar preset loads <model>-inpaint for every edit when the phone has it. dreamshaper-8-inpaint is compiled from Lykon's own dreamshaper-8-inpainting. absolute-reality-inpaint has no upstream inpainting checkpoint, so it is made by "add difference" (tools/sd/make_inpaint_model.py): the UNet of stable-diffusion-inpainting plus (AbsoluteReality 1.81 − SD 1.5), with AbsoluteReality's own text encoder and VAE. Both were calibrated on inpainting samples (8 prompts, make_calibration.py in inpainting mode) and used on an 8 Gen 1 for outfit changes and restyles before being published. SHA-256 of the zips: b5fd9a8bfc173550b5825ca12a230f6b0ada2e2e29add33e736a56b9e499b586 (absolute-reality-inpaint), 1455d62b77ad7016964d61c19f3b3f27529d58f5317cf96400621ec8c983c606 (dreamshaper-8-inpaint).

Precision: w8a16: 8-bit weights (per-channel) and 16-bit activations. That is what makes the output look like the checkpoint. Classifier-free guidance multiplies the difference between the conditional and unconditional predictions by 7.5, and that difference is only a few percent of the prediction, so any larger error drowns the prompt. Measured against the float UNet, this build is within 0.85% of it. An 8-bit-activation build of the same checkpoint was 8.3% out and produced noisy, over-saturated images. The price is time: about 50 s for 20 steps at 512×512 on an 8 Gen 1, against 17 s for w8a8.

Every bundle here was loaded and used to generate on real hardware, an 8 Gen 1 (Hexagon v69), before being published, and its UNet was checked against the float model on that phone. The v68 binaries are what a Snapdragon 888 loads; this w8a16 build has not itself been run on an 888 yet (the earlier w8a8 build was).

v68 and newer means Snapdragon 888 (SM8350) onward. A context binary runs forwards but never backwards, so a v68 build works on 8 Gen 1/2/3 and Elite as well; it simply does not use their newer instructions.

What is inside

bundle.json            the manifest: resolution, layout, licence, which graph is which
unet.bin               QAIRT context binary, NHWC, w8a16         — Hexagon NPU
vae_decoder.bin        QAIRT context binary                      — Hexagon NPU
vae_encoder.bin        QAIRT context binary (enables img2img)    — Hexagon NPU
text_encoder.tflite    CLIP, fp16                                — CPU
time_embed.tflite      timestep embedding, fp16                  — CPU
tokenizer/             vocab.json + merges.txt (standard CLIP BPE)

Two graphs stay on the CPU deliberately. Quantised to 8 bits, CLIP collapses into a constant function — every prompt produces the same image, with nothing raised anywhere. The timestep embedding multiplies its input by frequencies spanning four orders of magnitude before the sin/cos, which no per-tensor scale covers. Both are cheap: they run once or twice per image, against twenty to forty NPU steps.

LivePortrait (avatar animation)

liveportrait/ holds the two graphs of LivePortrait's generator that AutoDroid Studio builds itself, for the avatar site preset's moving faces (idle sway, blink, talking mouth). They are QAIRT 2.32 context binaries for Hexagon v68 and newer, w8a16.

The generator is split around the CPU: the 3D grid_sample warp between the two graphs runs in the app, and so does the occlusion map (a 7x7 conv with one output channel over 2272 inputs took 3.3 s on the HTP, and padding it hung the NPU; as 49 taps summed on the CPU it is 0.26 s). The feature and motion extractors and the retargeting MLPs come from facefusion-mobile-models. Measured on an 8 Gen 1: about 1.5 s a frame, a 33-frame loop per mood in under a minute; against the float model, 38.5 dB (motion net) and 49.9 dB (decoder).

Licence: MIT, from LivePortrait's own weights (warping_module.pth, spade_generator.pth; Copyright (c) 2024 Kuaishou Visual Generation and Interactive Center). The CreativeML Open RAIL-M terms below apply to the Stable Diffusion bundles, not to these files. The build scripts are in the app's repository under tools/liveportrait/.

Licence

The code that runs these is one question; the weights are another.

Every bundle here is a derivative of a Stable Diffusion 1.x checkpoint, and each of those is licensed CreativeML Open RAIL-M — base SD 1.5, AbsoluteReality 1.81, DreamShaper 8, Openjourney, Waifu Diffusion 1.3 (from SD 1.4), AniPlus v1, DreamShaper 8 inpainting and SD 1.5 inpainting (the input to absolute-reality-inpaint) alike. Each carries its upstream checkpoint's licence, not this repository's; follow the links in the table above for the originals.

That licence permits commercial use, and it comes with conditions that travel with the weights:

• You must pass the licence on. Anyone who receives these files, or a derivative of them, must receive the same use restrictions.
• The Attachment A use restrictions apply, and they are not optional. In summary, the model may not be used to break the law, to exploit or harm minors, to generate or disseminate verifiably false information with intent to harm, to generate personal identifiable information with intent to harm, to defame or harass, for fully automated legal/medical/credit decisions about individuals, to discriminate against individuals or groups protected by law, or to exploit the vulnerabilities of a specific group. Read Attachment A in full — the summary is not the licence.
• The licence disclaims warranty. These are quantised approximations of the original weights and are lower fidelity than the source checkpoint.

The QAIRT compiler that produced the context binaries is Qualcomm's; the tooling that drives it, the sampler, the tokenizer and the runtime are AutoDroid Studio's own and carry that project's licence. Nothing here derives from a non-commercially-licensed runtime.

Building your own

The toolchain is in the app's repository under tools/sd/, and docs/sd_bundles.md documents it, including which checkpoints are suitable and which are not. In short:

B=~/my-bundle
python tools/sd/fetch_qairt_host.py 2.32.0.250228      # the compiler, ~230 MB
tools/sd/build_sd_bundle.sh --release --export \
    --model <hf repo id> --licence "<its licence>" --out $B --resolution 512 --keep-onnx
python tools/sd/make_calibration.py --model <hf repo id> --out $B
tools/sd/build_sd_bundle.sh --release --compile --out $B --soc sm8350 --keep-onnx \
    --qairt ~/qairt/2.32.0.250228
tools/sd/make_text_encoder_tflite.sh --out $B --graph time_embed
tools/sd/make_text_encoder_tflite.sh --out $B --graph text_encoder
python tools/sd/package_bundle.py --out $B --name my-bundle --arch v68

Only compile checkpoints whose terms permit it, and record the actual licence with --licence: it is written into bundle.json and shown to the user in the app.