RGBA-Image-2.1-Turbo Core AI port: bf16 + int8 DiT, text encoder, VAE x3 (debug locations stripped), host/, tokenizer/, card

.gitattributes

@@ -33,3 +33,16 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+host/rope_axis0_cos.f32 filter=lfs diff=lfs merge=lfs -text
+host/rope_axis0_sin.f32 filter=lfs diff=lfs merge=lfs -text
+host/rope_axis1_cos.f32 filter=lfs diff=lfs merge=lfs -text
+host/rope_axis1_sin.f32 filter=lfs diff=lfs merge=lfs -text
+host/rope_axis2_cos.f32 filter=lfs diff=lfs merge=lfs -text
+host/rope_axis2_sin.f32 filter=lfs diff=lfs merge=lfs -text
+qi21_encoder_dynL_w16a32_ids_iofp32.aimodel/main.mlirb filter=lfs diff=lfs merge=lfs -text
+qi21_vae_1024_fp32.aimodel/main.mlirb filter=lfs diff=lfs merge=lfs -text
+qi21_vae_256_fp32.aimodel/main.mlirb filter=lfs diff=lfs merge=lfs -text
+qi21_vae_512_fp32.aimodel/main.mlirb filter=lfs diff=lfs merge=lfs -text
+qi21t_dit_full_bf16_dyn_iofp32.aimodel/main.mlirb filter=lfs diff=lfs merge=lfs -text
+qi21t_dit_full_int8lin_dyn_iofp32.aimodel/main.mlirb filter=lfs diff=lfs merge=lfs -text
+tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,55 @@
+Qwen RESEARCH LICENSE AGREEMENT
+
+Qwen RESEARCH LICENSE AGREEMENT Release Date: September 20, 2026
+
+By clicking to agree or by using or distributing any portion or element of the Qwen Materials, you will be deemed to have recognized and accepted the content of this Agreement, which is effective immediately.
+
+1. Definitions
+    a. This Qwen RESEARCH LICENSE AGREEMENT (this "Agreement") shall mean the terms and conditions for use, reproduction, distribution and modification of the Materials as defined by this Agreement.
+    b. "We" (or "Us") shall mean Hangzhou Tongyi Laboratory Technology Co., Ltd.
+    c. "You" (or "Your") shall mean a natural person or legal entity exercising the rights granted by this Agreement and/or using the Materials for any purpose and in any field of use.
+    d. "Third Parties" shall mean individuals or legal entities that are not under common control with us or you.
+    e. "Qwen" shall mean the large language models, diffusion models, and software and algorithms, consisting of trained model weights, parameters (including optimizer states), machine-learning model code, inference-enabling code, training-enabling code, fine-tuning enabling code and other elements of the foregoing distributed by us.
+    f. "Materials" shall mean, collectively, our proprietary Qwen and Documentation (and any portion thereof) made available under this Agreement.
+    g. "Source" form shall mean the preferred form for making modifications, including but not limited to model source code, documentation source, and configuration files.
+    h. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+    i. "Non-Commercial" shall mean for research or evaluation purposes only.
+
+2. Grant of Rights
+    a. You are granted a non-exclusive, worldwide, non-transferable and royalty-free limited license under our intellectual property or other rights owned by us embodied in the Materials to use, reproduce, distribute, copy, create derivative works of, and make modifications to the Materials FOR NON-COMMERCIAL PURPOSES ONLY. 
+    b. You shall not use the Materials for any commercial purpose without obtaining a separate commercial license from us. If you wish to use the Materials commercially, you shall request a license from us at model-business@notice.qwencloud.com.
+
+3. Redistribution
+Subject to Section 2 (Grant of Rights), you may distribute copies or make the Materials, or derivative works thereof, available as part of a product or service that contains any of them, with or without modifications, and in Source or Object form, provided that you meet the following conditions:
+    a. You shall give any other recipients of the Materials or derivative works a copy of this Agreement;
+    b. You shall cause any modified files to carry prominent notices stating that you changed the files;
+    c. You shall retain in all copies of the Materials that you distribute the following attribution notices within a "Notice" text file distributed as a part of such copies: "Qwen is licensed under the Qwen RESEARCH LICENSE AGREEMENT, Copyright (c) 2026 Hangzhou Tongyi Laboratory Technology Co., Ltd. All Rights Reserved."; and
+    d. You may add your own copyright statement to your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of your modifications, or for any such derivative works as a whole, provided your use, reproduction, and distribution of the work otherwise complies with the terms and conditions of this Agreement.
+
+4. Rules of use
+    a. The Materials may be subject to export controls or restrictions in China, the United States or other countries or regions. You shall comply with applicable laws and regulations in your use of the Materials.
+    b. If you use the Materials or any outputs or results therefrom to create, train, fine-tune, or improve an AI model that is distributed or made available, you shall prominently display “Built with Qwen” or “Improved using Qwen” in the related product documentation.
+    c. You shall not use "Qwen" as the primary name or identifier of any derivative works or products; reasonable descriptive use (e.g., "fine-tuned from Qwen Image") is permitted.
+
+5. Intellectual Property
+    a. We retain ownership of all intellectual property rights in and to the Materials and derivatives made by or for us. Conditioned upon compliance with the terms and conditions of this Agreement, with respect to any derivative works and modifications of the Materials that are made by you, you are and will be the owner of such derivative works and modifications.
+    b. No trademark license is granted to use the trade names, trademarks, service marks, or product names of us, except as required to fulfill notice requirements under this Agreement or as required for reasonable and customary use in describing and redistributing the Materials.
+    c. If you commence a lawsuit or other proceedings (including a cross-claim or counterclaim in a lawsuit) against us or any entity alleging that the Materials or any output therefrom, or any part of the foregoing, infringe any intellectual property or other right owned or licensable by you, then all licenses granted to you under this Agreement shall terminate as of the date such lawsuit or other proceeding is commenced or brought.
+
+6. Disclaimer of Warranty and Limitation of Liability
+    a. We are not obligated to support, update, provide training for, or develop any further version of the Qwen Materials or to grant any license thereto.
+    b. THE MATERIALS ARE PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED WARRANTY OF ANY KIND INCLUDING WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, OR FITNESS FOR A PARTICULAR PURPOSE. WE MAKE NO WARRANTY AND ASSUME NO RESPONSIBILITY FOR THE SAFETY OR STABILITY OF THE MATERIALS AND ANY OUTPUT THEREFROM.
+    c. IN NO EVENT SHALL WE BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE MATERIALS OR ANY OUTPUT OF IT, NO MATTER HOW IT’S CAUSED.
+    d. You will defend, indemnify and hold harmless us from and against any claim by any third party arising out of or related to your use or distribution of the Materials.
+
+7. Survival and Termination.
+    a. The term of this Agreement shall commence upon your acceptance of this Agreement or access to the Materials and will continue in full force and effect until terminated in accordance with the terms and conditions herein.
+    b. We may terminate this Agreement if you breach any of the terms or conditions of this Agreement. Upon termination of this Agreement, you must delete and cease use of the Materials. Sections 6 and 8 shall survive the termination of this Agreement.
+
+8. Governing Law and Jurisdiction.
+    a. This Agreement and any dispute arising out of or relating to it will be governed by the laws of China, without regard to conflict of law principles, and the UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement.
+    b. The People's Courts in Hangzhou City shall have exclusive jurisdiction over any dispute arising out of this Agreement.
+
+9. Other Terms and Conditions.
+    a. Any arrangements, understandings, or agreements regarding the Material not stated herein are separate from and independent of the terms and conditions of this Agreement. You shall request a separate license from us, if you use the Materials in ways not expressly agreed to in this Agreement. 
+    b. We shall not be bound by any additional or different terms or conditions communicated by you unless expressly agreed.

NOTICE

@@ -0,0 +1,55 @@
+Qwen is licensed under the Qwen RESEARCH LICENSE AGREEMENT, Copyright (c) 2026 Hangzhou Tongyi Laboratory Technology Co., Ltd. All Rights Reserved.
+
+The model files in this repository were converted and re-authored into Apple Core AI .aimodel graphs
+from the Qwen-Image-2.1-Turbo weights (Qwen/Qwen-Image-2.1-Turbo, revision
+d65dbc9a7e8f6b5479e33dee6030eaab2a906509) and the Qwen-Image-2.1 weights (Qwen/Qwen-Image-2.1,
+revision 790c92633540aa0cb11d9abf19eb46d861714758). They were changed as follows.
+
+qi21t_dit_full_bf16_dyn_iofp32.aimodel — the diffusion transformer (from Qwen-Image-2.1-Turbo transformer/)
+  - Re-authored in plain PyTorch with the checkpoint's parameter names, then exported as one graph.
+  - Block-causal attention is computed as two scaled-dot-product-attention calls per block
+    (text tokens attend causally to text; image tokens attend to every token).
+  - Rotary position embeddings are applied as real-valued cos/sin pairs that the host supplies.
+  - The prefix key/value cache is removed: the text prefix is recomputed at every step.
+  - Weights and computation are bfloat16; every graph input and output is float32.
+  - Both sequence axes are dynamic (text 8-512 tokens, image 64-4096 tokens). Text-to-image only:
+    the graph has no condition-image input.
+  - The export-time debug locations (the conversion machine's source file paths) are stripped from
+    the graph file; the operations and the weights are untouched.
+
+qi21t_dit_full_int8lin_dyn_iofp32.aimodel — the same diffusion transformer, with int8 Linear weights
+  - The same graph as above, from the same weights.
+  - The 232 Linear weight matrices are stored as int8 (symmetric, -127..127, one bfloat16 scale per
+    block of 32 input features) and dequantized to bfloat16 inside the graph. The normalization
+    weights and all computation stay bfloat16.
+  - The export-time debug locations (the conversion machine's source file paths) are stripped from
+    the graph file; the operations and the weights are untouched.
+
+qi21_encoder_dynL_w16a32_ids_iofp32.aimodel — the text encoder (from Qwen-Image-2.1 text_encoder/)
+  - The text encoder of Qwen-Image-2.1-Turbo is byte-identical to that of Qwen-Image-2.1 (750 of 750
+    tensors). The graph is the one published in mlboydaisuke/RGBA-Image-2.1-CoreAI (revision
+    a9b5c9493571a8c4087dde0f4a191803feb0fd69), with its export-time debug locations (the conversion
+    machine's source file paths) stripped; the operations and the weights are untouched.
+  - Only the text path of the Qwen3-VL-8B encoder is kept. The vision tower, the language-model head
+    and the final RMSNorm are removed; the output is the residual stream after the last layer.
+  - Re-authored in plain PyTorch; the token embedding is inside the graph (int32 token ids in).
+  - Weights are stored in bfloat16 and all computation is float32; the output is float32.
+  - The sequence axis is dynamic (16-512 tokens).
+
+qi21_vae_256_fp32.aimodel, qi21_vae_512_fp32.aimodel, qi21_vae_1024_fp32.aimodel — the VAE (from Qwen-Image-2.1 vae/)
+  - The float32 VAE weights of Qwen-Image-2.1. The vae/ of Qwen-Image-2.1-Turbo holds the same
+    weights rounded to bfloat16. The graphs are the ones published in
+    mlboydaisuke/RGBA-Image-2.1-CoreAI (revision a9b5c9493571a8c4087dde0f4a191803feb0fd69), with
+    their export-time debug locations (the conversion machine's source file paths) stripped; the
+    operations and the weights are untouched.
+  - Decoder only, one frame; the VAE encoder is not included.
+  - The latent un-normalisation (latents * std + mean) and the token-to-grid unpacking are inside
+    the graph.
+  - One graph per output size (256x256, 512x512, 1024x1024), float32.
+
+Copied without changes from Qwen-Image-2.1-Turbo: LICENSE; config.json (= transformer/config.json);
+tokenizer/ (= processor/ tokenizer.json, tokenizer_config.json, processor_config.json,
+chat_template.jinja).
+
+Added by the conversion: host/ (rotary tables and the sampler constants, computed from the model
+definition and the checkpoint's sample_sigmas, and host_contract.md) and README.md.

README.md

@@ -0,0 +1,325 @@
+---
+license: other
+license_name: qwen-research
+license_link: LICENSE
+base_model: Qwen/Qwen-Image-2.1-Turbo
+pipeline_tag: text-to-image
+library_name: coreai
+tags:
+  - coreai
+  - rgba
+  - text-to-image
+  - apple-silicon
+---
+
+# RGBA-Image-2.1-Turbo — Core AI port of Qwen-Image-2.1-Turbo
+
+- **Built with Qwen.**
+- **Non-commercial use only** — Qwen Research License (research or evaluation purposes).
+- **macOS 27 on Apple silicon only.** Six Core AI bundles, 39.97 GB (37.22 GiB) in total; a run loads
+  five of them, 32.41 GB with the bf16 DiT or 25.73 GB with the int8 DiT.
+
+RGBA-Image-2.1-Turbo is [`Qwen/Qwen-Image-2.1-Turbo`](https://huggingface.co/Qwen/Qwen-Image-2.1-Turbo)
+(revision `d65dbc9`) converted to Core AI `.aimodel` graphs with coreai-torch 0.4.1 and coreai-core
+1.0.0b2. On an Apple M4 Max (macOS 27.0 26A428, measured 2026-10-11) the 7B DiT runs a 1024² step in
+4.72 s, so an 8-step image takes about 38 s of DiT time.
+
+A Qwen3-VL-8B text encoder (text path only) conditions a 7B single-stream DiT (32 blocks,
+block-causal attention). A 64-channel VAE decodes to four channels, RGBA. The sampler is the
+checkpoint's own: 8 FlowMatch Euler steps on a fixed sigma grid, no CFG. Ask for a transparent
+background in the prompt and the fourth channel is a real alpha.
+
+Sizes: 256², 512² and 1024², square. The DiT and the text encoder have dynamic axes (see Graph
+contracts); the VAE has one graph per size. The upstream 1:1 preset of 2048² needs 16,384 image
+tokens, outside this DiT's 64–4096-token axis.
+
+## What changed from RGBA-Image-2.1
+
+The graph code and the host code are those of
+[RGBA-Image-2.1](https://huggingface.co/mlboydaisuke/RGBA-Image-2.1-CoreAI). The differences, and why
+the rest is the same:
+
+- **Sampler.** 8 steps on the grid the checkpoint carries (`sample_sigmas` in its `model_index.json`:
+  1.0 … 0.414568), shift 1.0, no `μ`, no CFG. RGBA-Image-2.1 runs 40 steps on a shifted linspace.
+- **DiT.** Re-exported from the Turbo weights with the same exporter: 297 bf16 tensors with the
+  base checkpoint's names, shapes and dtypes. An int8 variant ships beside it.
+- **Text encoder.** The Turbo text encoder is byte-identical to the base one (750 of 750 tensors).
+  This repo carries RGBA-Image-2.1's encoder graph. Its export-time debug locations are stripped, so
+  the file differs from RGBA-Image-2.1's by that alone.
+- **VAE.** The Turbo `vae/` is the base fp32 VAE rounded to bf16 (238 of 238 tensors). This repo
+  carries RGBA-Image-2.1's fp32 VAE graphs. Their export-time debug locations are stripped, so the
+  files differ from RGBA-Image-2.1's by that alone. Their decode differs from the Turbo pipeline's by
+  the rounding band in Measured.
+
+The Turbo DiT is a distilled checkpoint. On the same noise and prompt, the fp32 Turbo pipeline's
+8-step image and the fp32 base pipeline's 40-step image are 21.75 dB (256²) and 23.35 dB (512²)
+apart (white-composited RGB PSNR).
+
+## Bundle
+
+[🤗 mlboydaisuke/RGBA-Image-2.1-Turbo-CoreAI](https://huggingface.co/mlboydaisuke/RGBA-Image-2.1-Turbo-CoreAI)
+
+| file | what it is | size |
+| --- | --- | --- |
+| `qi21t_dit_full_bf16_dyn_iofp32.aimodel` | the DiT: bf16 weights and compute, fp32 inputs and outputs | 14.23 GB (13.25 GiB) |
+| `qi21t_dit_full_int8lin_dyn_iofp32.aimodel` | the same DiT with int8 Linear weights (one bf16 scale per 32 inputs), bf16 compute | 7.56 GB (7.04 GiB) |
+| `qi21_encoder_dynL_w16a32_ids_iofp32.aimodel` | the text encoder: bf16 weights, fp32 compute; token ids in, `embed_tokens` inside | 15.14 GB (14.10 GiB) |
+| `qi21_vae_{256,512,1024}_fp32.aimodel` | the VAE decoder, fp32, one per size | 1.01 GB (0.94 GiB) each |
+| `host/` | per-axis RoPE tables, `scheduler.json` (the 8-step grid), [`host_contract.md`](https://huggingface.co/mlboydaisuke/RGBA-Image-2.1-Turbo-CoreAI/blob/main/host/host_contract.md) | |
+| `tokenizer/` | the source's `processor/` files, unchanged | |
+| `config.json` | the source's `transformer/config.json`, unchanged | |
+| `LICENSE`, `NOTICE` | the Qwen Research License and the change notice | |
+
+The two DiT bundles have one interface; a run uses one of them. On every gate below the int8 DiT
+stays inside the bar, at the bf16 DiT's speed (within 0.1 %). Compiled, the bf16 DiT is 26.52 GiB
+and the int8 DiT 20.30 GiB.
+
+**Compile before you run.** On macOS 27.0 (26A428) the Python runtime crashes on this DiT unless it
+is compiled ahead of time with `--expect-frequent-reshapes` (step 2 below). A plain ahead-of-time
+compile fails at the initial call (`ANERegion.mm:414 … Code=-19`); so did a just-in-time compile of
+the same graph with the base weights on 2026-09-25. The compiled copies need their own disk:
+26.52 GiB for the bf16 DiT or 20.30 GiB for the int8, and 14.10 GiB for the encoder.
+
+## Use it
+
+There is no Swift app for this model yet. The Python engine
+[`conversion/qwenimage21/pipeline_engine.py`](https://github.com/john-rocky/coreai-model-zoo/blob/main/conversion/qwenimage21/pipeline_engine.py)
+runs the whole loop on the three bundles: tokenize, encode, 8 DiT steps, decode, write a PNG.
+`--turbo` selects the 8-step grid.
+
+```
+# 1. the bundles (the tokenizer is in tokenizer/)
+hf download mlboydaisuke/RGBA-Image-2.1-Turbo-CoreAI --local-dir RGBA-Image-2.1-Turbo-CoreAI
+
+# 2. compile for the Mac GPU (once per bundle; the gates used --architecture h16c on an M4 Max)
+cd RGBA-Image-2.1-Turbo-CoreAI
+for m in qi21_encoder_dynL_w16a32_ids_iofp32 qi21t_dit_full_bf16_dyn_iofp32 qi21_vae_256_fp32 qi21_vae_1024_fp32; do
+  xcrun coreai-build compile $m.aimodel --output aot/$m --platform macOS --architecture h16c \
+      --preferred-compute gpu --expect-frequent-reshapes
+done
+R=$PWD; A=$PWD/aot
+
+# 3. generate, from a checkout of the zoo
+#    (Python with coreai-core 1.0.0b2, torch, numpy, tokenizers, pillow)
+cd /path/to/coreai-model-zoo/conversion/qwenimage21
+python pipeline_engine.py --turbo \
+    --prompt "This is an RGBA image with transparency. A cute cartoon dragon sticker. The image has alpha channel and the background is transparent." \
+    --size 1024 --seed 42 --tag dragon \
+    --tokenizer-json $R/tokenizer/tokenizer.json \
+    --encoder $A/qi21_encoder_dynL_w16a32_ids_iofp32/qi21_encoder_dynL_w16a32_ids_iofp32.h16c.aimodelc \
+    --dit $A/qi21t_dit_full_bf16_dyn_iofp32/qi21t_dit_full_bf16_dyn_iofp32.h16c.aimodelc \
+    --vae $A/qi21_vae_1024_fp32/qi21_vae_1024_fp32.h16c.aimodelc
+# -> _work/samples/dragon.png (RGBA) and dragon_rgb.png (composited on white)
+```
+
+For the int8 DiT, compile `qi21t_dit_full_int8lin_dyn_iofp32` the same way and pass its
+`.aimodelc` as `--dit`. The prompt above is the upstream card's recommended form for transparent
+images: "This is an RGBA image with transparency. {subject}. The image has alpha channel and the
+background is transparent." The noise is `torch.randn` on a CPU generator seeded with `--seed`, the
+same draw the reference pipeline makes with a CPU generator and that seed.
+
+To check the port against the fp32 reference, record the reference once and run the engine in
+oracle mode. `capture_oracle.py` runs the diffusers-main pipeline in fp32 on the CPU, 17 s of
+generation at 256² on the M4 Max. It needs the full `Qwen/Qwen-Image-2.1-Turbo` snapshot and a venv
+with diffusers main 85c9fa4 and transformers 5.17.
+
+```
+python capture_oracle.py --snapshot <Qwen-Image-2.1-Turbo snapshot dir> --model-id Qwen/Qwen-Image-2.1-Turbo \
+    --size 256 --steps 8 --tag turbo256                    # -> oracle/turbo256/
+python pipeline_engine.py --turbo --oracle oracle/turbo256 \
+    --tokenizer-json $R/tokenizer/tokenizer.json \
+    --encoder $A/qi21_encoder_dynL_w16a32_ids_iofp32/qi21_encoder_dynL_w16a32_ids_iofp32.h16c.aimodelc \
+    --dit $A/qi21t_dit_full_bf16_dyn_iofp32/qi21t_dit_full_bf16_dyn_iofp32.h16c.aimodelc \
+    --vae $A/qi21_vae_256_fp32/qi21_vae_256_fp32.h16c.aimodelc
+# prints the latent corr vs the reference after every step, then the RGBA and white-composited PSNR
+```
+
+## Which image model should I use?
+
+The zoo's Mac text-to-image models are not ranked; pick by trade-off. The two RGBA-Image models write
+RGBA natively, so they fit images that need an alpha channel.
+
+| | params | sampler | time @1024 | precision |
+| --- | --- | --- | --- | --- |
+| **FLUX.2 klein** | 4B | 4 steps, guidance-distilled (no CFG) | ~11 s | fp16 or int8 |
+| **Z-Image-Turbo** | 6B | 8 steps + CFG (16 forwards) | ~70 s | bf16, near-lossless |
+| **GLM-Image** | 16B (9B AR + 7B DiT) | AR prior + 20-step DiT | ~208 s | int8 |
+| **RGBA-Image-2.1** | 7B | 40 steps, no CFG | ~190 s | bf16 |
+| **RGBA-Image-2.1-Turbo** | 7B | 8 steps, distilled, no CFG | ~38 s | bf16 or int8 |
+
+Times are the ones each card reports, on an M4 Max. For the two RGBA-Image models they are the DiT
+steps at the warm median per forward: 40 × 4.757 s and 8 × 4.721 s. They leave out the encoder, the
+VAE and loading.
+
+## Graph contracts
+
+Every graph has one function, `main`, and fp32 inputs and outputs except `input_ids`. Both DiT
+bundles have the DiT row's contract.
+
+| graph | inputs | output |
+| --- | --- | --- |
+| encoder | `input_ids [1,Lfull]` int32, `Lfull` 16..512 | `hidden [1,Lfull,4096]`: the last layer's residual stream, before the final norm |
+| DiT | `img_tokens [1,N,64]`, `txt_feats [1,L,4096]`, `timestep [1]`, `txt_cos`/`txt_sin [1,L,64]`, `img_cos`/`img_sin [1,N,64]`; `L` 8..512, `N` 64..4096 | `vel [1,N,64]` |
+| VAE | `latents_packed [1,N,64]`, the sampler's latent unchanged | `image [1,4,S,S]`, RGBA in [-1, 1] |
+
+- **Prompt.** One tokenization of the text-to-image chat template around the prompt, no padding.
+  The DiT reads `hidden[:, drop_idx:]`. `drop_idx` is the token count of the template's system
+  part: 14 with this tokenizer. Compute it; do not hard-code it.
+- **Sequence.** `[text L | image N]`, image tokens in raster order, one token per 16×16 px tile
+  (256² → 256 tokens, 512² → 1024, 1024² → 4096). There is no 2×2 latent packing.
+- **RoPE.** Text token `i` sits at `(i, i, i)`. Image token `(y, x)` sits at `(L, y − (h − h//2),
+  x − (w − w//2))`. `host/` has the per-axis tables for positions −1024..8191.
+- **Sampler.** The 8 sigmas in `host/scheduler.json`, then `0`. Shift 1.0 leaves them unchanged,
+  and there is no `μ` and no terminal stretch, so the grid is the same at every size. The DiT's
+  `timestep` input is `timesteps[i] / 1000` in fp32 (σᵢ bit for bit on this grid), and each step is
+  `x += (σᵢ₊₁ − σᵢ)·v`.
+- **VAE.** The graph unpacks the tokens and applies `latents·std + mean` itself. Feed it the raw
+  sampler latent.
+
+The full contract, with the formulas a Swift host needs:
+[`host/host_contract.md`](https://huggingface.co/mlboydaisuke/RGBA-Image-2.1-Turbo-CoreAI/blob/main/host/host_contract.md).
+
+## Measured
+
+M4 Max (128 GiB), macOS 27.0 (26A428), coreai-core 1.0.0b2, 2026-10-11. Bundles compiled ahead of
+time with `--expect-frequent-reshapes` (`--architecture h16c`), run with
+`SpecializationOptions.default()`. Speed runs held the Mac's measurement window, which holds back
+other sessions' heavy jobs. The same form timed in different windows moved by up to 1.6 %. The
+timings were taken on the bundles before their debug locations were stripped; the published files
+compute the same outputs bit for bit (Gates).
+
+**DiT speed** (`bench_dit.py`, text L = 40, bf16 DiT):
+
+| size | image tokens | initial call | s/forward (warm median of 5) | 8 steps |
+| --- | --- | --- | --- | --- |
+| 256² | 256 | 2.27 s | 0.341 s | 2.7 s |
+| 512² | 1024 | 1.10 s | 1.097 s | 8.8 s |
+| 1024² | 4096 | 4.72 s | 4.721 s | 37.8 s |
+
+The int8 DiT against the bf16 one in the same process (`ab_dit.py`, L = 40, 8 alternating pairs per
+size): 0.3409 / 1.0923 / 4.7808 s per forward against 0.3410 / 1.0926 / 4.7850 s.
+
+**One image end to end** (`pipeline_engine.py --turbo`, bf16 DiT, inside the measurement window,
+compile cache already warm):
+
+| prompt, size | encoder load / call | DiT load / initial step / 8 steps | VAE load / call | total |
+| --- | --- | --- | --- | --- |
+| dragon sticker, 512² | 17.0 / 0.40 s | 2.0 / 3.20 / 10.9 s | 1.2 / 0.38 s | 32.0 s |
+| dragon sticker, 1024² | 3.4 / 0.37 s | 2.0 / 6.63 / 39.6 s | 0.5 / 1.45 s | 47.3 s |
+| apple, 1024² | 3.5 / 0.36 s | 1.9 / 6.64 / 39.3 s | 0.3 / 1.46 s | 47.0 s |
+
+Load times vary between processes on this shared Mac: 1.9–43.3 s for the DiT and 2.5–55.8 s for
+the encoder across the gate runs. The cold load of a new `.aimodelc` adds a compile-cache entry the
+size of the compiled bundle (26 GB for the bf16 DiT, 20 GB for the int8).
+
+**Memory.** Peak memory footprint 4.80 GB at 512² and 17.77–18.16 GB at 1024²
+(`/usr/bin/time -l`). Its "maximum resident set size", 58.3 GB with the bf16 DiT and 51.6 GB with
+the int8, counts the mapped weight pages of the encoder and the DiT.
+
+**Fidelity** against the fp32 diffusers Turbo pipeline (prompt "a red apple on a wooden table,
+studio lighting", seed 1234, the same noise, 8 steps):
+
+| size | bf16 DiT: white-composited RGB PSNR / final latent corr | int8 DiT: the same | alpha max\|Δ\| |
+| --- | --- | --- | --- |
+| 256² | 43.79 dB / 0.999961 | 41.76 dB / 0.999944 | 1/255 |
+| 512² | 42.45 dB / 0.999800 | 49.28 dB / 0.999976 | 1/255 |
+| 1024² | 42.50 dB / 0.999926 | 39.32 dB / 0.999873 | 1/255 |
+
+The reference decodes with the Turbo bf16 VAE file and the bundles carry the fp32 weights; the band
+between the two (below) is inside these numbers. With the reference's prompt embeddings in place of
+the encoder bundle, 256² scores 46.57 dB (bf16 DiT) and 42.56 dB (int8 DiT).
+
+**The VAE band.** The same final latent decoded with the fp32 weights (these bundles) and with the
+Turbo pipeline's bf16 copy:
+
+| size | max\|Δ\| on [-1, 1] | uint8 PSNR | max levels, RGB / alpha | bundle vs a fp32 decode of its own weights |
+| --- | --- | --- | --- | --- |
+| 256² | 0.074 | 56.95 dB | 10 / 1 | max\|Δ\| 3.0e-5 |
+| 512² | 0.106 | 58.95 dB | 14 / 1 | max\|Δ\| 3.2e-5 |
+| 1024² | 0.105 | 58.15 dB | 13 / 1 | max\|Δ\| 4.2e-5 |
+
+**Gates:**
+
+- DiT re-authored in plain PyTorch, fp32, with the Turbo weights, teacher-forced on all 8 steps:
+  min corr 0.999999999982 at 256² and 0.999999999997 at 512²; 9 of 9 broken variants fail the bar
+  (256²).
+- DiT bundles (GPU), teacher-forced against the fp32 reference, 8/8 steps, NaN 0: min corr 0.999971 /
+  0.999940 / 0.999977 at 256² / 512² / 1024² (bf16) and 0.999960 / 0.999883 / 0.999965 (int8).
+- Text encoder bundle on the Turbo reference: min per-token corr 0.999999998629, NaN 0. The host
+  tokenizer gives the Turbo processor's ids, `drop_idx` 14.
+- VAE bundles against a fp32 decode of their own weights: max|Δ| 3.0e-5 / 3.2e-5 / 4.2e-5, every
+  channel corr ≥ 0.99999995.
+- Sampler: sigmas, timesteps and all 8 Euler steps bit-exact at 256², 512² and 1024². RoPE tables
+  bit-exact against diffusers main.
+- Transparency: the dragon prompt above, seed 42: alpha min 0 and all four corner pixels 0 at 512²
+  (alpha mean 102) and 1024² (alpha mean 82).
+- Stripped bundles reproduce the unstripped outputs bit for bit. The published files have their
+  export-time debug locations stripped; against the bundles they were made from, both DiTs (8
+  teacher-forced steps at 256²), the encoder, the three VAEs and a 256² image end to end with each DiT
+  give identical outputs.
+
+**Other forms tried** (s/forward against the shipped bf16 DiT in the same window):
+
+| form | result |
+| --- | --- |
+| int8 Linear weights, AOT with `--expect-frequent-reshapes` | compiles in 301 s, passes every gate, −0.02 / −0.02 / −0.09 % at 256² / 512² / 1024²: ships as the second DiT |
+| image axis fixed at N = 4096 | −0.50 % at L = 40, +0.58 % at L = 18: the dynamic graph ships |
+| `--preferred-compute neural-engine` | 0 Neural Engine regions; runs on the GPU, outputs equal bit for bit, +0.01 / 0.00 / +0.72 % |
+| plain AOT, no `--expect-frequent-reshapes` | crashes at the initial call (`ANERegion.mm:414 … Code=-19`), dynamic and fixed image axis alike |
+| text K/V computed once per image | the 32 text tokens between L = 8 and L = 40 cost 1.59 % of a forward at 512² and 0.51 % at 1024² |
+
+## Lessons
+
+1. **A probe's compile result does not carry to the full graph, either way.** The 2-layer int8 probe
+   with random weights fails the `--expect-frequent-reshapes` compile (`Pass failed:
+   MPSMemrefAllocFusion`), on 2026-09-25 and again on 2026-10-11. The full 32-layer int8 DiT with the
+   Turbo weights compiles in 301 s and passes every gate. On 2026-09-25 it went the other way: the
+   probe ran where the full bf16 DiT crashed. Judge compilation on the full graph.
+2. **A sibling checkpoint can carry a bf16 copy of a component.** The Turbo `vae/` is the base fp32
+   VAE rounded to bf16, so the fp32 bundles sit 0.074–0.106 from the Turbo pipeline's decode, 7–10×
+   the 1e-2 bar. Gate a bundle against a fp32 decode of the weights it holds, and report the rounding
+   band beside it. Alpha is near-constant on an opaque image (0.976–1.000), so its correlation drops
+   to 0.966–0.991 under that band: report alpha in levels, not correlation.
+3. **Read a dB gap between two DiT forms next to a nudge control.** The 8-step sampler turns a
+   1.25e-5 relative change of the prompt embeddings into 29.03 dB (512²) and 32.08 dB (1024²)
+   between dragon stickers. The int8 and bf16 stickers are 34.42 and 28.99 dB apart, the same order.
+   78–88 % of the pixels whose alpha moves by more than 2 levels lie within 3 px of the silhouette:
+   alpha max|Δ| on a sticker (227–255) measures the edge.
+4. **`--preferred-compute neural-engine` can compile to 0 regions without an error.** This DiT
+   compiled that way has no Neural Engine region and runs on the GPU, equal bit for bit to the gpu
+   compile. Count the `*ANE_region*` entries before timing an ANE form.
+5. **An exported `.aimodel` carries the export machine's paths.** coreai-torch writes every op's
+   source location into `main.mlirb`, and `grep -I` skips that binary. coreai-torch's
+   `strip_debug_info` removes them without touching the ops or the weights
+   ([`strip_bundle.py`](https://github.com/john-rocky/coreai-model-zoo/blob/main/conversion/qwenimage21/strip_bundle.py));
+   the result is a new asset, so gate it again.
+
+The lessons of the base port (the Neural Engine region, the encoder's fp32 compute, the bf16 band):
+[RGBA-Image-2.1](https://github.com/john-rocky/coreai-model-zoo/blob/main/models/rgba-image-2.1/README.md#lessons).
+Port notes, every gate and the dead ends:
+[`knowledge/qwenimage21-port.md`](https://github.com/john-rocky/coreai-model-zoo/blob/main/knowledge/qwenimage21-port.md).
+Scripts: [`conversion/qwenimage21/`](https://github.com/john-rocky/coreai-model-zoo/tree/main/conversion/qwenimage21).
+
+## Licence
+
+The weights are Qwen Materials under the **Qwen RESEARCH LICENSE AGREEMENT** (release date
+2026-09-20), included unchanged as
+[`LICENSE`](https://huggingface.co/mlboydaisuke/RGBA-Image-2.1-Turbo-CoreAI/blob/main/LICENSE). A
+summary follows; the Agreement is what binds.
+
+- **§2, non-commercial only.** You may use, copy, modify and redistribute the Materials for
+  research or evaluation purposes only. Commercial use needs a separate licence from Hangzhou
+  Tongyi Laboratory Technology Co., Ltd.; §2(b) gives the contact.
+- **§3, redistribution,** under three conditions: every recipient gets a copy of the Agreement
+  (`LICENSE`); modified files carry a notice that they were changed (`NOTICE` lists every change);
+  and copies keep the attribution text below in a "Notice" file (`NOTICE`, line 1).
+- **§4(b).** An AI model created from the Materials and made available displays "Built with Qwen"
+  prominently in its documentation. This card does, at the top.
+- **§4(c).** "Qwen" is not the primary name of a derivative. This port is named
+  RGBA-Image-2.1-Turbo; "Core AI port of Qwen-Image-2.1-Turbo" is the descriptive use the Agreement
+  permits.
+
+[`NOTICE`](https://huggingface.co/mlboydaisuke/RGBA-Image-2.1-Turbo-CoreAI/blob/main/NOTICE) begins
+with the attribution text §3(c) requires:
+
+> Qwen is licensed under the Qwen RESEARCH LICENSE AGREEMENT, Copyright (c) 2026 Hangzhou Tongyi Laboratory Technology Co., Ltd. All Rights Reserved.

config.json

@@ -0,0 +1,19 @@
+{
+  "_class_name": "QwenImage21Transformer2DModel",
+  "_diffusers_version": "0.41.0.dev0",
+  "attention_head_dim": 128,
+  "axes_dims_rope": [
+    16,
+    56,
+    56
+  ],
+  "causal_condition": true,
+  "context_in_dim": 4096,
+  "eps": 1e-06,
+  "in_channels": 64,
+  "mlp_ratio": 3,
+  "num_attention_heads": 32,
+  "num_layers": 32,
+  "out_channels": 64,
+  "patch_size": 1
+}

host/host_contract.md

@@ -0,0 +1,181 @@
+# Host contract — RGBA-Image-2.1-Turbo (Core AI port of Qwen-Image-2.1-Turbo)
+
+Everything a host computes around the three graphs, for text-to-image, batch 1, no CFG.
+The Python reference of every step below is in the zoo's
+[`conversion/qwenimage21/`](https://github.com/john-rocky/coreai-model-zoo/tree/main/conversion/qwenimage21):
+`qi21_tokenize.py` (tokenizer), `qi21_host.py` (RoPE, pack/unpack), `qi21_sched.py` (sampler,
+`schedule_fixed`), `pipeline_engine.py --turbo` (the whole loop on the three bundles). The first three
+match the diffusers-main pipeline (diffusers 85c9fa4, `Qwen/Qwen-Image-2.1-Turbo` @ `d65dbc9`) exactly:
+the same token ids, bit-identical RoPE tables, bit-identical sigmas and Euler steps.
+`pipeline_engine.py` is scored against the pipeline's fp32 images.
+
+This port shares its graph code and its text-encoder and VAE graphs with RGBA-Image-2.1 (the files here
+have their export-time debug locations stripped). Only the DiT weights and the sampler differ. Section 6
+is the part that changed.
+
+## 1. The graphs
+
+Every graph has one function, `main`. All tensors crossing a graph boundary are fp32, except
+`input_ids` (int32).
+
+| bundle | inputs | output | axes |
+| --- | --- | --- | --- |
+| `qi21_encoder_dynL_w16a32_ids_iofp32.aimodel` | `input_ids [1,Lfull]` int32 | `hidden [1,Lfull,4096]` | `Lfull` 16..512 |
+| `qi21t_dit_full_bf16_dyn_iofp32.aimodel` | `img_tokens [1,N,64]`, `txt_feats [1,L,4096]`, `timestep [1]`, `txt_cos [1,L,64]`, `txt_sin [1,L,64]`, `img_cos [1,N,64]`, `img_sin [1,N,64]` | `vel [1,N,64]` | `L` 8..512, `N` 64..4096 |
+| `qi21t_dit_full_int8lin_dyn_iofp32.aimodel` | the same as the bf16 DiT | the same | the same |
+| `qi21_vae_{256,512,1024}_fp32.aimodel` | `latents_packed [1,N,64]` | `image [1,4,S,S]` | fixed: `N = (S/16)²` |
+
+- Encoder: the Qwen3-VL-8B text stack (36 layers). bf16 weights, fp32 compute. `embed_tokens` is
+  inside the graph. The output is the residual stream after the last layer, **before** the final
+  RMSNorm. Do not apply a norm on the host.
+- DiT: 32 blocks, fp32 boundary. Two bundles with one interface; use either. `bf16`: bf16 weights
+  and compute. `int8lin`: the 232 Linear weights in int8 (symmetric, one bf16 scale per block of
+  32), dequantized inside the graph; norms, scales and compute in bf16.
+- VAE: decoder only, fp32. The graph unpacks the tokens and applies `latents * std + mean` itself.
+
+## 2. Tokenize
+
+Tokenizer: `tokenizer/tokenizer.json` (Qwen2 BPE, byte-level), the Turbo checkpoint's
+`processor/tokenizer.json`. No BOS token. An empty prompt is replaced by a single space `" "`.
+
+Template (text-to-image):
+
+```
+<|im_start|>system\nComprehend and analyze the provided prompt.<|im_end|>\n<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n
+```
+
+`\n` is a newline character. Encode the whole string once, with no padding and no truncation, to get
+`ids` (length `Lfull`).
+
+**`drop_idx`** is the number of tokens of the system part alone,
+`<|im_start|>system\nComprehend and analyze the provided prompt.<|im_end|>\n`. Compute it by encoding
+that string. With this tokenizer it is 14:
+`[151644, 8948, 198, 1092, 30782, 408, 323, 23643, 279, 3897, 9934, 13, 151645, 198]`.
+Check that `ids[:drop_idx]` equals those tokens.
+
+`Lfull` must be 16..512 (the encoder's axis), and the DiT needs `L = Lfull − drop_idx` in 8..512.
+The template around the empty-prompt substitute `" "` is 23 tokens (`L` = 9).
+
+The Turbo `tokenizer.json` differs from the base checkpoint's only in its offset and decoder
+settings (`trim_offsets`, `add_prefix_space`, `use_regex`). Vocabulary, merges and added tokens are
+the same, and both files give the processor's ids on every prompt the port was gated on.
+
+## 3. Encode
+
+```
+hidden        = encoder(input_ids = ids as int32 [1, Lfull])      # [1, Lfull, 4096]
+prompt_embeds = hidden[:, drop_idx : Lfull]                       # [1, L, 4096], L = Lfull - drop_idx
+```
+
+Pass exactly `Lfull` tokens; the axis is dynamic, so no padding is needed. (Attention is causal, so
+pad tokens never reach the first `Lfull` outputs, but a longer input moves the GPU result by about
+4e-6 relative.) Run the encoder once per image.
+
+## 4. Sequence layout and RoPE
+
+The DiT's sequence is `[text L | image N]`: the `L` prompt tokens, then the image tokens in raster
+order. One image token covers one 16×16 px tile of the output: for an `S×S` image,
+`h = w = S/16` and `N = h·w` (256² → 256 tokens, 512² → 1024, 1024² → 4096). There is no 2×2 packing.
+
+Each token has a 3-axis position `(frame, height, width)`:
+
+- text token `i` (0-based) → `(i, i, i)`;
+- image token at row `y`, column `x` (0-based, token index `y·w + x`) →
+  `(L, y − (h − h//2), x − (w − w//2))`. The grid is centred on zero. For `h = 16`, rows go −8..7.
+
+`host/rope_axis{a}_{cos,sin}.f32` hold one row per position −1024..8191: fp32, little-endian,
+row-major `[9216, P_a]` with `P = (8, 28, 28)`. The row for position `p` is `p + 1024`. A token's
+64 values are the three rows concatenated in axis order:
+
+```
+cos[token] = axis0_cos[f + 1024] ++ axis1_cos[hpos + 1024] ++ axis2_cos[wpos + 1024]   # 8 + 28 + 28
+sin[token] = the same with the _sin tables
+txt_cos, txt_sin = rows of the L text tokens     # [1, L, 64]
+img_cos, img_sin = rows of the N image tokens    # [1, N, 64]
+```
+
+The tables are `torch.polar(1, outer(pos, 1 / 10000^(arange(0, d, 2)/d)))` for axis widths
+`d = 16, 56, 56`, the same numbers as `QwenImage21Rope.freqs` of diffusers main (bit-exact). Axes 1
+and 2 have the same width, so their files are byte-identical. The six files are byte-identical to
+RGBA-Image-2.1's `host/`. The four tensors depend only on `L`, `h` and `w`: build them once per
+image, not per step.
+
+## 5. Noise and pack
+
+The initial latent is standard normal noise: 64 channels × `h` rows × `w` columns, channel-major.
+The reference pipeline draws it as `randn((1, 1, 64, h, w))` and packs it into DiT tokens:
+
+```
+x[0, y·w + x_, c] = z[c, y, x_]          # = z.view(1, 64, h·w).transpose(1, 2)
+```
+
+Any N(0, 1) noise generates an image. Matching the Python engine for a given seed needs its exact
+draw: `torch.randn((1, 1, 64, h, w), generator=torch.Generator("cpu").manual_seed(seed))`.
+
+## 6. Sampler (FlowMatch Euler, a fixed 8-step grid, no CFG)
+
+The checkpoint carries its own sigmas: `sample_sigmas` in its `model_index.json`, copied to
+`host/scheduler.json`. The pipeline passes them to the scheduler in place of a linspace and ignores
+`num_inference_steps`. `use_dynamic_shifting` is false, so there is no `mu` and the grid is the same
+at every image size. All arrays are fp32.
+
+```
+sigmas    = fp32(sample_sigmas)        # 1.0, 0.978453, 0.95418, 0.926626, 0.89508, 0.845148, 0.704534, 0.414568
+sigmas    = shift·sigmas / (1 + (shift − 1)·sigmas)                  # shift 1.0: unchanged, bit for bit
+                                                                     # shift_terminal null: no terminal stretch
+timesteps = sigmas · num_train_timesteps                             # fp32
+sigmas    = sigmas ++ [0]                                            # 9 values
+for i in 0 ..< 8:
+    t   = timesteps[i] / 1000                                        # fp32; this is the DiT `timestep` input
+    vel = dit(img_tokens = x, txt_feats = prompt_embeds, timestep = [t], txt_cos, txt_sin, img_cos, img_sin)
+    x   = x + (sigmas[i+1] − sigmas[i]) · vel                        # fp32
+```
+
+On this grid `t` equals `sigmas[i]` bit for bit at all 8 steps; keep `timesteps[i] / 1000` anyway,
+the form the pipeline uses. `qi21_sched.schedule_fixed` reproduces the reference sigmas, timesteps
+and all 8 Euler steps bit-exactly at 256², 512² and 1024².
+
+RGBA-Image-2.1 runs 40 steps on a shifted linspace instead (its `host/host_contract.md`, §6). The
+Turbo DiT is a distilled checkpoint, not the base DiT run for fewer steps: on the same noise and
+prompt, the fp32 Turbo pipeline's 8-step image and the fp32 base pipeline's 40-step image are
+21.75 dB (256²) and 23.35 dB (512²) apart (white-composited RGB PSNR).
+
+## 7. Decode
+
+```
+image = vae_S(latents_packed = x)          # x after the last step, [1, N, 64], exactly as the sampler holds it
+rgba8 = round(clip(image · 0.5 + 0.5, 0, 1) · 255)   # [1, 4, S, S] -> channels R, G, B, A
+```
+
+Feed the sampler's latent unchanged: no unpacking and no `* std + mean` on the host (the graph does
+both). The four channels are what the reference pipeline saves as an RGBA PNG.
+
+The VAE bundles hold the base checkpoint's fp32 VAE weights. The Turbo checkpoint's `vae/` is a bf16
+copy of those weights (all 238 tensors are the round-to-nearest-even of the fp32 ones). Decoding the
+same latent, the two sets of weights differ by up to 0.074–0.106 on the [-1, 1] scale: uint8 PSNR
+56.95 / 58.95 / 58.15 dB at 256² / 512² / 1024², at most 10–14 levels on one channel, 1 level on
+alpha. A host that compares against the diffusers Turbo pipeline sees that band; the bundles match a
+fp32 decode with their own weights to max|Δ| 3.0e-5 – 4.2e-5.
+
+## 8. Compile before running on the GPU
+
+On macOS 27.0 (26A428) the Python runtime crashes on the 32-block DiT when the `.aimodel` is
+compiled just-in-time: the MPSGraph delegate forms a Neural Engine region inside the graph and the
+ANE inference fails (`ANERegion.mm:414 failed assertion … Code=-19`). A plain ahead-of-time compile
+fails the same way, with a dynamic or a static image axis. What runs is an ahead-of-time compile with
+`--expect-frequent-reshapes`, loaded with `SpecializationOptions.default()`:
+
+```
+xcrun coreai-build compile qi21t_dit_full_bf16_dyn_iofp32.aimodel \
+    --output aot/qi21t_dit_full_bf16_dyn_iofp32 \
+    --platform macOS --architecture h16c --preferred-compute gpu --expect-frequent-reshapes
+# -> aot/qi21t_dit_full_bf16_dyn_iofp32/qi21t_dit_full_bf16_dyn_iofp32.h16c.aimodelc
+```
+
+Do the same for the encoder and the VAE bundle you use; every gate of this port ran all three this
+way, on an M4 Max with `--architecture h16c` (without `--architecture`, `coreai-build` compiles for
+every supported architecture). On that Mac the bf16 DiT compiles in 107.6 s to 26.52 GiB, the int8 DiT
+in 301 s to 20.30 GiB; the encoder's compiled copy is 14.10 GiB. With
+`--preferred-compute neural-engine` the DiT compiles to 0 Neural Engine regions and runs on the GPU.
+Whether a Swift host using `GraphModel(computeUnits: .gpu)` hits the same Neural Engine region has
+not been tested.

host/rope_axis0_cos.f32

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a67b7ed9fea4c3f775dea442cf921f6cfa25be5d7da2671a87a01b154af3b5b
+size 294912

host/rope_axis0_sin.f32

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6da418893c5551a329985da7efbeb20858736f3fb21077239405f9ffb5f578f
+size 294912

host/rope_axis1_cos.f32

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8152a557c6febd21a2baeded29590c6b5bf18c439da5ddbe110c1273379c6ee3
+size 1032192

host/rope_axis1_sin.f32

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9e468de85274824afd0a30ecf8ca8bb53005ed0d606b656a65703e51c1b21cc
+size 1032192

host/rope_axis2_cos.f32

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8152a557c6febd21a2baeded29590c6b5bf18c439da5ddbe110c1273379c6ee3
+size 1032192

host/rope_axis2_sin.f32

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9e468de85274824afd0a30ecf8ca8bb53005ed0d606b656a65703e51c1b21cc
+size 1032192

host/scheduler.json

@@ -0,0 +1,17 @@
+{
+  "sample_sigmas": [
+    1.0,
+    0.978453,
+    0.95418,
+    0.926626,
+    0.89508,
+    0.845148,
+    0.704534,
+    0.414568
+  ],
+  "shift": 1.0,
+  "use_dynamic_shifting": false,
+  "shift_terminal": null,
+  "num_train_timesteps": 1000,
+  "steps": 8
+}

qi21_encoder_dynL_w16a32_ids_iofp32.aimodel/main.hash

@@ -0,0 +1,2 @@
+�KͫRrC�l��´�
+xY��X��zp3�����c

qi21_encoder_dynL_w16a32_ids_iofp32.aimodel/main.mlirb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17a14bcdab527243b56cc1ecc2b4b40a7859cec45892f97a7033f88fb38ba763
+size 15137683256

qi21_encoder_dynL_w16a32_ids_iofp32.aimodel/metadata.json

@@ -0,0 +1,25 @@
+{
+  "creationDate" : "20260925T065421Z",
+  "assetVersion" : "2.0",
+  "description" : "Qwen-Image-2.1 text encoder (Qwen3-VL-8B text stack, all 36 layers), bf16 weights, fp32 compute, int32 input_ids -> fp32 hidden (last layer, before the final norm), dynamic L 16..512. Source: Qwen\/Qwen-Image-2.1@790c926.",
+  "license" : "qwen-research",
+  "producer" : "coreai-core 1.0.0b2",
+  "creatorDefinedMetadata" : {
+    "strip" : {
+      "what" : "the .aimodel re-saved after coreai-torch's strip_debug_info: every op's source location (file, line, call stack) replaced by an unknown location; the ops and the weights are not touched",
+      "from_main_mlirb" : {
+        "bytes" : 15138226830,
+        "sha256" : "d37b8e64763648cb6a32b23a2199b42d0ee93fac2c3899835d8e64d534563243"
+      },
+      "main_mlirb" : {
+        "bytes" : 15137683256,
+        "sha256" : "17a14bcdab527243b56cc1ecc2b4b40a7859cec45892f97a7033f88fb38ba763"
+      },
+      "tool" : "conversion\/qwenimage21\/strip_bundle.py",
+      "versions" : {
+        "coreai-torch" : "0.4.1",
+        "coreai-core" : "1.0.0b2"
+      }
+    }
+  }
+}

qi21_vae_1024_fp32.aimodel/main.hash

@@ -0,0 +1 @@
+�á�����d��̡$����a9�X��4לP

qi21_vae_1024_fp32.aimodel/main.mlirb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4c3a184f7ee16f3f764ade7cca124a9a9b0ad613915ea8a0b58ffdf34d79c50
+size 1012370701

qi21_vae_1024_fp32.aimodel/metadata.json

@@ -0,0 +1,25 @@
+{
+  "description" : "Qwen-Image-2.1 VAE decoder, 1024x1024, fp32: latents_packed [1,4096,64] (sampler output, normalised) -> image [1,4,1024,1024] RGBA in [-1,1]; unpack and latents*std+mean inside the graph. Source: Qwen\/Qwen-Image-2.1@790c926.",
+  "assetVersion" : "2.0",
+  "license" : "qwen-research",
+  "creationDate" : "20260925T071221Z",
+  "producer" : "coreai-core 1.0.0b2",
+  "creatorDefinedMetadata" : {
+    "strip" : {
+      "what" : "the .aimodel re-saved after coreai-torch's strip_debug_info: every op's source location (file, line, call stack) replaced by an unknown location; the ops and the weights are not touched",
+      "from_main_mlirb" : {
+        "bytes" : 1012440351,
+        "sha256" : "d82fc436a51e36dea17272c64e8dd667df7dcd0c1d485bf225319303ed823944"
+      },
+      "main_mlirb" : {
+        "bytes" : 1012370701,
+        "sha256" : "b4c3a184f7ee16f3f764ade7cca124a9a9b0ad613915ea8a0b58ffdf34d79c50"
+      },
+      "tool" : "conversion\/qwenimage21\/strip_bundle.py",
+      "versions" : {
+        "coreai-torch" : "0.4.1",
+        "coreai-core" : "1.0.0b2"
+      }
+    }
+  }
+}

qi21_vae_256_fp32.aimodel/main.hash

@@ -0,0 +1 @@
+

qi21_vae_256_fp32.aimodel/main.mlirb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0dfd5cd6b8402850f5fa6d7a91b624e8c76188ceaecaab40d49681bed465633f
+size 1012364804

qi21_vae_256_fp32.aimodel/metadata.json

@@ -0,0 +1,25 @@
+{
+  "creationDate" : "20260925T071101Z",
+  "producer" : "coreai-core 1.0.0b2",
+  "assetVersion" : "2.0",
+  "license" : "qwen-research",
+  "description" : "Qwen-Image-2.1 VAE decoder, 256x256, fp32: latents_packed [1,256,64] (sampler output, normalised) -> image [1,4,256,256] RGBA in [-1,1]; unpack and latents*std+mean inside the graph. Source: Qwen\/Qwen-Image-2.1@790c926.",
+  "creatorDefinedMetadata" : {
+    "strip" : {
+      "what" : "the .aimodel re-saved after coreai-torch's strip_debug_info: every op's source location (file, line, call stack) replaced by an unknown location; the ops and the weights are not touched",
+      "from_main_mlirb" : {
+        "bytes" : 1012434454,
+        "sha256" : "82396266f39abd444e11fd6b17b20347eeb7c3b8d5262b5522f877b13f527762"
+      },
+      "main_mlirb" : {
+        "bytes" : 1012364804,
+        "sha256" : "0dfd5cd6b8402850f5fa6d7a91b624e8c76188ceaecaab40d49681bed465633f"
+      },
+      "tool" : "conversion\/qwenimage21\/strip_bundle.py",
+      "versions" : {
+        "coreai-torch" : "0.4.1",
+        "coreai-core" : "1.0.0b2"
+      }
+    }
+  }
+}

qi21_vae_512_fp32.aimodel/main.mlirb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d578ba43cf8a5f62134e3cd46885006f385153d8c1b1f83f9f7ce0a35215626f
+size 1012366781

qi21_vae_512_fp32.aimodel/metadata.json

@@ -0,0 +1,25 @@
+{
+  "description" : "Qwen-Image-2.1 VAE decoder, 512x512, fp32: latents_packed [1,1024,64] (sampler output, normalised) -> image [1,4,512,512] RGBA in [-1,1]; unpack and latents*std+mean inside the graph. Source: Qwen\/Qwen-Image-2.1@790c926.",
+  "assetVersion" : "2.0",
+  "license" : "qwen-research",
+  "creationDate" : "20260925T071145Z",
+  "producer" : "coreai-core 1.0.0b2",
+  "creatorDefinedMetadata" : {
+    "strip" : {
+      "what" : "the .aimodel re-saved after coreai-torch's strip_debug_info: every op's source location (file, line, call stack) replaced by an unknown location; the ops and the weights are not touched",
+      "from_main_mlirb" : {
+        "bytes" : 1012436431,
+        "sha256" : "cf8b1b14704963bc912866b81482a2ac24b1367796c6f60eeed17e95e9282e56"
+      },
+      "main_mlirb" : {
+        "bytes" : 1012366781,
+        "sha256" : "d578ba43cf8a5f62134e3cd46885006f385153d8c1b1f83f9f7ce0a35215626f"
+      },
+      "tool" : "conversion\/qwenimage21\/strip_bundle.py",
+      "versions" : {
+        "coreai-torch" : "0.4.1",
+        "coreai-core" : "1.0.0b2"
+      }
+    }
+  }
+}

qi21t_dit_full_bf16_dyn_iofp32.aimodel/main.hash

@@ -0,0 +1 @@
+�i�7H'�Q��	��ˋ)�����l�mG����

qi21t_dit_full_bf16_dyn_iofp32.aimodel/main.mlirb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c69d137481c271ffd51fa99098187cb8b298d82fb88c56c15e66d47afc1caf8
+size 14230567115

qi21t_dit_full_bf16_dyn_iofp32.aimodel/metadata.json

@@ -0,0 +1,25 @@
+{
+  "license" : "qwen-research",
+  "producer" : "coreai-core 1.0.0b2",
+  "creationDate" : "20261011T062903Z",
+  "description" : "Qwen-Image-2.1 DiT (full), bf16 weights+compute, fp32 I\/O, dynamic text\/image axes. Source: Qwen\/Qwen-Image-2.1-Turbo@d65dbc9.",
+  "assetVersion" : "2.0",
+  "creatorDefinedMetadata" : {
+    "strip" : {
+      "what" : "the .aimodel re-saved after coreai-torch's strip_debug_info: every op's source location (file, line, call stack) replaced by an unknown location; the ops and the weights are not touched",
+      "from_main_mlirb" : {
+        "bytes" : 14231004528,
+        "sha256" : "94804e70b71730201413aa962dda9092b8a2b158adeef191fa6322f4336aa9f9"
+      },
+      "main_mlirb" : {
+        "bytes" : 14230567115,
+        "sha256" : "9c69d137481c271ffd51fa99098187cb8b298d82fb88c56c15e66d47afc1caf8"
+      },
+      "tool" : "conversion\/qwenimage21\/strip_bundle.py",
+      "versions" : {
+        "coreai-torch" : "0.4.1",
+        "coreai-core" : "1.0.0b2"
+      }
+    }
+  }
+}

qi21t_dit_full_int8lin_dyn_iofp32.aimodel/main.hash

@@ -0,0 +1,2 @@
+Q.p>�<X��ڧ
+f��H&2�p��:݌ܺ-�

qi21t_dit_full_int8lin_dyn_iofp32.aimodel/main.mlirb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:511d2e703e04b33c1358a9fddaa70a66e5cd482632c070b5c33add8cdcba2dc7
+size 7560188326

qi21t_dit_full_int8lin_dyn_iofp32.aimodel/metadata.json

@@ -0,0 +1,25 @@
+{
+  "assetVersion" : "2.0",
+  "producer" : "coreai-core 1.0.0b2",
+  "creationDate" : "20261011T065052Z",
+  "license" : "qwen-research",
+  "description" : "Qwen-Image-2.1 DiT (full), int8 per-block-32 Linear weights (symmetric), bf16 compute, fp32 I\/O, dynamic text\/image axes. Source: Qwen\/Qwen-Image-2.1-Turbo@d65dbc9.",
+  "creatorDefinedMetadata" : {
+    "strip" : {
+      "what" : "the .aimodel re-saved after coreai-torch's strip_debug_info: every op's source location (file, line, call stack) replaced by an unknown location; the ops and the weights are not touched",
+      "from_main_mlirb" : {
+        "bytes" : 7560697655,
+        "sha256" : "3190edb18e6167499ae015b1660532846a1f4aa1d6de5cdbcf1dae5e6d2c752e"
+      },
+      "main_mlirb" : {
+        "bytes" : 7560188326,
+        "sha256" : "511d2e703e04b33c1358a9fddaa70a66e5cd482632c070b5c33add8cdcba2dc7"
+      },
+      "tool" : "conversion\/qwenimage21\/strip_bundle.py",
+      "versions" : {
+        "coreai-torch" : "0.4.1",
+        "coreai-core" : "1.0.0b2"
+      }
+    }
+  }
+}

tokenizer/chat_template.jinja

@@ -0,0 +1,120 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {%- if messages[0].content is string %}
+            {{- messages[0].content }}
+        {%- else %}
+            {%- for content in messages[0].content %}
+                {%- if 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' }}
+        {%- if messages[0].content is string %}
+            {{- messages[0].content }}
+        {%- else %}
+            {%- for content in messages[0].content %}
+                {%- if 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- for message in messages %}
+    {%- if message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' }}
+        {%- if message.content is string %}
+            {{- message.content }}
+        {%- else %}
+            {%- for content in message.content %}
+                {%- if content.type == 'image' or 'image' in content or 'image_url' in content %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                    {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%}
+                    <|vision_start|><|image_pad|><|vision_end|>
+                {%- elif content.type == 'video' or 'video' in content %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                    {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%}
+                    <|vision_start|><|video_pad|><|vision_end|>
+                {%- elif 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role + '\n' }}
+        {%- if message.content is string %}
+            {{- message.content }}
+        {%- else %}
+            {%- for content_item in message.content %}
+                {%- if 'text' in content_item %}
+                    {{- content_item.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and message.content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {%- if message.content is string %}
+            {{- message.content }}
+        {%- else %}
+            {%- for content in message.content %}
+                {%- if content.type == 'image' or 'image' in content or 'image_url' in content %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                    {%- if add_vision_id %}Picture {{ image_count.value }}: {% endif -%}
+                    <|vision_start|><|image_pad|><|vision_end|>
+                {%- elif content.type == 'video' or 'video' in content %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                    {%- if add_vision_id %}Video {{ video_count.value }}: {% endif -%}
+                    <|vision_start|><|video_pad|><|vision_end|>
+                {%- elif 'text' in content %}
+                    {{- content.text }}
+                {%- endif %}
+            {%- endfor %}
+        {%- endif %}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

tokenizer/processor_config.json

@@ -0,0 +1,63 @@
+{
+  "image_processor": {
+    "data_format": "channels_first",
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "image_mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "image_processor_type": "Qwen2VLImageProcessorFast",
+    "image_std": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "merge_size": 2,
+    "patch_size": 16,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "size": {
+      "longest_edge": 16777216,
+      "shortest_edge": 65536
+    },
+    "temporal_patch_size": 2
+  },
+  "processor_class": "Qwen3VLProcessor",
+  "video_processor": {
+    "data_format": "channels_first",
+    "default_to_square": true,
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "do_sample_frames": true,
+    "fps": 2,
+    "image_mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "image_std": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "max_frames": 768,
+    "merge_size": 2,
+    "min_frames": 4,
+    "patch_size": 16,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "return_metadata": false,
+    "size": {
+      "longest_edge": 25165824,
+      "shortest_edge": 4096
+    },
+    "temporal_patch_size": 2,
+    "video_processor_type": "Qwen3VLVideoProcessor"
+  }
+}

tokenizer/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be75606093db2094d7cd20f3c2f385c212750648bd6ea4fb2bf507a6a4c55506
+size 11422650

tokenizer/tokenizer_config.json

@@ -0,0 +1,30 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "is_local": true,
+  "model_max_length": 262144,
+  "pad_token": "<|endoftext|>",
+  "processor_class": "Qwen3VLProcessor",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}