orbitquant 0.1.0__tar.gz → 0.1.2__tar.gz

{orbitquant-0.1.0 → orbitquant-0.1.2}/.github/workflows/publish-pypi.yml

@@ -6,7 +6,7 @@ on:
       version:
         description: Version to publish
         required: true
-        default: "0.1.0"
+        default: "0.1.2"
 
 jobs:
   build:

{orbitquant-0.1.0 → orbitquant-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orbitquant
-Version: 0.1.0
+Version: 0.1.2
 Summary: Clean-room OrbitQuant implementation for diffusion transformers
 Project-URL: Homepage, https://github.com/iamwavecut/OrbitQuant
 Project-URL: Repository, https://github.com/iamwavecut/OrbitQuant
@@ -81,8 +81,7 @@ Install the package with the Hugging Face runtime dependencies:
 pip install "orbitquant[hf]"
 ```
 
-Until the first PyPI release is available, install the same package directly
-from GitHub:
+The development branch can also be installed directly from GitHub:
 
 ```bash
 pip install "orbitquant[hf] @ git+https://github.com/iamwavecut/OrbitQuant.git"
@@ -377,6 +376,7 @@ Published Hub repositories can be checked without downloading tensor weights:
 orbitquant audit-hf-artifacts \
   --namespace WaveCut \
   --policy-inventory-root ./reports/native/module-inventories \
+  --summary-only \
   --fail-on-artifact-regression \
   --output ./reports/native/hf-artifact-audit.json \
   --markdown-output ./reports/native/hf-artifact-audit.md
@@ -512,6 +512,20 @@ Apple Silicon. Full-model speedup claims still require backend-specific
 benchmark artifacts for the target model and native settings. See
 [docs/kernel-audit.md](docs/kernel-audit.md) for the release claim boundary.
 
+To verify that a published OrbitQuant model artifact executes through the
+native packed matmul runtime without running full image/video generation:
+
+```bash
+LOCAL_KERNELS="WaveCut/orbitquant-packed-matmul=/path/to/build/torch212-metal-aarch64-darwin" \
+  uv run python scripts/verify_hf_kernel_model_artifact.py --device mps
+```
+
+The default artifact is `WaveCut/FLUX.2-klein-4B-OrbitQuant-W4A4`. The script
+loads one quantized transformer projection from the artifact, runs it with
+`runtime_mode="native_packed_matmul"`, compares it with `dequant_bf16`, and
+prints JSON with finite-output, allclose, error, and packed-vs-materialized
+weight storage fields.
+
 ## License
 
 Code in this repository is Apache-2.0. Quantized artifacts also record the

{orbitquant-0.1.0 → orbitquant-0.1.2}/README.md

@@ -37,8 +37,7 @@ Install the package with the Hugging Face runtime dependencies:
 pip install "orbitquant[hf]"
 ```
 
-Until the first PyPI release is available, install the same package directly
-from GitHub:
+The development branch can also be installed directly from GitHub:
 
 ```bash
 pip install "orbitquant[hf] @ git+https://github.com/iamwavecut/OrbitQuant.git"
@@ -333,6 +332,7 @@ Published Hub repositories can be checked without downloading tensor weights:
 orbitquant audit-hf-artifacts \
   --namespace WaveCut \
   --policy-inventory-root ./reports/native/module-inventories \
+  --summary-only \
   --fail-on-artifact-regression \
   --output ./reports/native/hf-artifact-audit.json \
   --markdown-output ./reports/native/hf-artifact-audit.md
@@ -468,6 +468,20 @@ Apple Silicon. Full-model speedup claims still require backend-specific
 benchmark artifacts for the target model and native settings. See
 [docs/kernel-audit.md](docs/kernel-audit.md) for the release claim boundary.
 
+To verify that a published OrbitQuant model artifact executes through the
+native packed matmul runtime without running full image/video generation:
+
+```bash
+LOCAL_KERNELS="WaveCut/orbitquant-packed-matmul=/path/to/build/torch212-metal-aarch64-darwin" \
+  uv run python scripts/verify_hf_kernel_model_artifact.py --device mps
+```
+
+The default artifact is `WaveCut/FLUX.2-klein-4B-OrbitQuant-W4A4`. The script
+loads one quantized transformer projection from the artifact, runs it with
+`runtime_mode="native_packed_matmul"`, compares it with `dequant_bf16`, and
+prints JSON with finite-output, allclose, error, and packed-vs-materialized
+weight storage fields.
+
 ## License
 
 Code in this repository is Apache-2.0. Quantized artifacts also record the

{orbitquant-0.1.0 → orbitquant-0.1.2}/docs/kernel-audit.md

@@ -45,6 +45,13 @@ for the current artifact format and runtime modes.
   packed matmul package. Set `ORBITQUANT_RUN_NATIVE_KERNEL_PACKAGE_CI=0` only
   to verify the inline Metal shader stages without closing the native packed
   matmul package gate.
+- `scripts/verify_hf_kernel_model_artifact.py` is a model-artifact verification
+  script for reviewers. It downloads one published OrbitQuant artifact by
+  default, restores one real packed `OrbitQuantLinear` transformer projection,
+  runs it through `runtime_mode="native_packed_matmul"`, compares against
+  `dequant_bf16`, and prints finite-output, allclose, error, and weight-side
+  storage accounting JSON. It intentionally avoids full Diffusers pipeline
+  loading and image/video generation.
 - Full-model speedup claims require backend-specific benchmark artifacts from
   the target model class and native settings. Synthetic kernel benchmarks are
   useful diagnostics, not release evidence for FLUX, Z-Image, or Wan throughput.
@@ -64,11 +71,17 @@ for the current artifact format and runtime modes.
   `upstream`/`source` metadata. The run verified kernel-builder layout hooks,
   macOS 15/Python ABI 3.9 compatibility, get-kernel loading, and 17 package
   tests for the Metal build.
-- A private Hugging Face source snapshot exists at
+- A public Hugging Face source snapshot exists at
   `WaveCut/orbitquant-packed-matmul` commit
-  `6821e4cd5ff1894994d7137c1d861660cfeed1c8`, refreshed on
-  2026-07-08T18:00Z after adding CUDA launch-error checks, but Kernel Hub
-  publication is not yet approved for the account. On 2026-07-08T17:02Z,
+  `cb0ceb1a4d070556c52cfba691aba3f6647c246b`. It contains the tracked
+  `native-kernels/orbitquant-packed-matmul` source package with no generated
+  `build/`, local `.venv/`, `__pycache__/`, binary extension, or benchmark
+  output files. The PyPI `orbitquant-0.1.0.tar.gz` source distribution also
+  contains this kernel source under
+  `orbitquant-0.1.0/native-kernels/orbitquant-packed-matmul/`, with SHA256
+  `6abedb769b32c8d70f2763278e106346319d628d85ed7469549faa5020ab1a89`.
+  Kernel Hub publication is not yet approved for the account. On
+  2026-07-08T17:02Z,
   `nix --option sandbox relaxed run .#build-and-copy -L` built and copied the
   three Metal variants, and
   `nix --option sandbox relaxed run .#build-and-upload -L` found those variants
@@ -79,6 +92,61 @@ for the current artifact format and runtime modes.
   source snapshot `6821e4cd5ff1894994d7137c1d861660cfeed1c8` and source
   archive SHA256
   `77aef6caa1bbdbbd77e2cbf5003423073e001191d008473c957795d7bed03651`.
+  A second follow-up comment on 2026-07-09T11:56Z points reviewers to the
+  public source snapshot, checked commit
+  `b050a89d6e6f52098c73d904a85011231f77485c`, public PyPI source
+  distribution URL, and SHA256.
+  A third follow-up comment on 2026-07-09T12:22Z points reviewers to source
+  snapshot `c34d9851cde2cf098589927a7b0bed85d65426af`, whose benchmark reports
+  both `predequantized_f_linear_seconds_per_iter` and
+  `dequantize_then_f_linear_seconds_per_iter`. That comment explicitly
+  clarifies that the current MPS native packed matmul path is not throughput
+  proof for large matrices: local W4 512x1024x1024 fp16 measured about
+  `0.045x` versus dequantize-then-F.linear, and W4 512x3072x3072 fp16 measured
+  about `0.044x` versus dequantize-then-F.linear. Treat those MPS numbers as
+  correctness and memory-path evidence only, not performance evidence.
+  A fourth follow-up comment on 2026-07-09T12:27Z answered the model-scope
+  question: the kernel is intended for OrbitQuant-converted diffusion
+  transformer backbones with packed `OrbitQuantLinear` layers, currently FLUX.1
+  Schnell, FLUX.2 Klein, Z-Image-Turbo, and Wan2.1-T2V-1.3B-Diffusers; it is
+  not a drop-in kernel for arbitrary unquantized models or skipped components
+  such as text encoders, VAEs, embeddings, timestep MLPs, or final projection
+  heads.
+  The public source snapshot was updated again on 2026-07-09T12:39Z to commit
+  `cb0ceb1a4d070556c52cfba691aba3f6647c246b`; the benchmark now also reports
+  `packed_weight_path_bytes`, `materialized_weight_bytes`, and
+  `packed_weight_path_vs_materialized_weight_ratio` so kernel review can
+  distinguish weight-side storage savings from throughput claims.
+  A fifth follow-up comment on 2026-07-09T12:41Z points reviewers to this
+  snapshot and repeats that the storage fields are memory-path accounting, not
+  large-matrix throughput proof.
+  After reviewer asked for model-level verification scripts,
+  `scripts/verify_hf_kernel_model_artifact.py` was added to verify the default
+  `WaveCut/FLUX.2-klein-4B-OrbitQuant-W4A4` artifact at one restored packed
+  transformer projection without running full generation.
+  A sixth follow-up comment on 2026-07-09T12:50Z points reviewers to commit
+  `f42d2dc19897adde62ec3ebb33e4ce748255dd54` and includes MPS/CUDA
+  `LOCAL_KERNELS` commands for running that verifier.
+  On 2026-07-09T12:57Z, that verifier passed locally on Apple Silicon MPS using
+  the `torch212-metal-aarch64-darwin` local kernel variant and the published
+  `WaveCut/FLUX.2-klein-4B-OrbitQuant-W4A4` artifact. It restored
+  `transformer_blocks.0.attn.to_q` with shape 3072x3072, ran
+  `runtime_mode="native_packed_matmul"` for one token, compared against
+  `dequant_bf16`, and reported `finite=true`, `allclose_to_dequant_bf16=true`,
+  `max_abs_error_vs_dequant_bf16=0.001953125`, and
+  `packed_weight_path_vs_materialized_weight_ratio=0.2503289116753472`.
+  A seventh follow-up comment on 2026-07-09T12:58Z posted the verifier command
+  and JSON result summary to discussion 15.
+  On 2026-07-09T13:05Z, the same published artifact layer was re-verified with
+  `runtime_mode="auto_fused"` and the same local
+  `torch212-metal-aarch64-darwin` package. It again reported `finite=true`,
+  `allclose_to_dequant_bf16=true`,
+  `max_abs_error_vs_dequant_bf16=0.001953125`, and
+  `packed_weight_path_vs_materialized_weight_ratio=0.2503289116753472`.
+  This proves that default optimized dispatch reaches the native packed matmul
+  path for a real published artifact when the local Metal package is available.
+  An eighth follow-up comment on 2026-07-09T13:05Z posted the `auto_fused`
+  command and JSON result summary to discussion 15.
   Re-running `nix --option sandbox relaxed run .#build-and-upload -L` on
   2026-07-08T18:12Z at OrbitQuant commit `956842a` rebuilt the three Metal
   variants, passed ABI/get-kernel build checks, and still stopped at the same
@@ -104,6 +172,80 @@ for the current artifact format and runtime modes.
   `quantize-bench` with exit 0. This verifies the Python/Triton CUDA path and
   packed-weight CUDA runtime fallback behavior, not the separate native CUDA
   kernel-builder package.
+- A public-package CUDA smoke passed on 2026-07-09T13:15Z on the active RunPod
+  `orbitquant-cuda-gate-4090` pod (`ofz7pyxcw6vlzm`) with Torch 2.9.1+cu128,
+  CUDA 12.8, driver 580.159.04, and an NVIDIA GeForce RTX 4090. It installed
+  `orbitquant[kernels]==0.1.0` from PyPI into a temporary `/tmp` venv using
+  `--system-site-packages`, ran `orbitquant kernel-info`, and ran
+  `orbitquant kernel-bench --device cuda --dtype float16 --runtime-mode
+  auto_fused --tokens 16 --in-features 128 --out-features 128 --warmup 1
+  --iterations 2`. The benchmark selected `triton_cuda` for both activation
+  kernels and weight quantization, kept packed weight indices and row norms on
+  `cuda:0`, reported `forward_prewarmed_ms=0.14182400703430176`, and removed
+  the temporary venv after completion. This verifies the published PyPI package
+  CUDA/Triton `auto_fused` path, not the separate native CUDA Kernel Hub
+  package.
+- After a reviewer asked for actual numbers, a model-like CUDA microbenchmark
+  was run on the same pod on 2026-07-09T13:21Z with
+  `orbitquant[kernels]==0.1.0` from PyPI, `tokens=512`, `in_features=3072`,
+  `out_features=3072`, W4A4, float16, warmup 2, and 5 iterations. The
+  `auto_fused` Triton path reported `forward_prewarmed_ms=0.6518784046173096`,
+  `forward_cold_ms=0.6581952095031738`, and `peak_memory_bytes=69293568`.
+  The explicit `dequant_bf16` reference reported
+  `forward_prewarmed_ms=0.13742079734802246`,
+  `forward_cold_ms=0.20090880393981933`, and
+  `peak_memory_bytes=115025408`. These numbers were posted to discussion 15 on
+  2026-07-09T13:22Z with the explicit caveat that current CUDA/Triton
+  `auto_fused` is memory-path evidence, not a throughput win on this RTX 4090
+  microbenchmark.
+- A follow-up tile sweep on the same RTX 4090, PyPI package, and
+  512x3072x3072 W4A4 float16 benchmark found the best tested Triton packed
+  matmul tile at `block_m=32`, `block_n=128`, `block_k=64`, `num_warps=8`.
+  A focused 20-iteration confirmation measured the previous default
+  `block_n=64` at `forward_prewarmed_ms=0.6374400138854981` and the selected
+  `block_n=128` default at `forward_prewarmed_ms=0.596992015838623`, both with
+  `peak_memory_bytes=69293568`. This updates the package default tile for the
+  packed matmul path, but it remains a local CUDA/Triton microbenchmark result
+  and does not change the no-throughput-win claim boundary above.
+- A post-publication CUDA smoke for `orbitquant[kernels]==0.1.1` passed on
+  2026-07-09T14:07Z on the same active RunPod RTX 4090 with Torch 2.9.1+cu128,
+  CUDA 12.8, driver 580.159.04, 512x3072x3072 W4A4 float16, warmup 5, and 20
+  measured iterations. It verified `OrbitQuantConfig().runtime_mode ==
+  "auto_fused"` and `packed_matmul_block_n == 128` from the published package.
+  The `auto_fused` run selected `triton_cuda`, used tile `{block_m=32,
+  block_n=128, block_k=64, num_warps=8}`, kept packed weight indices and row
+  norms on `cuda:0`, and reported
+  `forward_prewarmed_ms=0.5946400165557861`,
+  `forward_cold_ms=0.6080512046813965`, and
+  `peak_memory_bytes=69293568`. The explicit `dequant_bf16` reference reported
+  `forward_prewarmed_ms=0.12743680477142333`,
+  `forward_cold_ms=0.1994752049446106`, and
+  `peak_memory_bytes=115025408`. This confirms the published 0.1.1 CUDA/Triton
+  memory path and tile default; it also confirms that this RTX 4090 isolated
+  benchmark still favors `dequant_bf16` for throughput by about 4.666x.
+- After reviewer asked to run on an actual model, CUDA artifact-layer
+  verification passed on the same active RunPod RTX 4090 on 2026-07-09T13:54Z.
+  The verifier installed OrbitQuant from GitHub `main`, downloaded the
+  published `WaveCut/FLUX.2-klein-4B-OrbitQuant-W4A4` artifact, restored
+  `transformer_blocks.0.attn.to_q` (3072x3072) from source model
+  `black-forest-labs/FLUX.2-klein-4B` revision
+  `e7b7dc27f91deacad38e78976d1f2b499d76a294`, and ran 512 float16 tokens
+  through `runtime_mode="auto_fused"` with
+  `activation_kernel_backend="triton_cuda"`. The run used Torch 2.9.1+cu128,
+  CUDA 12.8, driver 580.159.04, W4A4, warmup 5, and 20 measured iterations. It
+  reported `finite=true`, `allclose_to_dequant_bf16=true`,
+  `max_abs_error_vs_dequant_bf16=0.015625`,
+  `packed_weight_path_bytes=4724800`, `materialized_weight_bytes=18874368`,
+  `packed_weight_path_vs_materialized_weight_ratio=0.2503289116753472`,
+  `peak_memory_bytes=87756800`,
+  `auto_fused_forward_first_ms=477.2464599609375`,
+  `auto_fused_forward_prewarmed_ms=0.6343167781829834`,
+  `dequant_bf16_forward_first_ms=103.32876586914062`, and
+  `dequant_bf16_forward_prewarmed_ms=0.1256432056427002`. This is actual
+  published artifact layer execution, not full FLUX image generation; it
+  supports the CUDA/Triton memory-path claim but not a throughput-win claim.
+  A follow-up comment with these actual model artifact numbers was posted to
+  discussion 15 on 2026-07-09T14:00Z.
 - Native CUDA `native_packed_matmul` still needs a compatible loadable variant.
   A locally built `build/torch29-cxx11-cu130-x86_64-linux` variant was copied
   to the same CUDA 12.8 host and failed before execution with
@@ -138,8 +280,9 @@ for the current artifact format and runtime modes.
   and benchmark stages were explicitly skipped.
 - On 2026-07-09, a prebuilt-only native loader check still found no loadable
   CUDA/Metal Kernel Hub artifact: `repo_info(..., repo_type="kernel")`
-  returned 404 while the source snapshot model repo resolved to commit
-  `6821e4cd5ff1894994d7137c1d861660cfeed1c8`. The native loader therefore
+  returned 404. After the storage-footprint benchmark update, the public source
+  snapshot model repo resolved to commit
+  `cb0ceb1a4d070556c52cfba691aba3f6647c246b`. The native loader therefore
   still requires `LOCAL_KERNELS`, an importable package, or Kernel Hub approval.
 
 ## Packaging Boundary

orbitquant-0.1.2/docs/kernel-hub-approval-request.md

@@ -0,0 +1,290 @@
+# Kernel Hub Approval Request
+
+Use this as the source text for the Hugging Face `kernels-community/README`
+discussion requested by `kernel-builder build-and-upload`:
+
+`https://huggingface.co/spaces/kernels-community/README/discussions/new`
+
+Submitted discussion:
+
+`https://huggingface.co/spaces/kernels-community/README/discussions/15`
+
+Follow-up comment:
+
+On 2026-07-08T18:03Z, the discussion was updated with source snapshot
+`6821e4cd5ff1894994d7137c1d861660cfeed1c8` and source archive SHA256
+`77aef6caa1bbdbbd77e2cbf5003423073e001191d008473c957795d7bed03651`.
+
+Reviewer follow-up:
+
+On 2026-07-09T07:29Z, `sayakpaul` reported that the source snapshot repo URL
+was not visible and asked for performance numbers. On 2026-07-09T09:59Z,
+`WaveCut` replied without changing repository visibility: the source snapshot
+repo is still private, the tracked source archive SHA256 is
+`77aef6caa1bbdbbd77e2cbf5003423073e001191d008473c957795d7bed03651`, and the
+reply offered either a public source-only snapshot repo or a source archive
+through the preferred review channel. The reply also restated the MPS native
+packed matmul smoke benchmark numbers and the CUDA/Triton partial gate evidence,
+while keeping native CUDA package numbers pending.
+
+Source visibility follow-up:
+
+As of 2026-07-09T11:54Z, `WaveCut/orbitquant-packed-matmul` is public as a
+source snapshot repo:
+
+`https://huggingface.co/WaveCut/orbitquant-packed-matmul`
+
+The live checked commit is
+`cb0ceb1a4d070556c52cfba691aba3f6647c246b`. Its file list contains only the
+tracked source/test files and no generated `build/`, local `.venv/`,
+`__pycache__/`, binary `.so`, or benchmark output files.
+
+The public PyPI source distribution also contains the reviewable kernel source:
+
+- PyPI project: `https://pypi.org/project/orbitquant/0.1.0/`
+- Source distribution:
+  `https://files.pythonhosted.org/packages/c8/41/1df33fe61ff5638a0b9385bbe0493353b62cfd8f39dd1ee7481487f92ed0/orbitquant-0.1.0.tar.gz`
+- SHA256:
+  `6abedb769b32c8d70f2763278e106346319d628d85ed7469549faa5020ab1a89`
+- Kernel path inside the archive:
+  `orbitquant-0.1.0/native-kernels/orbitquant-packed-matmul/`
+
+The older source archive was locally prepared and checked on 2026-07-08T18:00Z:
+`/tmp/orbitquant-packed-matmul-source.tar`, SHA256
+`77aef6caa1bbdbbd77e2cbf5003423073e001191d008473c957795d7bed03651`,
+21 tar entries, and no generated `build/`, local `.venv/`, `__pycache__/`,
+binary `.so`, or benchmark output files.
+
+On 2026-07-09T11:56Z, `WaveCut` posted a follow-up comment in discussion 15
+with the public source snapshot URL, checked commit, PyPI source distribution
+URL, SHA256, and the same claim boundary: MPS native packed-matmul smoke
+numbers plus CUDA/Triton gate evidence are available, while native CUDA
+`native_packed_matmul` package numbers remain pending a compatible Kernel
+Hub/CUDA build path.
+
+On 2026-07-09T12:22Z, `WaveCut` posted another follow-up comment after
+updating the benchmark source to snapshot
+`c34d9851cde2cf098589927a7b0bed85d65426af`. The updated benchmark reports both
+`predequantized_f_linear_seconds_per_iter` and
+`dequantize_then_f_linear_seconds_per_iter`. The comment explicitly says the
+current MPS native packed-matmul path is not throughput proof for large
+matrices: local W4 512x1024x1024 fp16 measured about `0.045x` versus
+dequantize-then-F.linear, and W4 512x3072x3072 fp16 measured about `0.044x`
+versus dequantize-then-F.linear. The current CUDA source uses WMMA for
+FP16/BF16 low-bit modes, but native CUDA package benchmarks remain pending a
+compatible Kernel Hub/CUDA build path.
+
+On 2026-07-09T12:27Z, `WaveCut` answered the model-scope question. The kernel
+is model-agnostic at the operator level, but intended for OrbitQuant-converted
+diffusion transformer backbones with packed `OrbitQuantLinear` layers. Current
+target families are FLUX.1-schnell, FLUX.2 Klein, Z-Image-Turbo, and
+Wan2.1-T2V-1.3B-Diffusers. The kernel is not intended for arbitrary
+unquantized models, text encoders, VAEs, embeddings, timestep MLPs, or final
+projection heads.
+
+On 2026-07-09T12:39Z, the public source snapshot was updated to commit
+`cb0ceb1a4d070556c52cfba691aba3f6647c246b`. The benchmark JSON now reports
+packed weight storage fields:
+`packed_weight_indices_bytes`, `row_norms_bytes`, `centroid_bytes`,
+`packed_weight_path_bytes`, `materialized_weight_bytes`, and
+`packed_weight_path_vs_materialized_weight_ratio`.
+
+On 2026-07-09T12:41Z, `WaveCut` posted a follow-up comment in discussion 15
+with the `cb0ceb1a4d070556c52cfba691aba3f6647c246b` source snapshot URL and
+the same claim boundary: the new fields are weight-side storage accounting,
+not throughput proof; native CUDA package benchmark evidence remains pending a
+compatible Kernel Hub/CUDA build path.
+
+On 2026-07-09T12:42Z, `sayakpaul` asked for a way to try optimizing one target
+model with these kernels. The repository now includes
+`scripts/verify_hf_kernel_model_artifact.py`, which verifies one published
+OrbitQuant artifact layer through `runtime_mode="native_packed_matmul"` and
+compares it with `dequant_bf16` without loading the full Diffusers pipeline or
+running image/video generation.
+
+On 2026-07-09T12:50Z, `WaveCut` replied with the verification script commit
+`f42d2dc19897adde62ec3ebb33e4ce748255dd54`, MPS and CUDA `LOCAL_KERNELS`
+example commands, and the expected behavior when no loadable native kernel is
+available.
+
+On 2026-07-09T12:57Z, the verifier passed locally on Apple Silicon MPS with
+the `torch212-metal-aarch64-darwin` local kernel variant and the published
+`WaveCut/FLUX.2-klein-4B-OrbitQuant-W4A4` artifact. It verified
+`transformer_blocks.0.attn.to_q` (3072x3072) with
+`runtime_mode="native_packed_matmul"` against `dequant_bf16` and reported
+`finite=true`, `allclose_to_dequant_bf16=true`,
+`max_abs_error_vs_dequant_bf16=0.001953125`, and
+`packed_weight_path_vs_materialized_weight_ratio=0.2503289116753472`.
+
+On 2026-07-09T12:58Z, `WaveCut` posted that verifier command and JSON result
+summary in discussion 15.
+
+On 2026-07-09T13:05Z, the same published artifact layer was re-verified with
+`runtime_mode="auto_fused"` and the same local `torch212-metal-aarch64-darwin`
+package. It again reported `finite=true`, `allclose_to_dequant_bf16=true`,
+`max_abs_error_vs_dequant_bf16=0.001953125`, and
+`packed_weight_path_vs_materialized_weight_ratio=0.2503289116753472`. This
+checks the default optimized dispatch path, not only the explicit
+`native_packed_matmul` mode.
+
+On 2026-07-09T13:05Z, `WaveCut` posted that `auto_fused` verifier command and
+JSON result summary in discussion 15.
+
+On 2026-07-09T13:08Z, `sayakpaul` asked for actual reported numbers rather
+than another script reference. A model-like CUDA microbenchmark was then run on
+the active RTX 4090 RunPod with `orbitquant[kernels]==0.1.0` from PyPI, Torch
+2.9.1+cu128, CUDA 12.8, driver 580.159.04, `tokens=512`,
+`in_features=3072`, `out_features=3072`, W4A4, float16, warmup 2, and
+5 iterations. The `auto_fused` Triton path reported
+`forward_prewarmed_ms=0.6518784046173096`,
+`forward_cold_ms=0.6581952095031738`, and `peak_memory_bytes=69293568`. The
+explicit `dequant_bf16` reference reported
+`forward_prewarmed_ms=0.13742079734802246`,
+`forward_cold_ms=0.20090880393981933`, and
+`peak_memory_bytes=115025408`.
+
+On 2026-07-09T13:22Z, `WaveCut` posted those numbers in discussion 15 and
+explicitly stated that the current CUDA/Triton `auto_fused` result is
+memory-path evidence, not a throughput win on this RTX 4090 microbenchmark.
+
+On 2026-07-09T13:54Z, after `sayakpaul` asked to run on an actual model, a
+CUDA verifier passed on the active RTX 4090 RunPod using the published
+`WaveCut/FLUX.2-klein-4B-OrbitQuant-W4A4` artifact. It restored
+`transformer_blocks.0.attn.to_q` (3072x3072) from source model
+`black-forest-labs/FLUX.2-klein-4B` revision
+`e7b7dc27f91deacad38e78976d1f2b499d76a294`, ran 512 float16 tokens through
+`runtime_mode="auto_fused"` with `activation_kernel_backend="triton_cuda"`,
+and compared against `dequant_bf16`. The environment was Torch 2.9.1+cu128,
+CUDA 12.8, driver 580.159.04, W4A4, warmup 5, and 20 measured iterations. The
+result was `finite=true`, `allclose_to_dequant_bf16=true`,
+`max_abs_error_vs_dequant_bf16=0.015625`,
+`packed_weight_path_bytes=4724800`, `materialized_weight_bytes=18874368`,
+`packed_weight_path_vs_materialized_weight_ratio=0.2503289116753472`,
+`peak_memory_bytes=87756800`,
+`auto_fused_forward_prewarmed_ms=0.6343167781829834`, and
+`dequant_bf16_forward_prewarmed_ms=0.1256432056427002`. This is actual
+published model artifact layer execution for CUDA/Triton; it is not full
+image generation and it does not change the native CUDA Kernel Hub package
+approval blocker.
+
+On 2026-07-09T14:00Z, `WaveCut` posted those actual model artifact numbers in
+discussion 15.
+
+## Title
+
+Request Kernel Hub publish access for `WaveCut/orbitquant-packed-matmul`
+
+## Body
+
+We would like Kernel Hub publish access to publish
+`WaveCut/orbitquant-packed-matmul` as a Hugging Face Kernel Hub package.
+
+Repository:
+
+- Kernel Hub repo id: `WaveCut/orbitquant-packed-matmul`
+- Source package path: `native-kernels/orbitquant-packed-matmul`
+- Source repository: `https://github.com/iamwavecut/OrbitQuant`
+- Review source snapshot: `https://huggingface.co/WaveCut/orbitquant-packed-matmul/commit/cb0ceb1a4d070556c52cfba691aba3f6647c246b`
+- License: Apache-2.0
+
+Review-ready source package:
+
+The public source snapshot repo contains the reviewable tracked source snapshot
+at:
+
+`https://huggingface.co/WaveCut/orbitquant-packed-matmul/commit/cb0ceb1a4d070556c52cfba691aba3f6647c246b`
+
+If a source archive is requested instead, generate it from the Git-tracked
+kernel package path:
+
+```bash
+git archive --format=tar \
+  --prefix=orbitquant-packed-matmul/ \
+  HEAD:native-kernels/orbitquant-packed-matmul \
+  > /tmp/orbitquant-packed-matmul-source.tar
+```
+
+The archive should contain only the tracked source and test files:
+
+- `build.toml`
+- `CARD.md`
+- `example.py`
+- `flake.nix`
+- `flake.lock`
+- `benchmarks/benchmark.py`
+- `tests/__init__.py`
+- `tests/test_packed_matmul.py`
+- `torch-ext/orbitquant_packed_matmul/__init__.py`
+- `torch-ext/torch_binding.cpp`
+- `torch-ext/torch_binding.h`
+- `orbitquant_packed_matmul_cuda/packed_matmul.cu`
+- `orbitquant_packed_matmul_metal/packed_matmul.mm`
+- `orbitquant_packed_matmul_metal/packed_matmul.metal`
+
+Do not attach generated `build/`, local `.venv/`, `__pycache__/`, or benchmark
+output directories as source material.
+
+Purpose:
+
+`orbitquant-packed-matmul` implements packed low-bit matrix multiplication for
+OrbitQuant inference. It consumes packed OrbitQuant weight codebook indices,
+per-row norms, Lloyd-Max centroids, and optional bias directly, avoiding a full
+BF16/FP16 dequantized weight matrix before the linear projection.
+
+Ecosystem fit:
+
+- Primary library: `orbitquant`
+- Target integrations: Hugging Face Diffusers, Hugging Face Transformers, and
+  ComfyUI-OrbitQuant
+- Target model families: image and video diffusion transformers, including
+  FLUX.2 Klein, FLUX.1-schnell, Z-Image-Turbo, and Wan2.1 T2V
+- Runtime role: default `auto_fused` path prefers this native packed matmul
+  package on CUDA/MPS, with explicit `dequant_bf16` available as reference mode
+
+Kernel-builder compliance:
+
+- Uses `build.toml` and `kernel-builder`
+- Uses ABI3-safe `TORCH_LIBRARY_EXPAND(TORCH_EXTENSION_NAME, ops)` bindings
+- Does not use pybind11, `torch/extension.h`, `setup.py`, or hardcoded
+  `torch.ops` namespaces
+- Package tests cover 2/3/4/6-bit packed matmul with and without bias
+
+Current build and verification status:
+
+- Local kernel-builder CI passed with
+  `nix --option sandbox relaxed run .#ci-test -L`
+- Local Metal builds passed ABI compatibility checks for Python ABI 3.9
+- Local MPS OrbitQuant gate passed with `runtime_mode="native_packed_matmul"`
+  through `LOCAL_KERNELS`
+- `build-and-copy` currently builds 3 local Metal variants
+- `build-and-upload` finds those 3 variants and then stops at Kernel Hub
+  publish permission, which is why publish access is needed
+
+Benchmark status:
+
+- MPS smoke benchmarks from the local `torch212-metal-aarch64-darwin` package
+  variant on Apple Silicon with Torch 2.12.1:
+  - W4, 512 rows, 1024 input features, 1024 output features, float16:
+    `0.00764581459807232` seconds/iteration over 20 iterations.
+  - W4, 512 rows, 3072 input features, 3072 output features, float16:
+    `0.10189520000712946` seconds/iteration over 10 iterations.
+- MPS native packed matmul is currently not throughput-competitive with the
+  PyTorch baselines on the large local shapes above; treat those values as
+  correctness and memory-path evidence only.
+- CUDA native package benchmark evidence is pending a compatible CUDA
+  kernel-builder or Kernel Hub build path.
+
+Requested approval:
+
+Please enable Kernel Hub publish access for the `WaveCut` publisher namespace
+so this package can be uploaded as a `kernel`-type repository and loaded with:
+
+```python
+from kernels import get_kernel
+
+kernel = get_kernel(
+    "WaveCut/orbitquant-packed-matmul",
+    version=1,
+    trust_remote_code=True,
+)
+```