Upload folder using huggingface_hub

.gitattributes

@@ -45,3 +45,11 @@ vae_encoder.mnn filter=lfs diff=lfs merge=lfs -text
 text_encoder/visual.mnn.weight filter=lfs diff=lfs merge=lfs -text
 dit_turbo.mnn filter=lfs diff=lfs merge=lfs -text
 dit_turbo.mnn.weight filter=lfs diff=lfs merge=lfs -text
+samples/sample_coffee_shop.png filter=lfs diff=lfs merge=lfs -text
+samples/sample_fisherman_448x576.png filter=lfs diff=lfs merge=lfs -text
+samples/turbo_edit_office.png filter=lfs diff=lfs merge=lfs -text
+samples/turbo_edit_seifuku.png filter=lfs diff=lfs merge=lfs -text
+samples/turbo_edit_yukata.png filter=lfs diff=lfs merge=lfs -text
+samples/turbo_t2i_harajuku.png filter=lfs diff=lfs merge=lfs -text
+samples/turbo_t2i_kimono.png filter=lfs diff=lfs merge=lfs -text
+samples/turbo_t2i_studio.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -20,31 +20,84 @@ tags:
 [Qwen/Qwen-Image-2.1](https://huggingface.co/Qwen/Qwen-Image-2.1) converted to [MNN](https://github.com/alibaba/MNN)
 for on-device **text-to-image and image editing** on Android, with the OpenCL GPU running the DiT. Any size with sides
 a multiple of 32 works, from 256×256 up; the app offers 7 aspect ratios at three pixel budgets (~512², ~384², ~320²),
-e.g. 512×512, 576×448, 672×384, 480×320, 384×288.
+e.g. 512×512, 576×448, 672×384, 480×320, 384×288. An optional **Turbo** LoRA (`dit_turbo.mnn`) cuts a run from
+20–40 steps to a fixed 6.
 
 Runtime, Android library and demo app: **[github.com/scsonic/libQwenImage21](https://github.com/scsonic/libQwenImage21)**
 
+<p>
+<img src="samples/sample_coffee_shop.png" width="24%"/>
+<img src="samples/sample_fisherman_448x576.png" width="19%"/>
+<img src="samples/turbo_t2i_kimono.png" width="19%"/>
+<img src="samples/turbo_edit_yukata.png" width="19%"/>
+<img src="samples/turbo_edit_office.png" width="19%"/>
+</p>
+
+*Left two: base model, 20 steps. Right three: Turbo, 6 steps — a text-to-image portrait, then two edits of it (same
+face, new outfit and background). All generated on a phone; see [Turbo (6-step)](#turbo-6-step) below for the rest
+of the set and per-run timings.*
+
 | Tested on | Snapdragon 8 Gen 2 (Adreno 740), 16 GB RAM, Android 13 |
 |---|---|
 | Text to image, 448×576, 20 steps | 451 s total (DiT 19.1 s/step on OpenCL fp16) |
 | Image edit, 352×448, 20 steps | 348 s total (DiT 12.6 s/step) |
+| Text to image, 512×512, **Turbo 6 steps** | ~216–235 s total (DiT ~22 s/step) |
+| Image edit, 352×448, **Turbo 6 steps** | ~196–200 s total |
 
 ## Files
 
 | Path | What | Size |
 |---|---|---|
 | `dit.mnn` + `.weight` | 7B single-stream DiT (32 blocks + norm_out/proj_out). Block linears int4 (block 32), small layers int8 | 4.5 GB |
+| `dit_turbo.mnn` + `.weight` | Same DiT with the [Viggle-turbo](https://huggingface.co/Viggle/Qwen-Image-2.1-viggle-turbo) LoRA applied unmerged (a small extra fp16 branch per targeted layer); fixed 6-step schedule. Optional — see [below](#turbo-6-step) | 5.2 GB |
 | `txt_in.mnn`, `img_in.mnn` | text (int8) / latent (fp16) input projections | 36 MB |
 | `vae_decoder.mnn` | VAE decoder, 64-ch latent → RGBA, fp16 weights, dynamic size | 0.5 GB |
 | `vae_encoder.mnn` | VAE encoder for image editing, RGBA → normalized 64-ch latent, fp16 | 0.16 GB |
 | `text_encoder/` | Qwen3-VL-8B-Instruct, MNN int4 (from [taobao-mnn/Qwen3-VL-8B-Instruct-MNN](https://huggingface.co/taobao-mnn/Qwen3-VL-8B-Instruct-MNN)). `te_config.json` runs it text-only; `te_vl_config.json` adds the vision tower (`visual.mnn`) for image editing. Both return the last decoder layer before the final norm | 5.4 GB |
 
-Download:
+Download everything (~15.5 GB with Turbo) or skip `dit_turbo.mnn*` to save 5.2 GB:
 
 ```bash
-hf download evankuo/Qwen-Image-2.1-MNN --local-dir qwen_image21
+hf download evankuo/Qwen-Image-2.1-MNN --local-dir qwen_image21                          # + Turbo
+hf download evankuo/Qwen-Image-2.1-MNN --local-dir qwen_image21 --exclude "dit_turbo.mnn*"  # base model only
 ```
 
+## Turbo (6-step)
+
+[Viggle-turbo](https://huggingface.co/Viggle/Qwen-Image-2.1-viggle-turbo) distills Qwen-Image-2.1 to a fixed
+6-step schedule with no CFG. `dit_turbo.mnn` applies it **unmerged**, the way diffusers and the LoRA's own
+ComfyUI node do: the int4 base weights are untouched (identical to `dit.mnn`'s), and the LoRA's rank-128
+correction is added as a small extra fp16 branch per targeted layer, exported as its own MNN model file that
+happens to carry a second copy of the base weights (MNN has no format for patching an already-compiled graph).
+Merging the correction into the weights instead — especially into int4 — is what the LoRA's own README
+specifically measures as lossy; unmerged is the accurate path. `txt_in.mnn`, `img_in.mnn`, both VAE models and
+the text encoder are unaffected and shared with the base pipeline.
+
+<p>
+<img src="samples/turbo_t2i_studio.png" width="19%"/>
+<img src="samples/turbo_t2i_kimono.png" width="19%"/>
+<img src="samples/turbo_t2i_harajuku.png" width="19%"/>
+<img src="samples/turbo_edit_seifuku.png" width="19%"/>
+<img src="samples/turbo_edit_yukata.png" width="19%"/>
+</p>
+
+*Text-to-image (studio portrait, kimono, Harajuku street fashion) and two edits of the studio portrait — same
+face, new outfit and setting. All on a Snapdragon 8 Gen 2, OpenCL, 6 steps.*
+
+| | text encoder (+ prefix) | DiT (6 steps) | VAE | total |
+|---|---|---|---|---|
+| Text to image, 448×576–512×512 | ~15 s | 6 × ~22 s ≈ 134 s | ~18 s | **216–235 s** |
+| Image edit → 352×448 | ~20–80 s (with vision; P≈680) | 6 × ~18 s ≈ 108 s | ~13 s | **196–200 s** |
+
+A Turbo DiT step (~22 s at ~512²) is slower than a base-model step at the same size (~19 s) — the extra fp16
+branch costs roughly the 10–25% diffusers/ComfyUI themselves measure — but 6 steps instead of 20 still roughly
+halves the total time for both modes. Base model at 6 steps *without* the LoRA is visibly worse (soft, muddy) —
+the schedule alone isn't what's doing the work.
+
+Load it like the base model, just with `dit_turbo.mnn` instead of `dit.mnn`; the demo app has a **Turbo LoRA**
+checkbox that fixes the step count to 6. See the [runtime repo](https://github.com/scsonic/libQwenImage21/blob/main/docs/TURBO.md)
+for the CLI/library API.
+
 ## How it was made
 
 - **DiT**: taken from the GGUF **Q4_K** build ([leejet/Qwen-Image-2.1-GGUF](https://huggingface.co/leejet/Qwen-Image-2.1-GGUF)).
@@ -61,6 +114,7 @@ hf download evankuo/Qwen-Image-2.1-MNN --local-dir qwen_image21
 
 > **2026-09-23:** `dit.mnn` / `dit.mnn.weight` were re-exported for that per-layer K/V cache. Older copies do not load
 > with the current runtime — re-download both files.
+> **2026-09-25:** added `dit_turbo.mnn` / `.weight` (optional, see [Turbo](#turbo-6-step) above).
 
 Conversion scripts: `export/` in the GitHub repo.
 
@@ -68,3 +122,5 @@ Conversion scripts: `export/` in the GitHub repo.
 
 Derived from Qwen-Image-2.1 and released under the **Qwen Research License Agreement** (see `LICENSE`), i.e. for
 research / non-commercial use under its terms. The text encoder weights come from Qwen3-VL-8B-Instruct (Apache-2.0).
+The Turbo LoRA is a derivative of the same base model, released by Viggle under the same Qwen Research License
+Agreement.