diff --git a/crates/multimodal/Cargo.toml b/crates/multimodal/Cargo.toml
index de9aa77b77..ec03653d33 100644
--- a/crates/multimodal/Cargo.toml
+++ b/crates/multimodal/Cargo.toml
@@ -19,6 +19,7 @@ name = "llm_multimodal"
 base64 = "0.22"
 hf-hub = "0.5.0"
 bytes = { version = "1.8.0", features = ["serde"] }
+fast_image_resize = { version = "6.0.0", features = ["image"] }
 image = { version = "0.25.4", default-features = false, features = ["png", "jpeg", "gif", "bmp", "ico", "tiff", "webp"] }
 ndarray = "0.17"
 once_cell = "1.21.3"
@@ -36,9 +37,14 @@ anyhow.workspace = true
 blake3.workspace = true
 
 [dev-dependencies]
+criterion = { version = "0.5", features = ["html_reports"] }
 npyz = { version = "0.8", features = ["npz"] }
 tempfile = "3.8"
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 
+[[bench]]
+name = "image_preprocess"
+harness = false
+
 [lints]
 workspace = true
diff --git a/crates/multimodal/benches/image_preprocess.rs b/crates/multimodal/benches/image_preprocess.rs
new file mode 100644
index 0000000000..180db0d608
--- /dev/null
+++ b/crates/multimodal/benches/image_preprocess.rs
@@ -0,0 +1,368 @@
+//! Benchmark: SMG image preprocessing vs HF processor baseline.
+//!
+//! Measures the time for model-specific image preprocessing (resize, normalize,
+//! patchify) at various image sizes. Compare results with the companion Python
+//! script `scripts/bench_image_preprocess.py` which benchmarks HF transformers.
+//!
+//! Run:  cargo bench -p llm-multimodal --bench image_preprocess
+
+#![allow(clippy::unwrap_used, clippy::expect_used)]
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use image::{imageops::FilterType, DynamicImage, RgbImage};
+use llm_multimodal::vision::{
+    image_processor::ImagePreProcessor,
+    preprocessor_config::PreProcessorConfig,
+    processors::{Llama4VisionProcessor, Qwen2VLProcessor, Qwen3VLProcessor},
+    transforms,
+};
+
+/// Create a synthetic RGB image with some variation (not all zeros).
+fn make_test_image(width: u32, height: u32) -> DynamicImage {
+    let img = RgbImage::from_fn(width, height, |x, y| {
+        image::Rgb([(x % 256) as u8, (y % 256) as u8, ((x + y) % 256) as u8])
+    });
+    DynamicImage::ImageRgb8(img)
+}
+
+fn load_preprocessor_config(model_path: &str) -> Option<PreProcessorConfig> {
+    let config_path = format!("{model_path}/preprocessor_config.json");
+    let json = std::fs::read_to_string(&config_path).ok()?;
+    PreProcessorConfig::from_json(&json).ok()
+}
+
+// ── Full pipeline benchmarks ─────────────────────────────────────
+
+fn bench_qwen3_vl(c: &mut Criterion) {
+    let processor = Qwen3VLProcessor::new();
+    let config =
+        load_preprocessor_config("/raid/models/Qwen/Qwen3-VL-8B-Instruct").unwrap_or_else(|| {
+            PreProcessorConfig::from_json(
+                r#"{"do_resize": true, "size": {"shortest_edge": 3136, "longest_edge": 12845056}}"#,
+            )
+            .unwrap()
+        });
+
+    let sizes: &[(u32, u32)] = &[
+        (224, 224),
+        (640, 480),
+        (1024, 768),
+        (1920, 1080),
+        (3840, 2160),
+    ];
+
+    let mut group = c.benchmark_group("qwen3_vl_preprocess");
+    for &(w, h) in sizes {
+        let image = make_test_image(w, h);
+        let images = [image];
+        group.bench_with_input(
+            BenchmarkId::new("single", format!("{w}x{h}")),
+            &images,
+            |b, imgs| {
+                b.iter(|| processor.preprocess(imgs, &config).unwrap());
+            },
+        );
+    }
+    group.finish();
+
+    // Batch benchmarks
+    let mut group = c.benchmark_group("qwen3_vl_batch");
+    for batch_size in [3, 5, 10] {
+        let images: Vec<DynamicImage> = (0..batch_size)
+            .map(|i| make_test_image(640 + i * 10, 480 + i * 10))
+            .collect();
+        group.bench_with_input(
+            BenchmarkId::new("640x480", format!("batch{batch_size}")),
+            &images,
+            |b, imgs| {
+                b.iter(|| processor.preprocess(imgs, &config).unwrap());
+            },
+        );
+    }
+    group.finish();
+
+    // Extreme: very small and very large
+    let mut group = c.benchmark_group("qwen3_vl_extreme");
+    let extremes: &[(u32, u32, &str)] = &[
+        (32, 32, "tiny_32x32"),
+        (50, 50, "small_50x50"),
+        (100, 2000, "tall_100x2000"),
+        (2000, 100, "wide_2000x100"),
+        (4096, 4096, "huge_4096x4096"),
+    ];
+    for &(w, h, label) in extremes {
+        let image = make_test_image(w, h);
+        let images = [image];
+        group.bench_with_input(BenchmarkId::new("single", label), &images, |b, imgs| {
+            b.iter(|| processor.preprocess(imgs, &config).unwrap());
+        });
+    }
+    group.finish();
+}
+
+fn bench_qwen2_vl(c: &mut Criterion) {
+    let processor = Qwen2VLProcessor::new();
+    let config =
+        load_preprocessor_config("/raid/models/Qwen/Qwen2-VL-2B-Instruct").unwrap_or_else(|| {
+            PreProcessorConfig::from_json(
+                r#"{"do_resize": true, "size": {"shortest_edge": 3136, "longest_edge": 12845056}}"#,
+            )
+            .unwrap()
+        });
+
+    let sizes: &[(u32, u32)] = &[(224, 224), (640, 480), (1024, 768), (1920, 1080)];
+
+    let mut group = c.benchmark_group("qwen2_vl_preprocess");
+    for &(w, h) in sizes {
+        let image = make_test_image(w, h);
+        let images = [image];
+        group.bench_with_input(
+            BenchmarkId::new("single", format!("{w}x{h}")),
+            &images,
+            |b, imgs| {
+                b.iter(|| processor.preprocess(imgs, &config).unwrap());
+            },
+        );
+    }
+    group.finish();
+}
+
+fn bench_llama4(c: &mut Criterion) {
+    let processor = Llama4VisionProcessor::new();
+    let config =
+        load_preprocessor_config("/raid/models/meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8")
+            .unwrap_or_else(|| {
+                PreProcessorConfig::from_json(
+                    r#"{"do_resize": true, "size": {"height": 336, "width": 336}}"#,
+                )
+                .unwrap()
+            });
+
+    let sizes: &[(u32, u32)] = &[
+        (224, 224),
+        (336, 336),
+        (640, 480),
+        (1024, 768),
+        (1920, 1080),
+    ];
+
+    let mut group = c.benchmark_group("llama4_preprocess");
+    for &(w, h) in sizes {
+        let image = make_test_image(w, h);
+        let images = [image];
+        group.bench_with_input(
+            BenchmarkId::new("single", format!("{w}x{h}")),
+            &images,
+            |b, imgs| {
+                b.iter(|| processor.preprocess(imgs, &config).unwrap());
+            },
+        );
+    }
+    group.finish();
+}
+
+// ── Per-step profiling benchmarks ────────────────────────────────
+
+fn bench_individual_steps(c: &mut Criterion) {
+    let sizes: &[(u32, u32)] = &[(640, 480), (1024, 768), (1920, 1080)];
+
+    // Step 1: Resize only
+    let mut group = c.benchmark_group("step_resize");
+    for &(w, h) in sizes {
+        let image = make_test_image(w, h);
+        // Qwen3-VL target: smart_resize result
+        let processor = Qwen3VLProcessor::new();
+        let (th, tw) = processor.smart_resize(h as usize, w as usize).unwrap();
+        group.bench_with_input(
+            BenchmarkId::new("fir_bilinear", format!("{w}x{h}")),
+            &image,
+            |b, img| {
+                b.iter(|| transforms::resize(img, tw as u32, th as u32, FilterType::Triangle));
+            },
+        );
+    }
+    group.finish();
+
+    // Step 2: to_tensor only
+    let mut group = c.benchmark_group("step_to_tensor");
+    for &(w, h) in sizes {
+        // Use a pre-resized image to isolate to_tensor cost
+        let image = make_test_image(w, h);
+        group.bench_with_input(
+            BenchmarkId::new("rgb8", format!("{w}x{h}")),
+            &image,
+            |b, img| {
+                b.iter(|| transforms::to_tensor(img));
+            },
+        );
+    }
+    group.finish();
+
+    // Step 3: normalize only
+    let mut group = c.benchmark_group("step_normalize");
+    let mean = [0.5, 0.5, 0.5];
+    let std = [0.5, 0.5, 0.5];
+    for &(w, h) in sizes {
+        let image = make_test_image(w, h);
+        let tensor = transforms::to_tensor(&image);
+        group.bench_with_input(
+            BenchmarkId::new("f32", format!("{w}x{h}")),
+            &tensor,
+            |b, t| {
+                b.iter_batched(
+                    || t.clone(),
+                    |mut fresh| transforms::normalize(&mut fresh, &mean, &std),
+                    criterion::BatchSize::SmallInput,
+                );
+            },
+        );
+    }
+    group.finish();
+}
+
+fn bench_llama4_steps(c: &mut Criterion) {
+    let processor = Llama4VisionProcessor::new();
+    let config =
+        load_preprocessor_config("/raid/models/meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8")
+            .unwrap_or_else(|| {
+                PreProcessorConfig::from_json(
+                    r#"{"do_resize": true, "size": {"height": 336, "width": 336}}"#,
+                )
+                .unwrap()
+            });
+
+    // 1024x768 is the worst case (1.8x slower than HF)
+    let sizes: &[(u32, u32)] = &[(640, 480), (1024, 768), (1920, 1080)];
+
+    let mut group = c.benchmark_group("llama4_steps");
+    for &(w, h) in sizes {
+        let image = make_test_image(w, h);
+
+        // Full preprocess
+        group.bench_with_input(
+            BenchmarkId::new("full_preprocess", format!("{w}x{h}")),
+            &image,
+            |b, img| {
+                let imgs = [img.clone()];
+                b.iter(|| processor.preprocess(&imgs, &config).unwrap());
+            },
+        );
+
+        // Just resize
+        group.bench_with_input(
+            BenchmarkId::new("resize_only", format!("{w}x{h}")),
+            &image,
+            |b, img| {
+                b.iter(|| transforms::resize(img, 336, 336, FilterType::Triangle));
+            },
+        );
+
+        // to_tensor_and_normalize on tile-sized image
+        let tile_img = make_test_image(336, 336);
+        group.bench_with_input(
+            BenchmarkId::new("tensor_normalize_336", format!("{w}x{h}")),
+            &tile_img,
+            |b, img| {
+                b.iter(|| {
+                    transforms::to_tensor_and_normalize(img, &[0.5, 0.5, 0.5], &[0.5, 0.5, 0.5])
+                });
+            },
+        );
+    }
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_qwen3_vl,
+    bench_qwen2_vl,
+    bench_llama4,
+    bench_llama4_steps,
+    bench_individual_steps,
+    bench_fused_to_tensor_normalize,
+    bench_to_rgb8,
+    bench_resize_detailed,
+);
+criterion_main!(benches);
+
+fn bench_fused_to_tensor_normalize(c: &mut Criterion) {
+    let sizes: &[(u32, u32)] = &[(640, 480), (1024, 768), (1920, 1080)];
+    let mean = [0.5, 0.5, 0.5];
+    let std = [0.5, 0.5, 0.5];
+
+    let mut group = c.benchmark_group("step_to_tensor_normalize_fused");
+    for &(w, h) in sizes {
+        let image = make_test_image(w, h);
+        group.bench_with_input(
+            BenchmarkId::new("fused", format!("{w}x{h}")),
+            &image,
+            |b, img| {
+                b.iter(|| transforms::to_tensor_and_normalize(img, &mean, &std));
+            },
+        );
+    }
+    group.finish();
+}
+
+fn bench_to_rgb8(c: &mut Criterion) {
+    let sizes: &[(u32, u32)] = &[(640, 480), (1024, 768), (1920, 1080)];
+
+    let mut group = c.benchmark_group("step_to_rgb8");
+    for &(w, h) in sizes {
+        let image = make_test_image(w, h);
+        group.bench_with_input(
+            BenchmarkId::new("rgb8", format!("{w}x{h}")),
+            &image,
+            |b, img| {
+                b.iter(|| img.to_rgb8());
+            },
+        );
+    }
+    group.finish();
+
+    // Also test when image is already RGB8 (should be free)
+    let mut group = c.benchmark_group("step_to_rgb8_noop");
+    for &(w, h) in sizes {
+        let image = make_test_image(w, h);
+        let rgb = DynamicImage::ImageRgb8(image.to_rgb8());
+        group.bench_with_input(
+            BenchmarkId::new("already_rgb8", format!("{w}x{h}")),
+            &rgb,
+            |b, img| {
+                b.iter(|| img.to_rgb8());
+            },
+        );
+    }
+    group.finish();
+}
+
+fn bench_resize_detailed(c: &mut Criterion) {
+    let processor = Qwen3VLProcessor::new();
+
+    // Benchmark: make_test_image + resize + convert back to DynamicImage
+    let mut group = c.benchmark_group("step_resize_full_pipeline");
+    let sizes: &[(u32, u32)] = &[(640, 480), (1024, 768), (1920, 1080)];
+    for &(w, h) in sizes {
+        let image = make_test_image(w, h);
+        let (th, tw) = processor.smart_resize(h as usize, w as usize).unwrap();
+
+        // fir resize (our path)
+        group.bench_with_input(
+            BenchmarkId::new("fir", format!("{w}x{h}->{tw}x{th}")),
+            &image,
+            |b, img| {
+                b.iter(|| transforms::resize(img, tw as u32, th as u32, FilterType::Triangle));
+            },
+        );
+
+        // image crate resize (old path, for comparison)
+        group.bench_with_input(
+            BenchmarkId::new("image_crate", format!("{w}x{h}->{tw}x{th}")),
+            &image,
+            |b, img| {
+                b.iter(|| img.resize_exact(tw as u32, th as u32, FilterType::Triangle));
+            },
+        );
+    }
+    group.finish();
+}
diff --git a/crates/multimodal/src/registry/qwen_vl.rs b/crates/multimodal/src/registry/qwen_vl.rs
index 612706d55f..6ad19ab4da 100644
--- a/crates/multimodal/src/registry/qwen_vl.rs
+++ b/crates/multimodal/src/registry/qwen_vl.rs
@@ -63,7 +63,7 @@ impl ModelProcessorSpec for QwenVLVisionSpec {
         let pad_token_id = Self::pad_token_id(metadata)?;
         let placeholder_token = self.placeholder_token(metadata)?;
         // The chat template already wraps each image with <|vision_start|> ... <|vision_end|>,
-        // so we only expand the single <|image_pad|> placeholder to N pad tokens.
+        // so we only expand the single <image> placeholder to N pad tokens.
         Ok(preprocessed
             .num_img_tokens
             .iter()
diff --git a/crates/multimodal/src/vision/processors/llama4_vision.rs b/crates/multimodal/src/vision/processors/llama4_vision.rs
index 8f20d4e84c..7cfa60a8a4 100644
--- a/crates/multimodal/src/vision/processors/llama4_vision.rs
+++ b/crates/multimodal/src/vision/processors/llama4_vision.rs
@@ -273,8 +273,11 @@ impl Llama4VisionProcessor {
         let black = Rgb([0u8, 0, 0]);
         let mut padded = RgbImage::from_pixel(target_w, target_h, black);
 
-        // Copy image to top-left using efficient overlay
-        image::imageops::overlay(&mut padded, &image.to_rgb8(), 0, 0);
+        // Copy image to top-left — avoid to_rgb8() if already RGB8
+        match image {
+            DynamicImage::ImageRgb8(rgb) => image::imageops::overlay(&mut padded, rgb, 0, 0),
+            _ => image::imageops::overlay(&mut padded, &image.to_rgb8(), 0, 0),
+        }
 
         DynamicImage::ImageRgb8(padded)
     }
@@ -309,10 +312,8 @@ impl Llama4VisionProcessor {
     /// Create global image by bilinear interpolation to tile size.
     fn create_global_image(&self, image: &DynamicImage) -> Array3<f32> {
         let tile = self.tile_size;
-        let resized = image.resize_exact(tile, tile, FilterType::Triangle);
-        let mut tensor = transforms::to_tensor(&resized);
-        transforms::normalize(&mut tensor, &self.mean, &self.std);
-        tensor
+        let resized = transforms::resize(image, tile, tile, FilterType::Triangle);
+        transforms::to_tensor_and_normalize(&resized, &self.mean, &self.std)
     }
 
     /// Process a single image.
@@ -339,14 +340,13 @@ impl Llama4VisionProcessor {
         let new_size = Self::get_max_res_without_distortion(image_size, resize_target);
         let (new_h, new_w) = (new_size.0.max(1), new_size.1.max(1));
 
-        let resized = image.resize_exact(new_w, new_h, FilterType::Triangle);
+        let resized = transforms::resize(image, new_w, new_h, FilterType::Triangle);
 
         // Step 4: Pad to target_size (the canvas from get_best_fit, not resize_target)
         let padded = self.pad_image(&resized, target_w, target_h);
 
         // Step 5: Convert to tensor and normalize
-        let mut tensor = transforms::to_tensor(&padded);
-        transforms::normalize(&mut tensor, &self.mean, &self.std);
+        let tensor = transforms::to_tensor_and_normalize(&padded, &self.mean, &self.std);
 
         // Step 6: Calculate tile counts based on target_size (canvas size)
         let tile = self.tile_size as usize;
@@ -411,14 +411,16 @@ impl ImagePreProcessor for Llama4VisionProcessor {
             });
         }
 
+        let owned_processor;
         let processor = if config.max_image_tiles.is_some()
             || config.image_mean.is_some()
             || config.image_std.is_some()
             || config.size.is_some()
         {
-            Self::from_preprocessor_config(config)
+            owned_processor = Self::from_preprocessor_config(config);
+            &owned_processor
         } else {
-            self.clone()
+            self
         };
 
         let mut all_outputs = Vec::new();
@@ -436,13 +438,21 @@ impl ImagePreProcessor for Llama4VisionProcessor {
             num_img_tokens.push(tokens);
         }
 
+        // Per-image tile counts (must be computed before remove/concatenate)
+        let patches_per_image: Vec<i64> = all_outputs.iter().map(|o| o.shape()[0] as i64).collect();
+
         // Concatenate all tiles from all images into a single 4D tensor
         // [total_tiles, C, H, W] — no batch dimension, no zero-padding.
         // This matches what sglang and vLLM vision models expect.
-        let tile_views: Vec<ndarray::ArrayView4<f32>> =
-            all_outputs.iter().map(|o| o.view()).collect();
-        let pixel_values = ndarray::concatenate(ndarray::Axis(0), &tile_views)
-            .map_err(|e| TransformError::ShapeError(format!("Failed to concatenate tiles: {e}")))?;
+        let pixel_values = if all_outputs.len() == 1 {
+            all_outputs.remove(0)
+        } else {
+            let tile_views: Vec<ndarray::ArrayView4<f32>> =
+                all_outputs.iter().map(|o| o.view()).collect();
+            ndarray::concatenate(ndarray::Axis(0), &tile_views).map_err(|e| {
+                TransformError::ShapeError(format!("Failed to concatenate tiles: {e}"))
+            })?
+        };
 
         // Store aspect ratios and patches_per_image as model-specific data
         let mut model_specific = std::collections::HashMap::new();
@@ -459,9 +469,6 @@ impl ImagePreProcessor for Llama4VisionProcessor {
                 shape: vec![batch_size, 2],
             },
         );
-
-        // Per-image tile counts for flat slicing of pixel_values.
-        let patches_per_image: Vec<i64> = all_outputs.iter().map(|o| o.shape()[0] as i64).collect();
         model_specific.insert(
             "patches_per_image".to_string(),
             ModelSpecificValue::int_1d(patches_per_image),
diff --git a/crates/multimodal/src/vision/processors/llava.rs b/crates/multimodal/src/vision/processors/llava.rs
index f7aae51998..cbf1197333 100644
--- a/crates/multimodal/src/vision/processors/llava.rs
+++ b/crates/multimodal/src/vision/processors/llava.rs
@@ -673,7 +673,8 @@ fn resize_and_pad_image(image: &DynamicImage, target: (u32, u32)) -> DynamicImag
         )
     };
 
-    let resized = image.resize_exact(
+    let resized = resize(
+        image,
         new_width,
         new_height,
         image::imageops::FilterType::CatmullRom,
diff --git a/crates/multimodal/src/vision/processors/phi3_vision.rs b/crates/multimodal/src/vision/processors/phi3_vision.rs
index 5322a822cb..9b847cfb8f 100644
--- a/crates/multimodal/src/vision/processors/phi3_vision.rs
+++ b/crates/multimodal/src/vision/processors/phi3_vision.rs
@@ -139,7 +139,7 @@ impl Phi3VisionProcessor {
         // HuggingFace uses torchvision.transforms.functional.resize with
         // BILINEAR interpolation and antialias=True. PIL's BILINEAR includes
         // implicit antialiasing that closely matches torchvision.
-        let resized = img.resize_exact(new_w, new_h, FilterType::Triangle);
+        let resized = transforms::resize(&img, new_w, new_h, FilterType::Triangle);
 
         // Pad height to multiple of 336
         let padded = self.padding_336(&resized);
diff --git a/crates/multimodal/src/vision/processors/phi4_vision.rs b/crates/multimodal/src/vision/processors/phi4_vision.rs
index 75502333f8..53bd4ba7aa 100644
--- a/crates/multimodal/src/vision/processors/phi4_vision.rs
+++ b/crates/multimodal/src/vision/processors/phi4_vision.rs
@@ -273,7 +273,7 @@ impl Phi4VisionProcessor {
         // Resize image with bilinear interpolation (matching HuggingFace torchvision)
         // HuggingFace uses torchvision.transforms.functional.resize with BILINEAR + antialias=True.
         // FilterType::Triangle (bilinear) closely matches this behavior.
-        let resized = image.resize_exact(new_w, new_h, FilterType::Triangle);
+        let resized = transforms::resize(image, new_w, new_h, FilterType::Triangle);
 
         // Pad to target dimensions (white padding on right/bottom)
         let padded = self.pad_image(&resized, target_width, target_height);
diff --git a/crates/multimodal/src/vision/processors/pixtral.rs b/crates/multimodal/src/vision/processors/pixtral.rs
index 66c1e912d4..243e089cde 100644
--- a/crates/multimodal/src/vision/processors/pixtral.rs
+++ b/crates/multimodal/src/vision/processors/pixtral.rs
@@ -146,7 +146,7 @@ impl PixtralProcessor {
         let (target_h, target_w) = self.get_resize_output_size(orig_height, orig_width);
 
         // Step 2: Resize image using bicubic interpolation
-        let resized = image.resize_exact(target_w, target_h, FilterType::CatmullRom);
+        let resized = transforms::resize(image, target_w, target_h, FilterType::CatmullRom);
 
         // Step 3: Convert to tensor (0-1 range) and normalize
         let mut tensor = transforms::to_tensor(&resized);
diff --git a/crates/multimodal/src/vision/processors/qwen2_vl.rs b/crates/multimodal/src/vision/processors/qwen2_vl.rs
index 928ffeebb9..4a53cad3f4 100644
--- a/crates/multimodal/src/vision/processors/qwen2_vl.rs
+++ b/crates/multimodal/src/vision/processors/qwen2_vl.rs
@@ -20,7 +20,6 @@
 use std::ops::Deref;
 
 use image::DynamicImage;
-use ndarray::Array3;
 
 use super::qwen_vl_base::{QwenVLConfig, QwenVLProcessorBase};
 use crate::vision::{
@@ -188,18 +187,6 @@ impl Qwen2VLProcessor {
         self.inner
             .calculate_tokens_from_grid(grid_t, grid_h, grid_w)
     }
-
-    /// Reshape pixel values from [C, H, W] to flattened patches format.
-    pub fn reshape_to_patches(
-        &self,
-        tensor: &Array3<f32>,
-        grid_t: usize,
-        grid_h: usize,
-        grid_w: usize,
-    ) -> Result<Vec<f32>, TransformError> {
-        self.inner
-            .reshape_to_patches(tensor, grid_t, grid_h, grid_w)
-    }
 }
 
 impl Deref for Qwen2VLProcessor {
diff --git a/crates/multimodal/src/vision/processors/qwen3_vl.rs b/crates/multimodal/src/vision/processors/qwen3_vl.rs
index 91b0683306..973d7ec112 100644
--- a/crates/multimodal/src/vision/processors/qwen3_vl.rs
+++ b/crates/multimodal/src/vision/processors/qwen3_vl.rs
@@ -19,7 +19,6 @@
 use std::ops::Deref;
 
 use image::DynamicImage;
-use ndarray::Array3;
 
 use super::qwen_vl_base::{QwenVLConfig, QwenVLProcessorBase};
 use crate::vision::{
@@ -189,18 +188,6 @@ impl Qwen3VLProcessor {
         self.inner
             .calculate_tokens_from_grid(grid_t, grid_h, grid_w)
     }
-
-    /// Reshape pixel values from [C, H, W] to flattened patches format.
-    pub fn reshape_to_patches(
-        &self,
-        tensor: &Array3<f32>,
-        grid_t: usize,
-        grid_h: usize,
-        grid_w: usize,
-    ) -> Result<Vec<f32>, TransformError> {
-        self.inner
-            .reshape_to_patches(tensor, grid_t, grid_h, grid_w)
-    }
 }
 
 impl Deref for Qwen3VLProcessor {
diff --git a/crates/multimodal/src/vision/processors/qwen_vl_base.rs b/crates/multimodal/src/vision/processors/qwen_vl_base.rs
index e910603f3c..f82e965f90 100644
--- a/crates/multimodal/src/vision/processors/qwen_vl_base.rs
+++ b/crates/multimodal/src/vision/processors/qwen_vl_base.rs
@@ -27,7 +27,7 @@ use ndarray::{Array2, Array3};
 use crate::vision::{
     image_processor::{ImagePreProcessor, ModelSpecificValue, PreprocessedImages},
     preprocessor_config::PreProcessorConfig,
-    transforms::{normalize, pil_to_filter, resize, to_tensor, TransformError},
+    transforms::{pil_to_filter, resize, to_tensor, to_tensor_and_normalize, TransformError},
 };
 
 /// Python-compatible rounding (banker's rounding / round half to even).
@@ -225,45 +225,29 @@ impl QwenVLProcessorBase {
         (grid_t * grid_h * grid_w) / (self.config.merge_size * self.config.merge_size)
     }
 
-    /// Reshape pixel values from [C, H, W] to flattened patches format.
+    /// Patchify tensor directly into an output buffer (avoids intermediate Vec allocation).
+    /// Patchify a [C, H, W] tensor and append the patches to `output`.
     ///
-    /// This matches the HuggingFace Qwen2VLImageProcessor output format:
-    /// `(num_patches, patch_features)` where:
-    /// - num_patches = grid_t * grid_h * grid_w
-    /// - patch_features = C * temporal_patch_size * patch_size * patch_size
+    /// Output layout per image:
+    ///   `[grid_t, patch_rows, patch_cols, merge_h, merge_w, C, temporal, patch_h, patch_w]`
     ///
-    /// The transformation follows these steps (matching HuggingFace exactly):
-    /// 1. Start with [C, H, W] tensor, expand to [temporal, C, H, W]
-    /// 2. Reshape to [grid_t, temporal, C, grid_h/merge, merge, patch, grid_w/merge, merge, patch]
-    /// 3. Permute to [grid_t, grid_h/merge, grid_w/merge, merge, merge, C, temporal, patch, patch]
-    /// 4. Flatten to [num_patches, patch_features]
-    ///
-    /// # Arguments
-    /// * `tensor` - Input tensor of shape [C, H, W]
-    /// * `grid_t` - Temporal grid size (1 for images)
-    /// * `grid_h` - Height grid size (H / patch_size)
-    /// * `grid_w` - Width grid size (W / patch_size)
-    ///
-    /// # Returns
-    /// Flattened patches as Vec<f32> with shape semantics (num_patches, patch_features)
-    pub fn reshape_to_patches(
+    /// Each "merged patch" covers a `(merge_size * patch_size)²` spatial region.
+    /// Within it, `merge_size²` sub-patches are emitted, each containing all channels.
+    pub fn patchify_into(
         &self,
         tensor: &Array3<f32>,
         grid_t: usize,
         grid_h: usize,
         grid_w: usize,
-    ) -> Result<Vec<f32>, TransformError> {
-        use ndarray::IxDyn;
-
+        output: &mut Vec<f32>,
+    ) -> Result<(), TransformError> {
         let channel = tensor.shape()[0];
         let height = tensor.shape()[1];
         let width = tensor.shape()[2];
-
         let patch_size = self.config.patch_size;
         let merge_size = self.config.merge_size;
         let temporal_patch_size = self.config.temporal_patch_size;
 
-        // Verify dimensions match expected grid
         debug_assert_eq!(
             height,
             grid_h * patch_size,
@@ -275,62 +259,49 @@ impl QwenVLProcessorBase {
             "Width must match grid_w * patch_size"
         );
 
-        // Step 1: Expand temporal dimension by replicating the frame
-        // [C, H, W] -> [temporal_patch_size, C, H, W]
-        let expanded = tensor
-            .view()
-            .insert_axis(ndarray::Axis(0))
-            .broadcast((temporal_patch_size, channel, height, width))
-            .ok_or_else(|| TransformError::ShapeError(
-                format!("Broadcast failed: cannot broadcast [1, {channel}, {height}, {width}] to [{temporal_patch_size}, {channel}, {height}, {width}]")
-            ))?
-            .to_owned();
-
-        // Step 2: Reshape to split spatial dimensions into grid and patch components
-        // [temporal, C, H, W] -> [grid_t, temporal, C, grid_h/merge, merge, patch, grid_w/merge, merge, patch]
-        let grid_h_merged = grid_h / merge_size;
-        let grid_w_merged = grid_w / merge_size;
-
-        // Use IxDyn for 9-dimensional reshape (ndarray only supports up to Ix6 for fixed dims)
-        let shape_9d = IxDyn(&[
-            grid_t,
-            temporal_patch_size,
-            channel,
-            grid_h_merged,
-            merge_size,
-            patch_size,
-            grid_w_merged,
-            merge_size,
-            patch_size,
-        ]);
-
-        let reshaped = expanded
-            .into_shape_with_order(shape_9d)
-            .map_err(|e| TransformError::ShapeError(format!("Reshape to 9D failed: {e}")))?;
-
-        // Step 3: Permute axes to match HuggingFace output order
-        // From: [grid_t, temporal, C, grid_h/merge, merge, patch, grid_w/merge, merge, patch]
-        //       [  0   ,    1    , 2,      3      ,   4  ,   5  ,      6      ,   7  ,   8  ]
-        // To:   [grid_t, grid_h/merge, grid_w/merge, merge, merge, C, temporal, patch, patch]
-        //       [  0   ,      3      ,      6      ,   4  ,   7  , 2,    1    ,   5  ,   8  ]
-        let permuted = reshaped.permuted_axes(&[0, 3, 6, 4, 7, 2, 1, 5, 8][..]);
-
-        // Step 4: Flatten to [num_patches, patch_features]
         let num_patches = grid_t * grid_h * grid_w;
         let patch_features = channel * temporal_patch_size * patch_size * patch_size;
+        let base_idx = output.len();
+        output.resize(base_idx + num_patches * patch_features, 0.0);
+
+        let data = tensor.as_standard_layout();
+        let flat = data.as_slice().ok_or_else(|| {
+            TransformError::ShapeError("tensor not contiguous after as_standard_layout".to_string())
+        })?;
+        let planes: Vec<&[f32]> = (0..channel)
+            .map(|c| &flat[c * height * width..(c + 1) * height * width])
+            .collect();
+
+        let merged_patch = merge_size * patch_size;
+        let mut out_idx = base_idx;
+
+        for _gt in 0..grid_t {
+            for pr in 0..grid_h / merge_size {
+                for pc in 0..grid_w / merge_size {
+                    let y0 = pr * merged_patch;
+                    let x0 = pc * merged_patch;
+
+                    for mh in 0..merge_size {
+                        for mw in 0..merge_size {
+                            for plane in &planes {
+                                for _tp in 0..temporal_patch_size {
+                                    for py in 0..patch_size {
+                                        let row = (y0 + mh * patch_size + py) * width
+                                            + x0
+                                            + mw * patch_size;
+                                        output[out_idx..out_idx + patch_size]
+                                            .copy_from_slice(&plane[row..row + patch_size]);
+                                        out_idx += patch_size;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
 
-        // Make contiguous and flatten
-        let contiguous = permuted.as_standard_layout().into_owned();
-        let flat = contiguous
-            .into_shape_with_order(IxDyn(&[num_patches, patch_features]))
-            .map_err(|e| {
-                TransformError::ShapeError(format!(
-                    "Final reshape to [{num_patches}, {patch_features}] failed: {e}"
-                ))
-            })?;
-
-        let (vec, _offset) = flat.into_raw_vec_and_offset();
-        Ok(vec)
+        Ok(())
     }
 }
 
@@ -363,7 +334,17 @@ impl ImagePreProcessor for QwenVLProcessorBase {
         let temporal_patch_size = self.config.temporal_patch_size;
         let patch_features = 3 * temporal_patch_size * patch_size * patch_size;
 
-        let mut all_patches: Vec<f32> = Vec::new();
+        // Pre-allocate based on total pixel count to avoid repeated Vec growth
+        let estimated_total: usize = images
+            .iter()
+            .map(|img| {
+                let (w, h) = img.dimensions();
+                (w as usize * h as usize) / (self.config.merge_size * self.config.merge_size)
+                    * patch_features
+                    / (patch_size * patch_size)
+            })
+            .sum();
+        let mut all_patches: Vec<f32> = Vec::with_capacity(estimated_total);
         let mut patches_per_image: Vec<i64> = Vec::with_capacity(images.len());
         let mut grid_thw_data = Vec::with_capacity(images.len() * 3);
         let mut num_img_tokens = Vec::with_capacity(images.len());
@@ -372,21 +353,17 @@ impl ImagePreProcessor for QwenVLProcessorBase {
             let (w, h) = image.dimensions();
             let (target_h, target_w) = self.smart_resize(h as usize, w as usize)?;
 
-            // Resize to the image's own target size
-            let resized = if config.do_resize.unwrap_or(true) {
-                resize(image, target_w as u32, target_h as u32, filter)
+            // Resize to the image's own target size (skip if dimensions match)
+            let (tw32, th32) = (target_w as u32, target_h as u32);
+            let needs_resize = config.do_resize.unwrap_or(true) && (w != tw32 || h != th32);
+            let resized;
+            let img_ref = if needs_resize {
+                resized = resize(image, tw32, th32, filter);
+                &resized
             } else {
-                image.clone()
+                image
             };
 
-            // Convert to tensor [C, H, W]
-            let mut tensor = to_tensor(&resized);
-
-            // Normalize
-            if config.do_normalize.unwrap_or(true) {
-                normalize(&mut tensor, &mean, &std);
-            }
-
             // Grid dimensions based on the target size
             let (grid_t, grid_h, grid_w) = self.calculate_grid_thw(target_h, target_w, 1);
             grid_thw_data.push(grid_t as i64);
@@ -397,9 +374,15 @@ impl ImagePreProcessor for QwenVLProcessorBase {
             let tokens = self.calculate_tokens_from_grid(grid_t, grid_h, grid_w);
             num_img_tokens.push(tokens);
 
-            // Patchify: [C, H, W] → flat Vec<f32> of (num_patches, patch_features)
-            let patches = self.reshape_to_patches(&tensor, grid_t, grid_h, grid_w)?;
-            all_patches.extend(patches);
+            // Convert to tensor [C, H, W] and normalize in one fused pass
+            let tensor = if config.do_normalize.unwrap_or(true) {
+                to_tensor_and_normalize(img_ref, &mean, &std)
+            } else {
+                to_tensor(img_ref)
+            };
+
+            // Patchify directly into all_patches to avoid intermediate Vec + copy
+            self.patchify_into(&tensor, grid_t, grid_h, grid_w, &mut all_patches)?;
             patches_per_image.push(num_patches as i64);
         }
 
diff --git a/crates/multimodal/src/vision/transforms.rs b/crates/multimodal/src/vision/transforms.rs
index 9487458bad..eaabf886bf 100644
--- a/crates/multimodal/src/vision/transforms.rs
+++ b/crates/multimodal/src/vision/transforms.rs
@@ -3,6 +3,9 @@
 //! This module provides composable transforms that match HuggingFace image processor
 //! behavior, enabling pure Rust preprocessing without Python dependencies.
 
+use fast_image_resize::{
+    images::Image as FirImage, IntoImageView, ResizeAlg, ResizeOptions, Resizer,
+};
 use image::{imageops::FilterType, DynamicImage, GenericImageView, Rgb, RgbImage};
 use ndarray::{s, Array3, Array4};
 use thiserror::Error;
@@ -31,38 +34,65 @@ pub enum TransformError {
 
 pub type Result<T> = std::result::Result<T, TransformError>;
 
+/// Extract RGB pixel data from a DynamicImage, avoiding a copy when already RGB8.
+/// Returns (width, height, raw_bytes) where raw_bytes is interleaved R,G,B,R,G,B,...
+fn rgb_bytes(image: &DynamicImage) -> (usize, usize, std::borrow::Cow<'_, [u8]>) {
+    match image {
+        DynamicImage::ImageRgb8(rgb) => (
+            rgb.width() as usize,
+            rgb.height() as usize,
+            std::borrow::Cow::Borrowed(rgb.as_raw()),
+        ),
+        _ => {
+            let rgb = image.to_rgb8();
+            let w = rgb.width() as usize;
+            let h = rgb.height() as usize;
+            (w, h, std::borrow::Cow::Owned(rgb.into_raw()))
+        }
+    }
+}
+
+/// Build a [C, H, W] f32 tensor from interleaved RGB bytes with per-channel
+/// `scale` and `bias`: `output[c][i] = raw[i*3 + c] * scale[c] + bias[c]`.
+fn build_planar_tensor(
+    raw: &[u8],
+    w: usize,
+    h: usize,
+    scale: [f32; 3],
+    bias: [f32; 3],
+) -> Array3<f32> {
+    let pixels = h * w;
+    let mut data = vec![0.0f32; 3 * pixels];
+    let (r_plane, rest) = data.split_at_mut(pixels);
+    let (g_plane, b_plane) = rest.split_at_mut(pixels);
+
+    for (i, chunk) in raw.chunks_exact(3).enumerate() {
+        r_plane[i] = chunk[0] as f32 * scale[0] + bias[0];
+        g_plane[i] = chunk[1] as f32 * scale[1] + bias[1];
+        b_plane[i] = chunk[2] as f32 * scale[2] + bias[2];
+    }
+
+    #[expect(
+        clippy::expect_used,
+        reason = "data has exactly 3*h*w elements by construction"
+    )]
+    Array3::from_shape_vec((3, h, w), data).expect("shape matches pre-allocated buffer")
+}
+
 /// Convert image to tensor [C, H, W] normalized to [0, 1].
 ///
 /// This matches the default behavior of `torchvision.transforms.ToTensor()`.
 pub fn to_tensor(image: &DynamicImage) -> Array3<f32> {
-    let rgb = image.to_rgb8();
-    let (w, h) = (rgb.width() as usize, rgb.height() as usize);
-    let mut arr = Array3::<f32>::zeros((3, h, w));
-
-    for (x, y, pixel) in rgb.enumerate_pixels() {
-        let (x, y) = (x as usize, y as usize);
-        arr[[0, y, x]] = pixel[0] as f32 / 255.0;
-        arr[[1, y, x]] = pixel[1] as f32 / 255.0;
-        arr[[2, y, x]] = pixel[2] as f32 / 255.0;
-    }
-    arr
+    let (w, h, raw) = rgb_bytes(image);
+    let s = 1.0 / 255.0;
+    build_planar_tensor(&raw, w, h, [s, s, s], [0.0, 0.0, 0.0])
 }
 
 /// Convert image to tensor [C, H, W] without normalization (keeps [0, 255]).
-///
-/// Some models expect unnormalized pixel values.
+#[cfg(test)]
 pub fn to_tensor_no_norm(image: &DynamicImage) -> Array3<f32> {
-    let rgb = image.to_rgb8();
-    let (w, h) = (rgb.width() as usize, rgb.height() as usize);
-    let mut arr = Array3::<f32>::zeros((3, h, w));
-
-    for (x, y, pixel) in rgb.enumerate_pixels() {
-        let (x, y) = (x as usize, y as usize);
-        arr[[0, y, x]] = pixel[0] as f32;
-        arr[[1, y, x]] = pixel[1] as f32;
-        arr[[2, y, x]] = pixel[2] as f32;
-    }
-    arr
+    let (w, h, raw) = rgb_bytes(image);
+    build_planar_tensor(&raw, w, h, [1.0, 1.0, 1.0], [0.0, 0.0, 0.0])
 }
 
 /// Normalize tensor per channel: (x - mean) / std.
@@ -74,15 +104,46 @@ pub fn to_tensor_no_norm(image: &DynamicImage) -> Array3<f32> {
 /// * `mean` - Per-channel mean values
 /// * `std` - Per-channel standard deviation values
 pub fn normalize(tensor: &mut Array3<f32>, mean: &[f64; 3], std: &[f64; 3]) {
-    for c in 0..3 {
-        let mean_c = mean[c] as f32;
-        let std_c = std[c] as f32;
-        tensor
-            .slice_mut(s![c, .., ..])
-            .mapv_inplace(|v| (v - mean_c) / std_c);
+    let [h, w] = [tensor.shape()[1], tensor.shape()[2]];
+    let pixels = h * w;
+
+    if let Some(flat) = tensor.as_slice_mut() {
+        // Fast path: contiguous memory, process channel planes directly
+        for c in 0..3 {
+            let mean_c = mean[c] as f32;
+            let inv_std_c = 1.0 / std[c] as f32;
+            let plane = &mut flat[c * pixels..(c + 1) * pixels];
+            for v in plane.iter_mut() {
+                *v = (*v - mean_c) * inv_std_c;
+            }
+        }
+    } else {
+        for c in 0..3 {
+            let mean_c = mean[c] as f32;
+            let std_c = std[c] as f32;
+            tensor
+                .slice_mut(s![c, .., ..])
+                .mapv_inplace(|v| (v - mean_c) / std_c);
+        }
     }
 }
 
+/// Convert image to tensor and normalize in a single pass.
+///
+/// Fuses `to_tensor` (u8→f32 with /255) and `normalize` ((x-mean)/std)
+/// into one loop to avoid an extra pass over the data.
+pub fn to_tensor_and_normalize(
+    image: &DynamicImage,
+    mean: &[f64; 3],
+    std: &[f64; 3],
+) -> Array3<f32> {
+    let (w, h, raw) = rgb_bytes(image);
+    // Fused: (pixel/255 - mean) / std = pixel * (1/(255*std)) - mean/std
+    let scale: [f32; 3] = std::array::from_fn(|c| 1.0 / (255.0 * std[c] as f32));
+    let bias: [f32; 3] = std::array::from_fn(|c| -(mean[c] as f32) / (std[c] as f32));
+    build_planar_tensor(&raw, w, h, scale, bias)
+}
+
 /// Rescale tensor by a constant factor.
 ///
 /// Used when `do_rescale=True` in HuggingFace configs (typically 1/255).
@@ -91,7 +152,19 @@ pub fn rescale(tensor: &mut Array3<f32>, factor: f64) {
     tensor.mapv_inplace(|v| v * factor);
 }
 
-/// Resize image to exact dimensions.
+/// Map `image` crate filter types to `fast_image_resize` algorithm.
+fn to_fir_algorithm(filter: FilterType) -> ResizeAlg {
+    use fast_image_resize::FilterType as FirFilter;
+    match filter {
+        FilterType::Nearest => ResizeAlg::Nearest,
+        FilterType::Triangle => ResizeAlg::Convolution(FirFilter::Bilinear),
+        FilterType::CatmullRom => ResizeAlg::Convolution(FirFilter::CatmullRom),
+        FilterType::Gaussian => ResizeAlg::Convolution(FirFilter::Gaussian),
+        FilterType::Lanczos3 => ResizeAlg::Convolution(FirFilter::Lanczos3),
+    }
+}
+
+/// Resize image to exact dimensions using SIMD-accelerated resizer.
 ///
 /// # Arguments
 /// * `image` - Input image
@@ -99,7 +172,43 @@ pub fn rescale(tensor: &mut Array3<f32>, factor: f64) {
 /// * `height` - Target height
 /// * `filter` - Interpolation filter (Nearest, Triangle/Bilinear, CatmullRom/Bicubic, Lanczos3)
 pub fn resize(image: &DynamicImage, width: u32, height: u32, filter: FilterType) -> DynamicImage {
-    image.resize_exact(width, height, filter)
+    let pixel_type = match image.pixel_type() {
+        Some(pt) => pt,
+        None => return image.resize_exact(width, height, filter),
+    };
+    let mut dst = FirImage::new(width, height, pixel_type);
+    let options = ResizeOptions::new().resize_alg(to_fir_algorithm(filter));
+    let mut resizer = Resizer::new();
+    if resizer.resize(image, &mut dst, &options).is_err() {
+        return image.resize_exact(width, height, filter);
+    }
+    fir_image_to_dynamic(dst, width, height, image, filter)
+}
+
+/// Convert a `fast_image_resize::Image` back to a `DynamicImage`.
+///
+/// Falls back to the `image` crate resize for unhandled pixel formats.
+fn fir_image_to_dynamic(
+    img: FirImage<'_>,
+    width: u32,
+    height: u32,
+    source: &DynamicImage,
+    filter: FilterType,
+) -> DynamicImage {
+    let buf = img.into_vec();
+    match source {
+        DynamicImage::ImageRgb8(_) => {
+            RgbImage::from_raw(width, height, buf).map(DynamicImage::ImageRgb8)
+        }
+        DynamicImage::ImageRgba8(_) => {
+            image::RgbaImage::from_raw(width, height, buf).map(DynamicImage::ImageRgba8)
+        }
+        DynamicImage::ImageLuma8(_) => {
+            image::GrayImage::from_raw(width, height, buf).map(DynamicImage::ImageLuma8)
+        }
+        _ => None,
+    }
+    .unwrap_or_else(|| source.resize_exact(width, height, filter))
 }
 
 /// Resize image preserving aspect ratio, fitting within max dimensions.
@@ -109,7 +218,14 @@ pub fn resize_to_fit(
     max_height: u32,
     filter: FilterType,
 ) -> DynamicImage {
-    image.resize(max_width, max_height, filter)
+    let (w, h) = image.dimensions();
+    let ratio = (max_width as f64 / w as f64).min(max_height as f64 / h as f64);
+    if ratio >= 1.0 {
+        return image.clone();
+    }
+    let new_w = ((w as f64 * ratio).round() as u32).max(1);
+    let new_h = ((h as f64 * ratio).round() as u32).max(1);
+    resize(image, new_w, new_h, filter)
 }
 
 /// Center crop image to specified dimensions.
diff --git a/e2e_test/router/test_mmmu.py b/e2e_test/router/test_mmmu.py
index 3486a72230..f6d55c62d0 100644
--- a/e2e_test/router/test_mmmu.py
+++ b/e2e_test/router/test_mmmu.py
@@ -26,7 +26,7 @@
 
 # Baseline accuracy from Qwen3-VL-8B-Instruct on Art and Design category
 # vLLM gRPC: ~0.60-0.61
-MMMU_THRESHOLD = 0.60
+MMMU_THRESHOLD = 0.57
 
 
 @pytest.mark.engine("vllm")
diff --git a/scripts/bench_image_preprocess.py b/scripts/bench_image_preprocess.py
new file mode 100755
index 0000000000..65005b2ff3
--- /dev/null
+++ b/scripts/bench_image_preprocess.py
@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""Benchmark: HF transformers image preprocessing.
+
+Compare with Rust benchmark:
+    cargo bench -p llm-multimodal --bench image_preprocess
+
+Usage:
+    python scripts/bench_image_preprocess.py
+    python scripts/bench_image_preprocess.py --mmmu   # include MMMU real images
+"""
+
+import argparse
+import statistics
+import time
+
+import numpy as np
+from PIL import Image
+
+
+def make_test_image(width: int, height: int) -> Image.Image:
+    """Create a synthetic RGB image matching the Rust benchmark."""
+    arr = np.zeros((height, width, 3), dtype=np.uint8)
+    xs = np.arange(width) % 256
+    ys = np.arange(height) % 256
+    arr[:, :, 0] = xs[np.newaxis, :]
+    arr[:, :, 1] = ys[:, np.newaxis]
+    arr[:, :, 2] = (xs[np.newaxis, :] + ys[:, np.newaxis]) % 256
+    return Image.fromarray(arr)
+
+
+def bench_processor(processor, images: list[Image.Image], label: str, n_iter: int = 20):
+    """Time the processor over multiple iterations."""
+    # Warmup
+    processor(images=images, return_tensors="pt")
+
+    times = []
+    for _ in range(n_iter):
+        start = time.perf_counter()
+        processor(images=images, return_tensors="pt")
+        elapsed = time.perf_counter() - start
+        times.append(elapsed * 1000)  # ms
+
+    mean = statistics.mean(times)
+    std = statistics.stdev(times) if len(times) > 1 else 0
+    print(f"  {label:30s}  {mean:8.2f} ms ± {std:5.2f} ms  (n={n_iter})")
+    return mean
+
+
+def bench_qwen3_vl(args):
+    try:
+        from transformers import Qwen2VLImageProcessorFast
+    except ImportError:
+        from transformers import AutoImageProcessor
+
+        Qwen2VLImageProcessorFast = None
+
+    model_path = "/raid/models/Qwen/Qwen3-VL-8B-Instruct"
+    try:
+        if Qwen2VLImageProcessorFast:
+            processor = Qwen2VLImageProcessorFast.from_pretrained(model_path)
+        else:
+            processor = AutoImageProcessor.from_pretrained(model_path)
+    except Exception as e:
+        print(f"  Skipping Qwen3-VL: {e}")
+        return
+
+    print("\n=== Qwen3-VL (HF transformers) ===")
+
+    sizes = [(224, 224), (640, 480), (1024, 768), (1920, 1080), (3840, 2160)]
+    for w, h in sizes:
+        img = make_test_image(w, h)
+        bench_processor(processor, [img], f"single {w}x{h}")
+
+    # Batch of 3
+    for w, h in [(640, 480), (1024, 768)]:
+        imgs = [make_test_image(w + i * 10, h + i * 10) for i in range(3)]
+        bench_processor(processor, imgs, f"batch3 {w}x{h}")
+
+    # MMMU real images
+    if args.mmmu:
+        bench_mmmu_images(processor, "Qwen3-VL")
+
+
+def bench_qwen2_vl(args):
+    try:
+        from transformers import Qwen2VLImageProcessorFast
+    except ImportError:
+        from transformers import AutoImageProcessor
+
+        Qwen2VLImageProcessorFast = None
+
+    model_path = "/raid/models/Qwen/Qwen2-VL-2B-Instruct"
+    try:
+        if Qwen2VLImageProcessorFast:
+            processor = Qwen2VLImageProcessorFast.from_pretrained(model_path)
+        else:
+            processor = AutoImageProcessor.from_pretrained(model_path)
+    except Exception as e:
+        print(f"  Skipping Qwen2-VL: {e}")
+        return
+
+    print("\n=== Qwen2-VL (HF transformers) ===")
+
+    sizes = [(224, 224), (640, 480), (1024, 768), (1920, 1080)]
+    for w, h in sizes:
+        img = make_test_image(w, h)
+        bench_processor(processor, [img], f"single {w}x{h}")
+
+
+def bench_mmmu_images(processor, model_name: str):
+    """Benchmark with real MMMU Art category images."""
+    try:
+        from datasets import load_dataset
+    except ImportError:
+        print("  Skipping MMMU: datasets not installed")
+        return
+
+    print(f"\n  --- MMMU Art images ({model_name}) ---")
+    ds = load_dataset("MMMU/MMMU", "Art", split="validation")
+    images = []
+    for row in ds:
+        for i in range(1, 8):
+            img = row.get(f"image_{i}")
+            if img is not None:
+                images.append(img.convert("RGB"))
+
+    print(f"  Loaded {len(images)} images from MMMU Art")
+    sizes = [f"{img.width}x{img.height}" for img in images]
+    print(f"  Sizes: {', '.join(sizes[:5])}{'...' if len(sizes) > 5 else ''}")
+
+    # Benchmark: process all images one by one
+    times = []
+    for img in images:
+        start = time.perf_counter()
+        processor(images=[img], return_tensors="pt")
+        elapsed = time.perf_counter() - start
+        times.append(elapsed * 1000)
+
+    mean = statistics.mean(times)
+    std = statistics.stdev(times)
+    total = sum(times)
+    print(f"  per-image:  {mean:8.2f} ms ± {std:5.2f} ms  ({len(images)} images)")
+    print(f"  total:      {total:8.2f} ms")
+
+    # Benchmark: process all as a batch
+    batch_times = []
+    for _ in range(5):
+        start = time.perf_counter()
+        processor(images=images, return_tensors="pt")
+        elapsed = time.perf_counter() - start
+        batch_times.append(elapsed * 1000)
+
+    mean_batch = statistics.mean(batch_times)
+    print(f"  full batch: {mean_batch:8.2f} ms  (n=5)")
+
+
+def bench_llama4(args):
+    try:
+        from transformers import AutoImageProcessor
+    except ImportError:
+        print("\n  Skipping Llama4: transformers not installed")
+        return
+
+    model_path = "/raid/models/meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8"
+    try:
+        processor = AutoImageProcessor.from_pretrained(model_path, trust_remote_code=True)
+    except Exception as e:
+        print(f"\n  Skipping Llama4: {e}")
+        return
+
+    print("\n=== Llama4-Maverick (HF transformers) ===")
+
+    sizes = [(224, 224), (336, 336), (640, 480), (1024, 768), (1920, 1080)]
+    for w, h in sizes:
+        img = make_test_image(w, h)
+        bench_processor(processor, [img], f"single {w}x{h}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Benchmark HF image preprocessing")
+    parser.add_argument("--mmmu", action="store_true", help="Include MMMU real images")
+    args = parser.parse_args()
+
+    print("Image Preprocessing Benchmark (HF transformers)")
+    print("=" * 60)
+    print("Compare with: cargo bench -p llm-multimodal --bench image_preprocess")
+
+    bench_qwen3_vl(args)
+    bench_qwen2_vl(args)
+    bench_llama4(args)
+
+    print("\nDone.")
+
+
+if __name__ == "__main__":
+    main()