@simulatte/doppler 0.1.9 → 0.2.0

package/src/gpu/kernels/dequant_f16_out.wgsl

@@ -1,153 +0,0 @@
-// Q4_K Dequantization Kernel - f16 Output
-//
-// Dequantizes Q4_K blocks directly to f16 to avoid an intermediate f32 buffer
-// when weights will be consumed by f16-weight matmul kernels.
-//
-// llama.cpp Q4_K format:
-//   - 256 elements per super-block
-//   - 8 sub-blocks of 32 elements each
-//   - 12 bytes encode 8 scales + 8 mins (6 bits each, packed)
-//   - 128 bytes of 4-bit quantized values
-
-enable f16;
-
-// Q4_K constants
-const QK_K: u32 = 256u;
-const SUBBLOCK_SIZE: u32 = 32u;
-
-// Tunable workgroup size
-override WORKGROUP_SIZE_MAIN: u32 = 256u;
-
-struct Uniforms {
-    num_blocks: u32,
-    output_offset: u32,
-    _pad0: u32,
-    _pad1: u32,
-}
-
-struct Q4KBlock {
-    d: u32,
-    scales: array<u32, 3>,
-    qs: array<u32, 32>,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> quantized: array<Q4KBlock>;
-@group(0) @binding(2) var<storage, read_write> output: array<f16>;
-
-var<workgroup> shared_scales: array<f32, 8>;
-var<workgroup> shared_mins: array<f32, 8>;
-var<workgroup> shared_d: f32;
-var<workgroup> shared_dmin: f32;
-
-fn unpack_f16_lo(packed: u32) -> f32 {
-    return unpack2x16float(packed).x;
-}
-
-fn unpack_f16_hi(packed: u32) -> f32 {
-    return unpack2x16float(packed).y;
-}
-
-// Get byte from scales array (12 bytes packed as 3 u32)
-fn get_scale_byte(scales: array<u32, 3>, byte_idx: u32) -> u32 {
-    let word_idx = byte_idx / 4u;
-    let byte_in_word = byte_idx % 4u;
-    return (scales[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-}
-
-// llama.cpp Q4_K scale/min extraction (get_scale_min_k4):
-// For sub-blocks 0-3: simple 6-bit extraction
-// For sub-blocks 4-7: complex packing with upper bits from earlier bytes
-fn get_scale_min_k4(scales: array<u32, 3>, j: u32) -> vec2<u32> {
-    var sc: u32;
-    var mn: u32;
-
-    if (j < 4u) {
-        // Simple case: lower 6 bits
-        sc = get_scale_byte(scales, j) & 63u;
-        mn = get_scale_byte(scales, j + 4u) & 63u;
-    } else {
-        // Complex case: 4 bits from bytes 8-11, upper 2 bits from bytes 0-7
-        let q_j = get_scale_byte(scales, j + 4u);  // bytes 8-11
-        let q_lo = get_scale_byte(scales, j - 4u); // bytes 0-3 (for upper bits of scale)
-        let q_hi = get_scale_byte(scales, j);      // bytes 4-7 (for upper bits of min)
-
-        sc = (q_j & 0xFu) | ((q_lo >> 6u) << 4u);
-        mn = (q_j >> 4u) | ((q_hi >> 6u) << 4u);
-    }
-
-    return vec2<u32>(sc, mn);
-}
-
-// Extract 4-bit quantized value
-// Q4_K nibble layout per 64-element chunk:
-//   - Elements 0-31: lower nibbles of 32 bytes
-//   - Elements 32-63: upper nibbles of same 32 bytes
-// Layout: chunk0 (elem 0-63) uses bytes 0-31
-//         chunk1 (elem 64-127) uses bytes 32-63
-//         chunk2 (elem 128-191) uses bytes 64-95
-//         chunk3 (elem 192-255) uses bytes 96-127
-fn get_q4(qs: array<u32, 32>, idx: u32) -> u32 {
-    // Which 64-element chunk? (0-3)
-    let chunk = idx / 64u;
-    // Position within chunk (0-63)
-    let pos_in_chunk = idx % 64u;
-    // First or second half of chunk?
-    let use_upper = pos_in_chunk >= 32u;
-    // Byte index within the 32-byte range for this chunk
-    let byte_in_range = select(pos_in_chunk, pos_in_chunk - 32u, use_upper);
-    // Absolute byte index
-    let byte_idx = chunk * 32u + byte_in_range;
-
-    let word_idx = byte_idx / 4u;
-    let byte_in_word = byte_idx % 4u;
-    let byte_val = (qs[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-
-    if (use_upper) {
-        return (byte_val >> 4u) & 0xFu;
-    } else {
-        return byte_val & 0xFu;
-    }
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE_MAIN, 1, 1)
-fn main(
-    @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>,
-    @builtin(num_workgroups) num_wg: vec3<u32>
-) {
-    // Support 2D dispatch for tensors with >65535 blocks.
-    let block_idx = workgroup_id.x + workgroup_id.y * num_wg.x;
-    let elem_idx = local_id.x;
-
-    if (block_idx >= u.num_blocks) {
-        return;
-    }
-
-    let block = quantized[block_idx];
-
-    if (elem_idx == 0u) {
-        shared_d = unpack_f16_lo(block.d);
-        shared_dmin = unpack_f16_hi(block.d);
-    }
-
-    // Threads 0-7 load scales and mins for 8 sub-blocks
-    if (elem_idx < 8u) {
-        let sm = get_scale_min_k4(block.scales, elem_idx);
-        shared_scales[elem_idx] = f32(sm.x);
-        shared_mins[elem_idx] = f32(sm.y);
-    }
-
-    workgroupBarrier();
-
-    let subblock_idx = elem_idx / SUBBLOCK_SIZE;  // 0-7
-    let scale = shared_d * shared_scales[subblock_idx];
-    let min_val = shared_dmin * shared_mins[subblock_idx];
-
-    let q = get_q4(block.qs, elem_idx);
-    // llama.cpp formula: dequant = d * scale * q - dmin * min
-    let dequant = scale * f32(q) - min_val;
-
-    let out_idx = u.output_offset + block_idx * QK_K + elem_idx;
-    output[out_idx] = f16(dequant);
-}

package/src/gpu/kernels/dequant_f16_out_vec4.wgsl

@@ -1,152 +0,0 @@
-// Q4_K Dequantization Kernel - f16 Output (vec4)
-//
-// Vectorized dequantization to f16 output for Q4_K blocks.
-
-enable f16;
-
-// Q4_K constants
-const QK_K: u32 = 256u;
-const SUBBLOCK_SIZE: u32 = 32u;
-
-// Tunable workgroup size
-override WORKGROUP_SIZE_VEC4: u32 = 64u;
-
-struct Uniforms {
-    num_blocks: u32,
-    output_offset: u32,
-    _pad0: u32,
-    _pad1: u32,
-}
-
-struct Q4KBlock {
-    d: u32,
-    scales: array<u32, 3>,
-    qs: array<u32, 32>,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> quantized: array<Q4KBlock>;
-@group(0) @binding(2) var<storage, read_write> output: array<f16>;
-
-var<workgroup> shared_scales: array<f32, 8>;
-var<workgroup> shared_mins: array<f32, 8>;
-var<workgroup> shared_d: f32;
-var<workgroup> shared_dmin: f32;
-
-fn unpack_f16_lo(packed: u32) -> f32 {
-    return unpack2x16float(packed).x;
-}
-
-fn unpack_f16_hi(packed: u32) -> f32 {
-    return unpack2x16float(packed).y;
-}
-
-// Get byte from scales array (12 bytes packed as 3 u32)
-fn get_scale_byte(scales: array<u32, 3>, byte_idx: u32) -> u32 {
-    let word_idx = byte_idx / 4u;
-    let byte_in_word = byte_idx % 4u;
-    return (scales[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-}
-
-// llama.cpp Q4_K scale/min extraction (get_scale_min_k4):
-// For sub-blocks 0-3: simple 6-bit extraction
-// For sub-blocks 4-7: complex packing with upper bits from earlier bytes
-fn get_scale_min_k4(scales: array<u32, 3>, j: u32) -> vec2<u32> {
-    var sc: u32;
-    var mn: u32;
-
-    if (j < 4u) {
-        // Simple case: lower 6 bits
-        sc = get_scale_byte(scales, j) & 63u;
-        mn = get_scale_byte(scales, j + 4u) & 63u;
-    } else {
-        // Complex case: 4 bits from bytes 8-11, upper 2 bits from bytes 0-7
-        let q_j = get_scale_byte(scales, j + 4u);  // bytes 8-11
-        let q_lo = get_scale_byte(scales, j - 4u); // bytes 0-3 (for upper bits of scale)
-        let q_hi = get_scale_byte(scales, j);      // bytes 4-7 (for upper bits of min)
-
-        sc = (q_j & 0xFu) | ((q_lo >> 6u) << 4u);
-        mn = (q_j >> 4u) | ((q_hi >> 6u) << 4u);
-    }
-
-    return vec2<u32>(sc, mn);
-}
-
-// Extract 4-bit quantized value
-// Q4_K nibble layout per 64-element chunk:
-//   - Elements 0-31: lower nibbles of 32 bytes
-//   - Elements 32-63: upper nibbles of same 32 bytes
-// Layout: chunk0 (elem 0-63) uses bytes 0-31
-//         chunk1 (elem 64-127) uses bytes 32-63
-//         chunk2 (elem 128-191) uses bytes 64-95
-//         chunk3 (elem 192-255) uses bytes 96-127
-fn get_q4(qs: array<u32, 32>, idx: u32) -> u32 {
-    // Which 64-element chunk? (0-3)
-    let chunk = idx / 64u;
-    // Position within chunk (0-63)
-    let pos_in_chunk = idx % 64u;
-    // First or second half of chunk?
-    let use_upper = pos_in_chunk >= 32u;
-    // Byte index within the 32-byte range for this chunk
-    let byte_in_range = select(pos_in_chunk, pos_in_chunk - 32u, use_upper);
-    // Absolute byte index
-    let byte_idx = chunk * 32u + byte_in_range;
-
-    let word_idx = byte_idx / 4u;
-    let byte_in_word = byte_idx % 4u;
-    let byte_val = (qs[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-
-    if (use_upper) {
-        return (byte_val >> 4u) & 0xFu;
-    } else {
-        return byte_val & 0xFu;
-    }
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE_VEC4, 1, 1)
-fn main_vec4(
-    @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>,
-    @builtin(num_workgroups) num_wg: vec3<u32>
-) {
-    // Support 2D dispatch for tensors with >65535 blocks (e.g. large FFN weights).
-    // block_idx = flat workgroup index across both X and Y dimensions.
-    let block_idx = workgroup_id.x + workgroup_id.y * num_wg.x;
-    let thread_idx = local_id.x;
-
-    if (block_idx >= u.num_blocks) {
-        return;
-    }
-
-    let block = quantized[block_idx];
-
-    if (thread_idx == 0u) {
-        shared_d = unpack_f16_lo(block.d);
-        shared_dmin = unpack_f16_hi(block.d);
-    }
-
-    // Threads 0-7 load scales and mins for 8 sub-blocks
-    if (thread_idx < 8u) {
-        let sm = get_scale_min_k4(block.scales, thread_idx);
-        shared_scales[thread_idx] = f32(sm.x);
-        shared_mins[thread_idx] = f32(sm.y);
-    }
-
-    workgroupBarrier();
-
-    let d = shared_d;
-    let dmin = shared_dmin;
-
-    let base_elem = thread_idx * 4u;
-    let subblock_idx = base_elem / SUBBLOCK_SIZE;  // 0-7
-    let scale = d * shared_scales[subblock_idx];
-    let min_val = dmin * shared_mins[subblock_idx];
-
-    let out_base = u.output_offset + block_idx * QK_K + base_elem;
-
-    // llama.cpp formula: dequant = d * scale * q - dmin * min
-    output[out_base + 0u] = f16(scale * f32(get_q4(block.qs, base_elem + 0u)) - min_val);
-    output[out_base + 1u] = f16(scale * f32(get_q4(block.qs, base_elem + 1u)) - min_val);
-    output[out_base + 2u] = f16(scale * f32(get_q4(block.qs, base_elem + 2u)) - min_val);
-    output[out_base + 3u] = f16(scale * f32(get_q4(block.qs, base_elem + 3u)) - min_val);
-}

package/src/gpu/kernels/dequant_f16_rowwise.wgsl

@@ -1,139 +0,0 @@
-// Q4_K Dequantization Kernel - f16 Output, Row-Wise Matrix Layout
-//
-// Dequantizes Q4_K blocks to f16 with proper row-major matrix stride.
-// Required when K (columns) is not aligned to QK_K (256), as the block
-// layout has padding that must be skipped.
-//
-// Example: For K=1152, each row has 5 blocks (5*256=1280 elements stored),
-// but only 1152 elements are valid. This kernel outputs [rows, K] shape
-// with stride K, not stride blocksPerRow*256.
-
-enable f16;
-
-// Q4_K constants
-const QK_K: u32 = 256u;
-const SUBBLOCK_SIZE: u32 = 32u;
-
-// Tunable workgroup size
-override WORKGROUP_SIZE_MAIN: u32 = 256u;
-
-struct Uniforms {
-    num_blocks: u32,
-    blocks_per_row: u32,
-    K: u32,               // actual columns (may not be 256-aligned)
-    rows: u32,
-}
-
-struct Q4KBlock {
-    d: u32,
-    scales: array<u32, 3>,
-    qs: array<u32, 32>,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> quantized: array<Q4KBlock>;
-@group(0) @binding(2) var<storage, read_write> output: array<f16>;
-
-var<workgroup> shared_scales: array<f32, 8>;
-var<workgroup> shared_mins: array<f32, 8>;
-var<workgroup> shared_d: f32;
-var<workgroup> shared_dmin: f32;
-
-fn unpack_f16_lo(packed: u32) -> f32 {
-    return unpack2x16float(packed).x;
-}
-
-fn unpack_f16_hi(packed: u32) -> f32 {
-    return unpack2x16float(packed).y;
-}
-
-fn get_scale_byte(scales: array<u32, 3>, byte_idx: u32) -> u32 {
-    let word_idx = byte_idx / 4u;
-    let byte_in_word = byte_idx % 4u;
-    return (scales[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-}
-
-fn get_scale_min_k4(scales: array<u32, 3>, j: u32) -> vec2<u32> {
-    var sc: u32;
-    var mn: u32;
-
-    if (j < 4u) {
-        sc = get_scale_byte(scales, j) & 63u;
-        mn = get_scale_byte(scales, j + 4u) & 63u;
-    } else {
-        let q_j = get_scale_byte(scales, j + 4u);
-        let q_lo = get_scale_byte(scales, j - 4u);
-        let q_hi = get_scale_byte(scales, j);
-        sc = (q_j & 0xFu) | ((q_lo >> 6u) << 4u);
-        mn = (q_j >> 4u) | ((q_hi >> 6u) << 4u);
-    }
-
-    return vec2<u32>(sc, mn);
-}
-
-fn get_q4(qs: array<u32, 32>, idx: u32) -> u32 {
-    let chunk = idx / 64u;
-    let pos_in_chunk = idx % 64u;
-    let use_upper = pos_in_chunk >= 32u;
-    let byte_in_range = select(pos_in_chunk, pos_in_chunk - 32u, use_upper);
-    let byte_idx = chunk * 32u + byte_in_range;
-
-    let word_idx = byte_idx / 4u;
-    let byte_in_word = byte_idx % 4u;
-    let byte_val = (qs[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-
-    if (use_upper) {
-        return (byte_val >> 4u) & 0xFu;
-    } else {
-        return byte_val & 0xFu;
-    }
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE_MAIN, 1, 1)
-fn main(
-    @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>
-) {
-    let block_idx = workgroup_id.x;
-    let elem_idx = local_id.x;
-
-    if (block_idx >= u.num_blocks) {
-        return;
-    }
-
-    let block = quantized[block_idx];
-
-    if (elem_idx == 0u) {
-        shared_d = unpack_f16_lo(block.d);
-        shared_dmin = unpack_f16_hi(block.d);
-    }
-
-    if (elem_idx < 8u) {
-        let sm = get_scale_min_k4(block.scales, elem_idx);
-        shared_scales[elem_idx] = f32(sm.x);
-        shared_mins[elem_idx] = f32(sm.y);
-    }
-
-    workgroupBarrier();
-
-    // Calculate row and column from block index
-    let row = block_idx / u.blocks_per_row;
-    let block_in_row = block_idx % u.blocks_per_row;
-    let col = block_in_row * QK_K + elem_idx;
-
-    // Skip elements beyond actual K (padding)
-    if (col >= u.K) {
-        return;
-    }
-
-    let subblock_idx = elem_idx / SUBBLOCK_SIZE;
-    let scale = shared_d * shared_scales[subblock_idx];
-    let min_val = shared_dmin * shared_mins[subblock_idx];
-
-    let q = get_q4(block.qs, elem_idx);
-    let dequant = scale * f32(q) - min_val;
-
-    // Write with proper row-major stride
-    let out_idx = row * u.K + col;
-    output[out_idx] = f16(dequant);
-}

package/src/gpu/kernels/dequant_f32_rowwise.wgsl

@@ -1,133 +0,0 @@
-// Q4_K Dequantization Kernel - f32 Output, Row-Wise Matrix Layout
-//
-// Dequantizes Q4_K blocks to f32 with proper row-major matrix stride.
-// Required when K (columns) is not aligned to QK_K (256), as the block
-// layout has padding that must be skipped.
-//
-// Example: For K=1152, each row has 5 blocks (5*256=1280 elements stored),
-// but only 1152 elements are valid. This kernel outputs [rows, K] shape
-// with stride K, not stride blocksPerRow*256.
-
-// Q4_K constants
-const QK_K: u32 = 256u;
-const SUBBLOCK_SIZE: u32 = 32u;
-
-// Tunable workgroup size
-override WORKGROUP_SIZE_MAIN: u32 = 256u;
-
-struct Uniforms {
-    num_blocks: u32,
-    blocks_per_row: u32,
-    K: u32,               // actual columns (may not be 256-aligned)
-    rows: u32,
-}
-
-struct Q4KBlock {
-    d: u32,
-    scales: array<u32, 3>,
-    qs: array<u32, 32>,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> quantized: array<Q4KBlock>;
-@group(0) @binding(2) var<storage, read_write> output: array<f32>;
-
-var<workgroup> shared_scales: array<f32, 8>;
-var<workgroup> shared_mins: array<f32, 8>;
-var<workgroup> shared_d: f32;
-var<workgroup> shared_dmin: f32;
-
-fn unpack_f16_lo(packed: u32) -> f32 {
-    return unpack2x16float(packed).x;
-}
-
-fn unpack_f16_hi(packed: u32) -> f32 {
-    return unpack2x16float(packed).y;
-}
-
-fn get_scale_byte(scales: array<u32, 3>, byte_idx: u32) -> u32 {
-    let word_idx = byte_idx / 4u;
-    let byte_in_word = byte_idx % 4u;
-    return (scales[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-}
-
-fn get_scale_min_k4(scales: array<u32, 3>, j: u32) -> vec2<u32> {
-    var sc: u32;
-    var mn: u32;
-
-    if (j < 4u) {
-        sc = get_scale_byte(scales, j) & 63u;
-        mn = get_scale_byte(scales, j + 4u) & 63u;
-    } else {
-        let q_j = get_scale_byte(scales, j + 4u);
-        let q_lo = get_scale_byte(scales, j - 4u);
-        let q_hi = get_scale_byte(scales, j);
-        sc = (q_j & 0xFu) | ((q_lo >> 6u) << 4u);
-        mn = (q_j >> 4u) | ((q_hi >> 6u) << 4u);
-    }
-
-    return vec2<u32>(sc, mn);
-}
-
-fn get_q4(qs: array<u32, 32>, idx: u32) -> u32 {
-    let chunk = idx / 64u;
-    let pos_in_chunk = idx % 64u;
-    let use_upper = pos_in_chunk >= 32u;
-    let byte_in_range = select(pos_in_chunk, pos_in_chunk - 32u, use_upper);
-    let byte_idx = chunk * 32u + byte_in_range;
-
-    let word_idx = byte_idx / 4u;
-    let byte_in_word = byte_idx % 4u;
-    let byte_val = (qs[word_idx] >> (byte_in_word * 8u)) & 0xFFu;
-
-    if (use_upper) {
-        return (byte_val >> 4u) & 0xFu;
-    }
-    return byte_val & 0xFu;
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE_MAIN, 1, 1)
-fn main(
-    @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>
-) {
-    let block_idx = workgroup_id.x;
-    let elem_idx = local_id.x;
-
-    if (block_idx >= u.num_blocks) {
-        return;
-    }
-
-    let block = quantized[block_idx];
-
-    if (elem_idx == 0u) {
-        shared_d = unpack_f16_lo(block.d);
-        shared_dmin = unpack_f16_hi(block.d);
-    }
-
-    if (elem_idx < 8u) {
-        let sm = get_scale_min_k4(block.scales, elem_idx);
-        shared_scales[elem_idx] = f32(sm.x);
-        shared_mins[elem_idx] = f32(sm.y);
-    }
-
-    workgroupBarrier();
-
-    let row = block_idx / u.blocks_per_row;
-    let block_in_row = block_idx % u.blocks_per_row;
-    let col = block_in_row * QK_K + elem_idx;
-
-    if (col >= u.K) {
-        return;
-    }
-
-    let subblock_idx = elem_idx / SUBBLOCK_SIZE;
-    let scale = shared_d * shared_scales[subblock_idx];
-    let min_val = shared_dmin * shared_mins[subblock_idx];
-
-    let q = get_q4(block.qs, elem_idx);
-    let dequant = scale * f32(q) - min_val;
-
-    let out_idx = row * u.K + col;
-    output[out_idx] = dequant;
-}

package/src/gpu/kernels/dequant_mxfp4.wgsl

@@ -1,120 +0,0 @@
-// MXFP4 Dequantization Kernel
-//
-// Dequantizes MXFP4 quantized weights used by GPT-OSS models.
-//
-// MXFP4 Format (per group of 32 elements):
-// - blocks: 16 bytes containing 32 x 4-bit values (2 nibbles per byte)
-// - scale: 1 byte shared across the 32 values
-//
-// Dequantization formula:
-//   value = (nibble - 8) * scale * (1.0 / 127.0)
-//
-// Where nibble is 0-15 (representing -8 to +7 signed 4-bit)
-
-// Tunable workgroup size
-override WORKGROUP_SIZE_MAIN: u32 = 256u;
-
-struct Uniforms {
-    total_elements: u32,    // Total output elements
-    num_groups: u32,        // Groups per row (e.g., 90)
-    group_size: u32,        // Elements per group (32 = 16 bytes * 2 nibbles)
-    row_stride: u32,        // Stride between rows in output
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> blocks: array<u32>;  // Packed U8 as U32
-@group(0) @binding(2) var<storage, read> scales: array<u32>;  // Packed U8 as U32
-@group(0) @binding(3) var<storage, read_write> output: array<f32>;
-
-// Extract 4-bit nibble from packed bytes and decode as E2M1 FP4
-// MXFP4 E2M1 format: 1 sign bit, 2 exponent bits (bias=1), 1 mantissa bit
-// Layout: S | E1 | E0 | M
-fn get_nibble(byte_data: u32, nibble_idx: u32) -> f32 {
-    // Each U32 contains 4 bytes, each byte contains 2 nibbles
-    let byte_idx = nibble_idx / 2u;
-    let is_high = nibble_idx % 2u;
-    let byte_val = (byte_data >> (byte_idx * 8u)) & 0xFFu;
-
-    var nibble: u32;
-    if (is_high == 1u) {
-        nibble = (byte_val >> 4u) & 0xFu;
-    } else {
-        nibble = byte_val & 0xFu;
-    }
-
-    // Decode E2M1 FP4:
-    // nibble = SEEM (4 bits)
-    // S = sign bit (bit 3)
-    // E = exponent (bits 2-1), bias = 1
-    // M = mantissa (bit 0)
-    let sign_bit = (nibble >> 3u) & 1u;
-    let exp = (nibble >> 1u) & 3u;  // 2-bit exponent
-    let mantissa = nibble & 1u;     // 1-bit mantissa
-
-    var value: f32;
-    if (exp == 0u) {
-        // Subnormal: value = (-1)^S * 0.5 * M
-        value = f32(mantissa) * 0.5;
-    } else {
-        // Normal: value = (-1)^S * (1 + 0.5*M) * 2^(E-1)
-        let m = 1.0 + f32(mantissa) * 0.5;
-        value = m * pow(2.0, f32(exp) - 1.0);
-    }
-
-    // Apply sign
-    if (sign_bit == 1u) {
-        value = -value;
-    }
-    return value;
-}
-
-// Get scale value from packed scales array (E8M0 format)
-fn get_scale(scale_data: u32, idx: u32) -> f32 {
-    let byte_idx = idx % 4u;
-    let scale_byte = (scale_data >> (byte_idx * 8u)) & 0xFFu;
-    // E8M0 format: 8-bit exponent, no mantissa
-    // scale = 2^(exponent - 127) where 127 is the IEEE bias
-    // Special cases: 0 = zero, 255 = NaN (we treat as 0)
-    if (scale_byte == 0u || scale_byte == 255u) {
-        return 0.0;
-    }
-    let exponent = i32(scale_byte) - 127;
-    return pow(2.0, f32(exponent));
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE_MAIN, 1, 1)
-fn main(
-    @builtin(global_invocation_id) global_id: vec3<u32>,
-    @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>
-) {
-    let elem_idx = global_id.x;
-
-    if (elem_idx >= u.total_elements) {
-        return;
-    }
-
-    // Compute which group this element belongs to
-    let group_idx = elem_idx / u.group_size;
-    let intra_group_idx = elem_idx % u.group_size;
-
-    // Get scale for this group
-    let scale_word_idx = group_idx / 4u;
-    let scale_byte_idx = group_idx % 4u;
-    let scale_word = scales[scale_word_idx];
-    let scale = get_scale(scale_word, scale_byte_idx);
-
-    // Get the block data
-    // Each group has 16 bytes = 4 U32 words = 32 nibbles
-    let block_base = group_idx * 4u;  // 4 U32 words per group
-    let word_in_block = intra_group_idx / 8u;  // Which U32 word (0-3)
-    let nibble_in_word = intra_group_idx % 8u;  // Which nibble in word (0-7)
-
-    let block_word = blocks[block_base + word_in_block];
-    let nibble_val = get_nibble(block_word, nibble_in_word);
-
-    // Dequantize: signed nibble * scale
-    let dequant = f32(nibble_val) * scale;
-
-    output[elem_idx] = dequant;
-}