@@ -517,12 +517,122 @@ fn hash_generic_byte_view_array<T: ByteViewType>(
     }
 }
 
+/// Dense-path unroll width; 8 lanes keep the gather pipeline full on ARM64/x86.
+#[cfg(not(feature = "force_hash_collisions"))]
+const DICT_SCATTER_LANES: usize = 8;
+
+#[cfg(not(feature = "force_hash_collisions"))]
+#[inline(always)]
+fn apply_dict_hash<const MULTI_COL: bool>(prev: u64, dict_hash: u64) -> u64 {
+    if MULTI_COL {
+        combine_hashes(dict_hash, prev)
+    } else {
+        dict_hash
+    }
+}
+
+/// Scatter dict hashes into every key position, 8-way unrolled.
+#[cfg(not(feature = "force_hash_collisions"))]
+#[inline(always)]
+fn scatter_dict_dense<K: ArrowDictionaryKeyType, const MULTI_COL: bool>(
+    keys: &[K::Native],
+    dict_hashes: &[u64],
+    hashes: &mut [u64],
+) {
+    let full = (keys.len() / DICT_SCATTER_LANES) * DICT_SCATTER_LANES;
+    let (keys_full, keys_tail) = keys.split_at(full);
+    let (hashes_full, hashes_tail) = hashes.split_at_mut(full);
+    for (k_chunk, h_chunk) in keys_full
+        .chunks_exact(DICT_SCATTER_LANES)
+        .zip(hashes_full.chunks_exact_mut(DICT_SCATTER_LANES))
+    {
+        let dh: [u64; DICT_SCATTER_LANES] = std::array::from_fn(|i| unsafe {
+            *dict_hashes.get_unchecked(k_chunk[i].as_usize())
+        });
+        for i in 0..DICT_SCATTER_LANES {
+            h_chunk[i] = apply_dict_hash::<MULTI_COL>(h_chunk[i], dh[i]);
+        }
+    }
+    for (k, h) in keys_tail.iter().zip(hashes_tail.iter_mut()) {
+        let dh = unsafe { *dict_hashes.get_unchecked(k.as_usize()) };
+        *h = apply_dict_hash::<MULTI_COL>(*h, dh);
+    }
+}
+
+/// Scatter dict hashes but skip positions whose dict value is null.
+#[cfg(not(feature = "force_hash_collisions"))]
+#[inline(always)]
+fn scatter_dict_dense_filter_values<K: ArrowDictionaryKeyType, const MULTI_COL: bool>(
+    keys: &[K::Native],
+    dict_values: &dyn Array,
+    dict_hashes: &[u64],
+    hashes: &mut [u64],
+) {
+    for (k, h) in keys.iter().zip(hashes.iter_mut()) {
+        let idx = k.as_usize();
+        if dict_values.is_valid(idx) {
+            let dh = unsafe { *dict_hashes.get_unchecked(idx) };
+            *h = apply_dict_hash::<MULTI_COL>(*h, dh);
+        }
+    }
+}
+
+/// Blend scatter inside a mixed 64-key chunk governed by `mask`.
+///
+/// Branchless fast path when dict values are all valid: clamp garbage key
+/// indices (from null-key positions), gather dict hashes for every lane, then
+/// csel-blend using the mask so only valid positions are written.
+#[cfg(not(feature = "force_hash_collisions"))]
+#[inline(always)]
+fn scatter_dict_blend_chunk<
+    K: ArrowDictionaryKeyType,
+    const HAS_NULL_VALUES: bool,
+    const MULTI_COL: bool,
+>(
+    keys: &[K::Native],
+    dict_values: &dyn Array,
+    dict_hashes: &[u64],
+    hashes: &mut [u64],
+    mask: u64,
+) {
+    debug_assert_eq!(keys.len(), 64);
+    debug_assert_eq!(hashes.len(), 64);
+    if HAS_NULL_VALUES {
+        let mut remaining = mask;
+        while remaining != 0 {
+            let i = remaining.trailing_zeros() as usize;
+            remaining &= remaining - 1;
+            let idx = unsafe { keys.get_unchecked(i).as_usize() };
+            if dict_values.is_valid(idx) {
+                let dh = unsafe { *dict_hashes.get_unchecked(idx) };
+                let slot = unsafe { hashes.get_unchecked_mut(i) };
+                *slot = apply_dict_hash::<MULTI_COL>(*slot, dh);
+            }
+        }
+        return;
+    }
+    let clamp = dict_hashes.len().saturating_sub(1);
+    for lane_base in (0..64).step_by(DICT_SCATTER_LANES) {
+        let dh: [u64; DICT_SCATTER_LANES] = std::array::from_fn(|i| {
+            let raw = unsafe { keys.get_unchecked(lane_base + i).as_usize() };
+            let idx = raw.min(clamp);
+            unsafe { *dict_hashes.get_unchecked(idx) }
+        });
+        for i in 0..DICT_SCATTER_LANES {
+            let slot = unsafe { hashes.get_unchecked_mut(lane_base + i) };
+            let new = apply_dict_hash::<MULTI_COL>(*slot, dh[i]);
+            let valid = ((mask >> (lane_base + i)) & 1) == 1;
+            *slot = if valid { new } else { *slot };
+        }
+    }
+}
+
 /// Scatter precomputed dictionary value hashes to key positions.
 ///
-/// Uses const generics to eliminate runtime branching in the hot loop:
-/// - `HAS_NULL_KEYS`: Whether to check for null dictionary keys
-/// - `HAS_NULL_VALUES`: Whether to check for null dictionary values
-/// - `MULTI_COL`: Whether to combine with existing hash (true) or initialize (false)
+/// Const generics eliminate runtime branching:
+/// - `HAS_NULL_KEYS`: dictionary has null keys to skip
+/// - `HAS_NULL_VALUES`: dictionary values may be null (per-index check)
+/// - `MULTI_COL`: combine with existing hash vs. overwrite
 #[cfg(not(feature = "force_hash_collisions"))]
 #[inline(never)]
 fn hash_dictionary_scatter<
@@ -536,28 +646,68 @@ fn hash_dictionary_scatter<
     hashes_buffer: &mut [u64],
 ) {
     let dict_values = array.values();
-    if HAS_NULL_KEYS {
-        for (hash, key) in hashes_buffer.iter_mut().zip(array.keys().iter()) {
-            if let Some(key) = key {
-                let idx = key.as_usize();
-                if !HAS_NULL_VALUES || dict_values.is_valid(idx) {
-                    if MULTI_COL {
-                        *hash = combine_hashes(dict_hashes[idx], *hash);
-                    } else {
-                        *hash = dict_hashes[idx];
-                    }
-                }
+    let keys = array.keys().values();
+
+    if !HAS_NULL_KEYS {
+        if HAS_NULL_VALUES {
+            scatter_dict_dense_filter_values::<K, MULTI_COL>(
+                keys,
+                dict_values.as_ref(),
+                dict_hashes,
+                hashes_buffer,
+            );
+        } else {
+            scatter_dict_dense::<K, MULTI_COL>(keys, dict_hashes, hashes_buffer);
+        }
+        return;
+    }
+
+    let null_buffer = array.keys().nulls().expect("HAS_NULL_KEYS implies nulls");
+    let bit_chunks = null_buffer.inner().bit_chunks();
+    let chunk_len = bit_chunks.chunk_len();
+
+    for (chunk_idx, mask) in bit_chunks.iter().enumerate() {
+        let base = chunk_idx * 64;
+        let keys_chunk = &keys[base..base + 64];
+        let hashes_chunk = &mut hashes_buffer[base..base + 64];
+        if mask == u64::MAX {
+            if HAS_NULL_VALUES {
+                scatter_dict_dense_filter_values::<K, MULTI_COL>(
+                    keys_chunk,
+                    dict_values.as_ref(),
+                    dict_hashes,
+                    hashes_chunk,
+                );
+            } else {
+                scatter_dict_dense::<K, MULTI_COL>(keys_chunk, dict_hashes, hashes_chunk);
             }
+        } else if mask != 0 {
+            scatter_dict_blend_chunk::<K, HAS_NULL_VALUES, MULTI_COL>(
+                keys_chunk,
+                dict_values.as_ref(),
+                dict_hashes,
+                hashes_chunk,
+                mask,
+            );
         }
-    } else {
-        for (hash, key) in hashes_buffer.iter_mut().zip(array.keys().values()) {
-            let idx = key.as_usize();
+    }
+
+    let remainder_len = bit_chunks.remainder_len();
+    if remainder_len > 0 {
+        let remainder = bit_chunks.remainder_bits();
+        let base = chunk_len * 64;
+        let mut remaining = remainder;
+        while remaining != 0 {
+            let i = remaining.trailing_zeros() as usize;
+            remaining &= remaining - 1;
+            if i >= remainder_len {
+                break;
+            }
+            let idx = keys[base + i].as_usize();
             if !HAS_NULL_VALUES || dict_values.is_valid(idx) {
-                if MULTI_COL {
-                    *hash = combine_hashes(dict_hashes[idx], *hash);
-                } else {
-                    *hash = dict_hashes[idx];
-                }
+                let dh = unsafe { *dict_hashes.get_unchecked(idx) };
+                hashes_buffer[base + i] =
+                    apply_dict_hash::<MULTI_COL>(hashes_buffer[base + i], dh);
             }
         }
     }