diff --git a/.gitignore b/.gitignore
index a7ddca8..62603b1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 build/
 docs/html/
 .vscode/
-.json
\ No newline at end of file
+.json
+__pycache__/
\ No newline at end of file
diff --git a/BUILD.md b/BUILD.md
index 245d062..946a1d5 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -108,6 +108,7 @@ These are set with `-D<OPTION>=<ON|OFF>` at the `cmake ..` configure step, e.g.
 | `ENABLE_E2E_TESTS` | `ON` | Adds the e2e lit suite (`tests/lit/e2e/`, the `e2e` build target). Set to `OFF` to skip building/copying it, e.g. if `lit` isn't available. |
 | `ENABLE_CLANG_TIDY` | `OFF` | Runs `clang-tidy` as part of the normal build (`-warnings-as-errors=*`), using the project's `.clang-tidy` config. Requires `clang-tidy` to be on your `PATH`. |
 | `ENABLE_DOCS` | `OFF` | Adds a `doc_doxygen` build target that generates the Doxygen API docs into `docs/html/` (requires Doxygen to be installed). Build it explicitly with `cmake --build . --target doc_doxygen`. |
+| `ENABLE_BENCH` | `ON` | Adds the `bench/` subdirectory, building the standalone `reference_bench` binary (naive C++ vs OpenCV timings; no MLIR/picceler runtime dependency). |
 
 ### Build type
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3c8a30b..42d5ad4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,6 +8,7 @@ option(ENABLE_TESTS "Enable testing" ON)
 option(ENABLE_E2E_TESTS "Enable end-to-end (compile-and-run) tests" ON)
 option(ENABLE_CLANG_TIDY "Enable clang-tidy" OFF)
 option(ENABLE_DOCS "Enable documentation generation" OFF)
+option(ENABLE_BENCH "Enable the reference_bench benchmark target" ON)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "Generate compile_commands.json" FORCE)
 
@@ -92,6 +93,10 @@ if (ENABLE_TESTS)
   add_subdirectory(tests)
 endif()
 
+if (ENABLE_BENCH)
+  add_subdirectory(bench)
+endif()
+
 
 
 
diff --git a/bench/CMakeLists.txt b/bench/CMakeLists.txt
new file mode 100644
index 0000000..cff280e
--- /dev/null
+++ b/bench/CMakeLists.txt
@@ -0,0 +1,14 @@
+find_package(OpenCV REQUIRED)
+
+add_executable(reference_bench
+    reference_bench.cpp
+)
+
+target_link_libraries(reference_bench PRIVATE
+    ${OpenCV_LIBS}
+    CLI11::CLI11
+)
+
+set_target_properties(reference_bench PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+)
diff --git a/bench/RESULTS.md b/bench/RESULTS.md
new file mode 100644
index 0000000..da52da8
--- /dev/null
+++ b/bench/RESULTS.md
@@ -0,0 +1,15 @@
+# Benchmark Results
+
+- Date: 2026-09-06
+- CPU: Intel(R) Core(TM) i5-14600KF
+- Image: `bench.jpg` (1092344 bytes)
+- Iterations: 50
+
+Generated locally by `bench/run_bench.py`, not in CI -- see bench/reference_bench.cpp for the naive/OpenCV implementations and bench/pic/ for the picceler programs.
+
+| operation | picceler | naive C++ | OpenCV |
+| --- | --- | --- | --- |
+| invert | 18.4 ms | 6.8 ms | 4.9 ms |
+| brightness(+30) | 18.1 ms | 8.0 ms | 5.3 ms |
+| gaussian_blur(r=6) | 1415.7 ms | 1051.5 ms | 12.3 ms |
+| sharpen(3x3) | 93.4 ms | 79.4 ms | 15.4 ms |
diff --git a/bench/pic/bench_brightness.pic b/bench/pic/bench_brightness.pic
new file mode 100644
index 0000000..ace2398
--- /dev/null
+++ b/bench/pic/bench_brightness.pic
@@ -0,0 +1,10 @@
+def main() -> int64 {
+    image img = load_image("img/bench.jpg")
+
+    for (i = 0 .. 50) {
+        image out = brightness(img, 30)
+        save_image(out, "bench_brightness_out.png")
+    }
+
+    return 0
+}
diff --git a/bench/pic/bench_gaussian_blur.pic b/bench/pic/bench_gaussian_blur.pic
new file mode 100644
index 0000000..3ec0ae3
--- /dev/null
+++ b/bench/pic/bench_gaussian_blur.pic
@@ -0,0 +1,10 @@
+def main() -> int64 {
+    image img = load_image("img/bench.jpg")
+
+    for (i = 0 .. 50) {
+        image out = gaussian_blur(img, 6)
+        save_image(out, "bench_gaussian_blur_out.png")
+    }
+
+    return 0
+}
diff --git a/bench/pic/bench_invert.pic b/bench/pic/bench_invert.pic
new file mode 100644
index 0000000..0235160
--- /dev/null
+++ b/bench/pic/bench_invert.pic
@@ -0,0 +1,10 @@
+def main() -> int64 {
+    image img = load_image("img/bench.jpg")
+
+    for (i = 0 .. 50) {
+        image out = invert(img)
+        save_image(out, "bench_invert_out.png")
+    }
+
+    return 0
+}
diff --git a/bench/pic/bench_sharpen.pic b/bench/pic/bench_sharpen.pic
new file mode 100644
index 0000000..a0c2ec6
--- /dev/null
+++ b/bench/pic/bench_sharpen.pic
@@ -0,0 +1,10 @@
+def main() -> int64 {
+    image img = load_image("img/bench.jpg")
+
+    for (i = 0 .. 50) {
+        image out = sharpen(img, 40)
+        save_image(out, "bench_sharpen_out.png")
+    }
+
+    return 0
+}
diff --git a/bench/reference_bench.cpp b/bench/reference_bench.cpp
new file mode 100644
index 0000000..88b9562
--- /dev/null
+++ b/bench/reference_bench.cpp
@@ -0,0 +1,297 @@
+#include <CLI/CLI.hpp>
+#include <opencv2/opencv.hpp>
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+#include <numbers>
+#include <string>
+#include <vector>
+
+namespace {
+
+using Clock = std::chrono::steady_clock;
+
+// Benchmark parameters
+constexpr int kBrightnessDelta = 30;
+constexpr int kGaussianRadius = 6;
+constexpr double kSharpenStrength = 40.0;
+
+struct BenchResult {
+  std::string operation;
+  std::string label;
+  double naiveMs;
+  double opencvMs;
+};
+
+double median(std::vector<double> samples) {
+  std::sort(samples.begin(), samples.end());
+  size_t n = samples.size();
+  return (n % 2 == 0) ? (samples[n / 2 - 1] + samples[n / 2]) / 2.0 : samples[n / 2];
+}
+
+template <typename Fn> double timeMedianMs(int iterations, Fn &&fn) {
+  fn(); // untimed warm-up
+
+  std::vector<double> samples;
+  samples.reserve(iterations);
+  for (int i = 0; i < iterations; ++i) {
+    auto start = Clock::now();
+    fn();
+    auto end = Clock::now();
+    samples.push_back(std::chrono::duration<double, std::milli>(end - start).count());
+  }
+  return median(std::move(samples));
+}
+
+// dst never freed until after all iterations, matching picceler's per-call leak
+template <typename Fn> double timeMedianMsFreshOutput(int iterations, Fn &&fn) {
+  std::vector<cv::Mat> outputs;
+  outputs.reserve(iterations + 1);
+  return timeMedianMs(iterations, [&] {
+    outputs.emplace_back();
+    fn(outputs.back());
+  });
+}
+
+std::vector<double> buildGaussianKernel(int radius) {
+  int size = 2 * radius + 1;
+  double sigma = std::max(radius / 2.0, 0.5);
+
+  std::vector<double> values;
+  values.reserve(static_cast<size_t>(size) * size);
+  double sum = 0.0;
+  for (int y = -radius; y <= radius; ++y) {
+    for (int x = -radius; x <= radius; ++x) {
+      double exponent = -static_cast<double>(x * x + y * y) / (2 * sigma * sigma);
+      double value = std::exp(exponent) / (2 * std::numbers::pi * sigma * sigma);
+      values.push_back(value);
+      sum += value;
+    }
+  }
+  for (double &v : values) {
+    v /= sum;
+  }
+  return values;
+}
+
+std::vector<double> buildSharpenKernel(double strengthValue) {
+  double strength = strengthValue / 25.0;
+  double center = 1.0 + 4.0 * strength;
+  double neighbor = -strength;
+  return {0.0, neighbor, 0.0, neighbor, center, neighbor, 0.0, neighbor, 0.0};
+}
+
+// ---- naive scalar reference implementations. Images are RGBA8 (CV_8UC4).
+// All four ops leave the alpha channel untouched
+
+void naiveInvert(const cv::Mat &src, cv::Mat &dst) {
+  dst.create(src.size(), src.type());
+  for (int y = 0; y < src.rows; ++y) {
+    const uint8_t *s = src.ptr<uint8_t>(y);
+    uint8_t *d = dst.ptr<uint8_t>(y);
+    for (int x = 0; x < src.cols; ++x) {
+      d[x * 4 + 0] = 255 - s[x * 4 + 0];
+      d[x * 4 + 1] = 255 - s[x * 4 + 1];
+      d[x * 4 + 2] = 255 - s[x * 4 + 2];
+      d[x * 4 + 3] = s[x * 4 + 3];
+    }
+  }
+}
+
+void naiveBrightness(const cv::Mat &src, cv::Mat &dst, int delta) {
+  dst.create(src.size(), src.type());
+  for (int y = 0; y < src.rows; ++y) {
+    const uint8_t *s = src.ptr<uint8_t>(y);
+    uint8_t *d = dst.ptr<uint8_t>(y);
+    for (int x = 0; x < src.cols; ++x) {
+      for (int c = 0; c < 3; ++c) {
+        int v = static_cast<int>(s[x * 4 + c]) + delta;
+        d[x * 4 + c] = static_cast<uint8_t>(std::clamp(v, 0, 255));
+      }
+      d[x * 4 + 3] = s[x * 4 + 3];
+    }
+  }
+}
+
+// Generic RGB-channel 2D convolution used by both gaussian_blur and sharpen.
+void naiveConvolveRGB(const cv::Mat &src, cv::Mat &dst, const std::vector<double> &kernel, int kRows, int kCols) {
+  dst.create(src.size(), src.type());
+  int rowRadius = kRows / 2;
+  int colRadius = kCols / 2;
+
+  for (int y = 0; y < src.rows; ++y) {
+    for (int x = 0; x < src.cols; ++x) {
+      double acc[3] = {0.0, 0.0, 0.0};
+      for (int ky = 0; ky < kRows; ++ky) {
+        int sy = y + ky - rowRadius;
+        if (sy < 0 || sy >= src.rows)
+          continue;
+        for (int kx = 0; kx < kCols; ++kx) {
+          int sx = x + kx - colRadius;
+          if (sx < 0 || sx >= src.cols)
+            continue;
+          double w = kernel[ky * kCols + kx];
+          const uint8_t *p = src.ptr<uint8_t>(sy) + sx * 4;
+          acc[0] += p[0] * w;
+          acc[1] += p[1] * w;
+          acc[2] += p[2] * w;
+        }
+      }
+      uint8_t *d = dst.ptr<uint8_t>(y) + x * 4;
+      for (int c = 0; c < 3; ++c) {
+        d[c] = static_cast<uint8_t>(std::clamp(acc[c], 0.0, 255.0));
+      }
+      d[3] = src.ptr<uint8_t>(y)[x * 4 + 3];
+    }
+  }
+}
+
+// ---- OpenCV reference implementations ----
+
+void opencvInvert(const cv::Mat &src, cv::Mat &dst) { cv::bitwise_not(src, dst); }
+
+void opencvBrightness(const cv::Mat &src, cv::Mat &dst, int delta) {
+  cv::add(src, cv::Scalar(delta, delta, delta, 0), dst);
+}
+
+// Splits off the alpha channel so blur/sharpen only do RGB work, matching the
+// naive/picceler columns (which also leave alpha untouched) rather than
+// having OpenCV do a 4th channel of work the other two columns don't.
+cv::Mat splitAlpha(const cv::Mat &rgba, cv::Mat &alphaOut) {
+  std::vector<cv::Mat> channels;
+  cv::split(rgba, channels);
+  alphaOut = channels[3];
+  cv::Mat rgb;
+  cv::merge(std::vector<cv::Mat>{channels[0], channels[1], channels[2]}, rgb);
+  return rgb;
+}
+
+cv::Mat mergeAlpha(const cv::Mat &rgb, const cv::Mat &alpha) {
+  std::vector<cv::Mat> channels;
+  cv::split(rgb, channels);
+  channels.push_back(alpha);
+  cv::Mat rgba;
+  cv::merge(channels, rgba);
+  return rgba;
+}
+
+void opencvGaussianBlur(const cv::Mat &src, cv::Mat &dst, int radius) {
+  cv::Mat alpha;
+  cv::Mat rgb = splitAlpha(src, alpha);
+
+  int size = 2 * radius + 1;
+  double sigma = std::max(radius / 2.0, 0.5);
+  cv::Mat blurred;
+  // BORDER_CONSTANT (zero-padding) to match picceler's own border handling,
+  // so the two columns differ in speed, not in what they compute at edges.
+  cv::GaussianBlur(rgb, blurred, cv::Size(size, size), sigma, sigma, cv::BORDER_CONSTANT);
+
+  dst = mergeAlpha(blurred, alpha);
+}
+
+void opencvSharpen(const cv::Mat &src, cv::Mat &dst, double strengthValue) {
+  cv::Mat alpha;
+  cv::Mat rgb = splitAlpha(src, alpha);
+
+  std::vector<double> kernelValues = buildSharpenKernel(strengthValue);
+  cv::Mat kernel(3, 3, CV_64F, kernelValues.data());
+  cv::Mat sharpened;
+  cv::filter2D(rgb, sharpened, -1, kernel, cv::Point(-1, -1), 0.0, cv::BORDER_CONSTANT);
+
+  dst = mergeAlpha(sharpened, alpha);
+}
+
+void printTable(const std::vector<BenchResult> &results) {
+  std::cout << std::left << std::setw(20) << "operation" << std::right << std::setw(14) << "naive (ms)" << std::setw(14)
+            << "opencv (ms)" << "\n";
+  std::cout << std::string(48, '-') << "\n";
+  std::cout << std::fixed << std::setprecision(2);
+  for (const auto &r : results) {
+    std::cout << std::left << std::setw(20) << r.label << std::right << std::setw(14) << r.naiveMs << std::setw(14)
+              << r.opencvMs << "\n";
+  }
+}
+
+void printJson(const std::vector<BenchResult> &results, int iterations) {
+  std::cout << std::fixed << std::setprecision(4);
+  std::cout << "{\n  \"iterations\": " << iterations << ",\n  \"results\": [\n";
+  for (size_t i = 0; i < results.size(); ++i) {
+    const auto &r = results[i];
+    std::cout << "    {\"operation\": \"" << r.operation << "\", \"label\": \"" << r.label
+              << "\", \"naive_ms\": " << r.naiveMs << ", \"opencv_ms\": " << r.opencvMs << "}";
+    std::cout << (i + 1 < results.size() ? ",\n" : "\n");
+  }
+  std::cout << "  ]\n}\n";
+}
+
+} // namespace
+
+int main(int argc, char **argv) {
+  CLI::App app{"Naive C++ vs OpenCV reference benchmark for picceler's builtin operations"};
+
+  std::string imagePath;
+  app.add_option("image-path", imagePath, "Path to the input image")->required();
+
+  int iterations = 20;
+  app.add_option("iterations", iterations, "Timed iterations per operation")->check(CLI::PositiveNumber);
+
+  bool jsonOutput = false;
+  app.add_flag("--json", jsonOutput, "Print results as JSON instead of a table");
+
+  CLI11_PARSE(app, argc, argv);
+
+  cv::Mat loaded = cv::imread(imagePath);
+  if (loaded.empty()) {
+    std::cerr << "reference_bench: failed to load image: " << imagePath << "\n";
+    return 1;
+  }
+
+  // Match lib/src/image.cpp's loadImage(): picceler-generated code always
+  // operates on RGBA8, so that's the workload naive/OpenCV must match too.
+  cv::Mat rgba;
+  cv::cvtColor(loaded, rgba, cv::COLOR_BGR2RGBA);
+
+  std::vector<BenchResult> results;
+
+  {
+    double naiveMs = timeMedianMsFreshOutput(iterations, [&](cv::Mat &dst) { naiveInvert(rgba, dst); });
+    double opencvMs = timeMedianMsFreshOutput(iterations, [&](cv::Mat &dst) { opencvInvert(rgba, dst); });
+    results.push_back({"invert", "invert", naiveMs, opencvMs});
+  }
+  {
+    double naiveMs =
+        timeMedianMsFreshOutput(iterations, [&](cv::Mat &dst) { naiveBrightness(rgba, dst, kBrightnessDelta); });
+    double opencvMs =
+        timeMedianMsFreshOutput(iterations, [&](cv::Mat &dst) { opencvBrightness(rgba, dst, kBrightnessDelta); });
+    results.push_back({"brightness", "brightness(+" + std::to_string(kBrightnessDelta) + ")", naiveMs, opencvMs});
+  }
+  {
+    std::vector<double> kernel = buildGaussianKernel(kGaussianRadius);
+    int size = 2 * kGaussianRadius + 1;
+    double naiveMs = timeMedianMsFreshOutput(
+        iterations, [&](cv::Mat &dst) { naiveConvolveRGB(rgba, dst, kernel, size, size); });
+    double opencvMs =
+        timeMedianMsFreshOutput(iterations, [&](cv::Mat &dst) { opencvGaussianBlur(rgba, dst, kGaussianRadius); });
+    results.push_back({"gaussian_blur", "gaussian_blur(r=" + std::to_string(kGaussianRadius) + ")", naiveMs, opencvMs});
+  }
+  {
+    std::vector<double> kernel = buildSharpenKernel(kSharpenStrength);
+    double naiveMs =
+        timeMedianMsFreshOutput(iterations, [&](cv::Mat &dst) { naiveConvolveRGB(rgba, dst, kernel, 3, 3); });
+    double opencvMs =
+        timeMedianMsFreshOutput(iterations, [&](cv::Mat &dst) { opencvSharpen(rgba, dst, kSharpenStrength); });
+    results.push_back({"sharpen", "sharpen(3x3)", naiveMs, opencvMs});
+  }
+
+  if (jsonOutput) {
+    printJson(results, iterations);
+  } else {
+    printTable(results);
+  }
+
+  return 0;
+}
diff --git a/bench/run_bench.py b/bench/run_bench.py
new file mode 100755
index 0000000..5fc543a
--- /dev/null
+++ b/bench/run_bench.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""POC driver: compiles+runs bench/pic/bench_*.pic with --profile for picceler's own numbers, runs
+reference_bench for the naive C++ / OpenCV columns, and merges both into bench/RESULTS.md.
+
+Usage: bench/run_bench.py [--build-dir build] [--image bench.jpg] [--iterations 50]
+"""
+import argparse
+import json
+import platform
+import statistics
+import subprocess
+import sys
+from datetime import date
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(REPO_ROOT / "tools" / "picceler-trace-to-json"))
+import pictrace  # noqa: E402 (needs sys.path set up first)
+
+OPERATIONS = ["invert", "brightness", "gaussian_blur", "sharpen"]
+LABELS = {
+    "invert": "invert",
+    "brightness": "brightness(+30)",
+    "gaussian_blur": "gaussian_blur(r=6)",
+    "sharpen": "sharpen(3x3)",
+}
+
+
+def median_duration_ms(events, name):
+    open_by_track = {}
+    durations = []
+    for event in events:
+        stack = open_by_track.setdefault(event["track_id"], [])
+        if event["phase"] == "B":
+            stack.append(event)
+        elif stack and stack[-1]["name"] == event["name"]:
+            begin = stack.pop()
+            if event["name"] == name:
+                durations.append((event["timestamp_ns"] - begin["timestamp_ns"]) / 1e6)
+    if not durations:
+        raise RuntimeError(f"no trace events found for '{name}'")
+    return statistics.median(durations)
+
+
+def run_picceler_bench(picceler_bin, build_dir, pic_dir, work_dir, op):
+    pic_file = pic_dir / f"bench_{op}.pic"
+    exe = work_dir / f"bench_{op}_bin"
+    subprocess.run([str(picceler_bin), "--profile", "-o", str(exe), str(pic_file)], check=True, cwd=build_dir)
+
+    trace_path = build_dir / "picceler_profiling_trace.bin"
+    trace_path.unlink(missing_ok=True)
+    subprocess.run([str(exe)], check=True, cwd=build_dir, stdout=subprocess.DEVNULL)
+
+    events = pictrace.parse_trace(trace_path.read_bytes())
+    trace_path.unlink()
+    return median_duration_ms(events, f"picceler.{op}")
+
+
+def run_reference_bench(reference_bench_bin, image_path, iterations):
+    result = subprocess.run(
+        [str(reference_bench_bin), str(image_path), str(iterations), "--json"],
+        check=True, capture_output=True, text=True,
+    )
+    data = json.loads(result.stdout)
+    return {r["operation"]: (r["naive_ms"], r["opencv_ms"]) for r in data["results"]}
+
+
+def cpu_model():
+    try:
+        with open("/proc/cpuinfo") as f:
+            for line in f:
+                if line.startswith("model name"):
+                    return line.split(":", 1)[1].strip()
+    except OSError:
+        pass
+    return platform.processor() or platform.machine() or "unknown"
+
+
+def render_results_md(picceler_results, reference_results, iterations, image_path):
+    lines = [
+        "# Benchmark Results",
+        "",
+        f"- Date: {date.today().isoformat()}",
+        f"- CPU: {cpu_model()}",
+        f"- Image: `{image_path.name}` ({image_path.stat().st_size} bytes)",
+        f"- Iterations: {iterations}",
+        "",
+        "Generated locally by `bench/run_bench.py`, not in CI -- see bench/reference_bench.cpp for "
+        "the naive/OpenCV implementations and bench/pic/ for the picceler programs.",
+        "",
+        "| operation | picceler | naive C++ | OpenCV |",
+        "| --- | --- | --- | --- |",
+    ]
+    for op in OPERATIONS:
+        naive_ms, opencv_ms = reference_results[op]
+        lines.append(f"| {LABELS[op]} | {picceler_results[op]:.1f} ms | {naive_ms:.1f} ms | {opencv_ms:.1f} ms |")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--build-dir", type=Path, default=REPO_ROOT / "build")
+    parser.add_argument("--image", default="bench.jpg", help="filename under <build-dir>/img/")
+    parser.add_argument("--iterations", type=int, default=50,
+                        help="reference_bench iterations; the .pic programs' own loop count is fixed at compile "
+                             "time (currently 50 too) -- change bench/pic/bench_*.pic to keep them in sync")
+    parser.add_argument("-o", "--output", type=Path, default=REPO_ROOT / "bench" / "RESULTS.md")
+    args = parser.parse_args()
+
+    build_dir = args.build_dir.resolve()
+    picceler_bin = build_dir / "picceler"
+    reference_bench_bin = build_dir / "reference_bench"
+    image_path = build_dir / "img" / args.image
+    pic_dir = REPO_ROOT / "bench" / "pic"
+    work_dir = build_dir / "bench_tmp"
+    work_dir.mkdir(exist_ok=True)
+
+    for required in (picceler_bin, reference_bench_bin, image_path):
+        if not required.exists():
+            sys.exit(f"error: required path does not exist: {required}")
+
+    print(f"Running naive C++ / OpenCV reference ({args.iterations} iterations)...")
+    reference_results = run_reference_bench(reference_bench_bin, image_path, args.iterations)
+
+    picceler_results = {}
+    for op in OPERATIONS:
+        print(f"Compiling and profiling picceler '{op}'...")
+        picceler_results[op] = run_picceler_bench(picceler_bin, build_dir, pic_dir, work_dir, op)
+
+    args.output.write_text(render_results_md(picceler_results, reference_results, args.iterations, image_path))
+    print(f"Wrote {args.output}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/profiling.md b/docs/profiling.md
index c716360..071c7bc 100644
--- a/docs/profiling.md
+++ b/docs/profiling.md
@@ -14,7 +14,7 @@ Running the binary writes `picceler_profiling_trace.bin` (cwd) on normal exit. C
 it in Perfetto:
 
 ```bash
-python3 tools/picceler-trace-to-json/picceler-trace-to-json.py picceler_profiling_trace.bin -o trace.json
+python3 tools/picceler-trace-to-json/pictrace.py picceler_profiling_trace.bin -o trace.json
 ```
 
 Open [ui.perfetto.dev](https://ui.perfetto.dev) and load `trace.json`. Each instrumented op is a
@@ -24,7 +24,16 @@ Without `--profile`, nothing changes: no buffer, no atexit handler, no file.
 
 ## What gets instrumented
 
-All `picceler` ops, after initial canonicalization, before any other optimisations otherwise
+Every `picceler` op, after initial canonicalization and before any other optimizations, except:
+
+* `show_image`, `read_number`, `read_string` -- these block on a window/stdin, so one call would
+  dwarf every real op's time on the timeline.
+* `print` -- times stdout buffering, not compute.
+* `kernel.const` -- sub-microsecond next to any real op; just adds a row.
+* `string.const` -- instrumentation itself creates these to hold each traced op's name.
+
+`load_image`/`save_image` are still instrumented: image decode/encode is genuinely part of the
+timeline, often the dominant cost in a short pipeline.
 
 ## The `.bin` format
 
@@ -53,7 +62,7 @@ Each event (24 bytes):
 
 ## Converting to Chrome Trace Event JSON
 
-`tools/picceler-trace-to-json/picceler-trace-to-json.py` (stdlib only) validates magic/version,
+`tools/picceler-trace-to-json/pictrace.py` (stdlib only) validates magic/version,
 turns each B/E pair into two JSON events, normalizes timestamps to start at `ts: 0`, and converts
 nanoseconds to the microsecond float `ts` the format expects. `trackId` maps to `"tid"` as
 `trackId + 1`; `"pid"` is always `1`. An unmatched begin/end (see the `abort()` caveat below) prints
diff --git a/img/bench.jpg b/img/bench.jpg
new file mode 100644
index 0000000..e8b05c9
Binary files /dev/null and b/img/bench.jpg differ
diff --git a/src/picceler_add_profiling_pass.cpp b/src/picceler_add_profiling_pass.cpp
index ff37b1f..e87546b 100644
--- a/src/picceler_add_profiling_pass.cpp
+++ b/src/picceler_add_profiling_pass.cpp
@@ -38,8 +38,11 @@ mlir::func::FuncOp ensureTraceFunc(mlir::ModuleOp module, mlir::OpBuilder &build
 #include "piccelerPasses.h.inc"
 
 /**
- * @brief A pass that wraps every Picceler op (except string.const) with piccelerTraceBegin/
- * piccelerTraceEnd runtime calls
+ * @brief A pass that wraps every Picceler compute/IO op with piccelerTraceBegin/piccelerTraceEnd
+ * runtime calls. Excludes StringConstOp (instrumentation itself creates these) and ShowImageOp/
+ * ReadNumberOp/ReadStringOp (block on a window/stdin, not compute -- one call would swallow every
+ * real op's time into invisibility on the timeline), PrintOp (times stdout buffering, not compute),
+ * and KernelConstOp (sub-microsecond next to any real op, just adds a row).
  */
 struct PiccelerAddProfilingPass : public impl::PiccelerAddProfilingBase<PiccelerAddProfilingPass> {
   void runOnOperation() override {
@@ -51,10 +54,10 @@ struct PiccelerAddProfilingPass : public impl::PiccelerAddProfilingBase<Picceler
     auto beginFunc = ensureTraceFunc(module, builder, "piccelerTraceBegin", stringType);
     auto endFunc = ensureTraceFunc(module, builder, "piccelerTraceEnd", stringType);
 
-    // collect all ops, as instrumentation creates additional string.const ops which we want to omit
     llvm::SmallVector<mlir::Operation *> targets;
     module.walk([&](mlir::Operation *op) {
-      if (op->getDialect() && llvm::isa<PiccelerDialect>(op->getDialect()) && !llvm::isa<StringConstOp>(op))
+      if (op->getDialect() && llvm::isa<PiccelerDialect>(op->getDialect()) &&
+          !llvm::isa<StringConstOp, ShowImageOp, ReadNumberOp, ReadStringOp, PrintOp, KernelConstOp>(op))
         targets.push_back(op);
     });
 
diff --git a/src/picceler_to_affine_pass.cpp b/src/picceler_to_affine_pass.cpp
index 813e9c2..75b2d77 100644
--- a/src/picceler_to_affine_pass.cpp
+++ b/src/picceler_to_affine_pass.cpp
@@ -10,6 +10,7 @@
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/Builders.h"
+#include "mlir/IR/IRMapping.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Transforms/DialectConversion.h"
@@ -137,6 +138,44 @@ struct RotateToAffine : mlir::OpConversionPattern<RotateOp> {
   }
 };
 
+/**
+ * @brief Relocates `value`'s defining chain to `funcOp`'s top level, since MLIR requires an
+ * affine.parallel/affine.apply dim or symbol to be defined there. Only safe for a pure `arith`
+ * chain (a compile-time-constant kernel size); fails otherwise.
+ */
+mlir::FailureOr<mlir::Value> hoistArithChainToFunctionTop(mlir::ConversionPatternRewriter &rewriter,
+                                                          mlir::func::FuncOp funcOp, mlir::Operation *insertBefore,
+                                                          mlir::Value value) {
+  mlir::Region &topLevelRegion = funcOp.getBody();
+
+  mlir::Operation *defOp = value.getDefiningOp();
+  if (!defOp) {
+    auto blockArg = mlir::dyn_cast<mlir::BlockArgument>(value);
+    if (blockArg && blockArg.getOwner()->getParent() == &topLevelRegion)
+      return value;
+    return mlir::failure();
+  }
+  if (defOp->getParentRegion() == &topLevelRegion)
+    return value;
+
+  if (!defOp->getDialect() || !mlir::isa<mlir::arith::ArithDialect>(defOp->getDialect()))
+    return mlir::failure();
+
+  mlir::IRMapping mapping;
+  for (mlir::Value operand : defOp->getOperands()) {
+    auto hoistedOperand = hoistArithChainToFunctionTop(rewriter, funcOp, insertBefore, operand);
+    if (mlir::failed(hoistedOperand))
+      return mlir::failure();
+    mapping.map(operand, *hoistedOperand);
+  }
+
+  // Fixed anchor (not setInsertionPointToStart) keeps leaves ordered before their uses.
+  mlir::OpBuilder::InsertionGuard guard(rewriter);
+  rewriter.setInsertionPoint(insertBefore);
+  mlir::Operation *cloned = rewriter.clone(*defOp, mapping);
+  return cloned->getResult(mlir::cast<mlir::OpResult>(value).getResultNumber());
+}
+
 struct NeighbourhoodOpsToAffine : mlir::OpInterfaceConversionPattern<NeighbourhoodOpInterface> {
   using OpInterfaceConversionPattern::OpInterfaceConversionPattern;
 
@@ -188,6 +227,19 @@ struct NeighbourhoodOpsToAffine : mlir::OpInterfaceConversionPattern<Neighbourho
     mlir::Value neighborhoodColRadiusIdx =
         rewriter.create<mlir::arith::IndexCastOp>(loc, indexType, neighborhoodColRadius);
 
+    auto funcOp = rawOp->getParentOfType<mlir::func::FuncOp>();
+    mlir::Operation *hoistAnchor = &funcOp.getBody().front().front();
+    for (mlir::Value *dimValue :
+        {&neighborhoodRowsIdx, &neighborhoodColsIdx, &neighborhoodRowRadiusIdx, &neighborhoodColRadiusIdx}) {
+      auto hoisted = hoistArithChainToFunctionTop(rewriter, funcOp, hoistAnchor, *dimValue);
+      if (mlir::failed(hoisted)) {
+        rawOp->emitOpError("neighborhood size must be a compile-time constant computable at the function's top "
+                           "level; it cannot depend on a runtime value while nested inside a for/if block");
+        return mlir::failure();
+      }
+      *dimValue = *hoisted;
+    }
+
     mlir::Value zeroIndex = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 0);
 
     auto pixelLoop = createAffineParallel(rewriter, loc, {inputHeight, inputWidth});
diff --git a/tests/lit/e2e/neighbourhood_op_control_flow.pic b/tests/lit/e2e/neighbourhood_op_control_flow.pic
new file mode 100644
index 0000000..5fe6dee
--- /dev/null
+++ b/tests/lit/e2e/neighbourhood_op_control_flow.pic
@@ -0,0 +1,39 @@
+
+# RUN: %picceler -o %t %s
+# RUN: printf "1\n" | %t | FileCheck %s
+
+# CHECK: loaded image
+# CHECK: gaussian_blur inside for-loop: ok
+# CHECK: sharpen inside if-block: ok
+# CHECK: neighbourhood_op_control_flow: ok
+
+def blur_repeatedly(image img) -> image {
+    for (i = 0 .. 3) {
+        image blurred = gaussian_blur(img, 4)
+        save_image(blurred, "loop_gaussian_blur_out.png")
+    }
+    print("gaussian_blur inside for-loop: ok\n")
+    return img
+}
+
+def sharpen_if_flagged(image img, float64 flag) -> image {
+    image result = img
+    if (flag == 1) {
+        image sharpened = sharpen(img, 40)
+        save_image(sharpened, "if_sharpen_out.png")
+    }
+    print("sharpen inside if-block: ok\n")
+    return result
+}
+
+def main() -> int64 {
+    image img = load_image("img/cat.png")
+    print("loaded image\n")
+
+    image after_loop = blur_repeatedly(img)
+    float64 flag = read_number("flag: ")
+    image after_if = sharpen_if_flagged(after_loop, flag)
+
+    print("neighbourhood_op_control_flow: ok\n")
+    return 0
+}
diff --git a/tests/lit/mlir/picceler_add_profiling_pass.mlir b/tests/lit/mlir/picceler_add_profiling_pass.mlir
index c0d1668..8150d10 100644
--- a/tests/lit/mlir/picceler_add_profiling_pass.mlir
+++ b/tests/lit/mlir/picceler_add_profiling_pass.mlir
@@ -46,3 +46,38 @@ func.func @GaussianBlur(%arg0 : !picceler.image) -> !picceler.image {
 // CHECK-NEXT: %[[RESULT:.*]] = "picceler.gaussian_blur"
 // CHECK-NEXT: call @piccelerTraceEnd(%[[NAME]], %[[IDX]], %[[TRACK]])
 // CHECK-NEXT: return %[[RESULT]]
+
+// -----
+
+// Blocking/non-compute ops (show_image, read_number, read_string, print) and kernel.const stay
+// unwrapped; load_image/save_image and the compute op in between still get traced.
+
+func.func @ExcludedOps(%arg0 : !picceler.image) {
+    %path = "picceler.string.const"() <{ value="cat.png" }> : () -> !picceler.string
+    %img = "picceler.load_image"(%path) : (!picceler.string) -> !picceler.image
+    %kernel = "picceler.kernel.const"() <{ values = dense<1.0> : tensor<3x3xf64> }> : () -> !picceler.kernel<3 x 3>
+    %blurred = "picceler.convolution"(%img, %kernel) : (!picceler.image, !picceler.kernel<3 x 3>) -> !picceler.image
+    "picceler.show_image"(%blurred) : (!picceler.image) -> ()
+    %prompt = "picceler.string.const"() <{ value="save?" }> : () -> !picceler.string
+    %answer = "picceler.read_string"(%prompt) : (!picceler.string) -> !picceler.string
+    %n = "picceler.read_number"(%prompt) : (!picceler.string) -> f64
+    %fmt = "picceler.string.const"() <{ value="{}\0A" }> : () -> !picceler.string
+    "picceler.print"(%fmt, %answer) : (!picceler.string, !picceler.string) -> ()
+    "picceler.save_image"(%blurred, %answer) : (!picceler.image, !picceler.string) -> ()
+    return
+}
+
+// A wrapped op gets a "picceler.string.const" holding its exact name; an excluded op doesn't, so
+// checking for that name const (rather than the call site, which only ever holds an SSA value) is
+// what actually distinguishes wrapped from unwrapped here.
+
+// CHECK-LABEL: func.func @ExcludedOps(
+// CHECK: "picceler.string.const"() <{value = "picceler.load_image"}>
+// CHECK-NOT: "picceler.string.const"() <{value = "picceler.kernel.const"}>
+// CHECK: "picceler.string.const"() <{value = "picceler.convolution"}>
+// CHECK-NOT: "picceler.string.const"() <{value = "picceler.show_image"}>
+// CHECK-NOT: "picceler.string.const"() <{value = "picceler.read_string"}>
+// CHECK-NOT: "picceler.string.const"() <{value = "picceler.read_number"}>
+// CHECK-NOT: "picceler.string.const"() <{value = "picceler.print"}>
+// CHECK: "picceler.string.const"() <{value = "picceler.save_image"}>
+// CHECK: "picceler.save_image"
diff --git a/tools/picceler-trace-to-json/README.md b/tools/picceler-trace-to-json/README.md
index 3d753b3..7214565 100644
--- a/tools/picceler-trace-to-json/README.md
+++ b/tools/picceler-trace-to-json/README.md
@@ -6,5 +6,8 @@ loadable directly in [Perfetto](https://ui.perfetto.dev) or [chrome://tracing](c
 [`docs/profiling.md`](../../docs/profiling.md) for the full format spec and workflow.
 
 ```bash
-python3 picceler-trace-to-json.py picceler_profiling_trace.bin -o trace.json
+python3 pictrace.py picceler_profiling_trace.bin -o trace.json
 ```
+
+Also importable — `bench/run_bench.py` reuses its `parse_trace`/`TraceFormatError` for the same
+`.bin` format rather than re-parsing it independently.
diff --git a/tools/picceler-trace-to-json/picceler-trace-to-json.py b/tools/picceler-trace-to-json/pictrace.py
similarity index 100%
rename from tools/picceler-trace-to-json/picceler-trace-to-json.py
rename to tools/picceler-trace-to-json/pictrace.py