[halidoscope] Add pip packaging via maturin

.github/workflows/pip-halidoscope.yml

@@ -0,0 +1,109 @@
+name: Build Halidoscope wheels
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - 'tools/halidoscope/**'
+      - '.github/workflows/pip-halidoscope.yml'
+  push:
+    branches: [ main ]
+    paths:
+      - 'tools/halidoscope/**'
+      - '.github/workflows/pip-halidoscope.yml'
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.event.pull_request.head.label || github.head_ref || github.ref }}'
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+# Halidoscope is a companion CLI/GUI packaged independently of Halide's own
+# Python wheels (halide, halide-bin, halide-runtime): it doesn't depend on
+# them, and this workflow doesn't participate in pip.yml's publish job. Its
+# version is kept in sync with Halide's release version via tbump (see
+# tool.tbump.file entries for tools/halidoscope/src-tauri/Cargo.toml et al.
+# in the top-level pyproject.toml), not via a per-commit dynamic version.
+jobs:
+  build:
+    name: Build wheel for ${{ matrix.platform_tag }}
+
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform_tag: manylinux_x86_64
+          - os: windows-latest
+            platform_tag: win_amd64
+          - os: macos-15-intel
+            platform_tag: macosx_x86_64
+          - os: macos-15
+            platform_tag: macosx_arm64
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install Tauri's Linux system dependencies
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            libwebkit2gtk-4.1-dev \
+            libayatana-appindicator3-dev \
+            librsvg2-dev \
+            patchelf \
+            build-essential \
+            libxdo-dev \
+            libssl-dev \
+            libsoup-3.0-dev \
+            xvfb
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 11
+          package_json_file: tools/halidoscope/package.json
+
+      - uses: actions/setup-node@v5
+        with:
+          node-version: 22
+          cache: pnpm
+          cache-dependency-path: tools/halidoscope/pnpm-lock.yaml
+
+      - uses: astral-sh/setup-uv@v7
+
+      - name: Build frontend
+        working-directory: tools/halidoscope
+        run: |
+          pnpm install --frozen-lockfile
+          pnpm build
+
+      - name: Build wheel
+        working-directory: tools/halidoscope
+        run: uvx maturin build --release --out wheelhouse
+
+      - name: Smoke-test wheel
+        working-directory: tools/halidoscope
+        shell: bash
+        run: |
+          uv venv .smoke-test-venv
+          uv pip install --python .smoke-test-venv --no-index --find-links wheelhouse halidoscope
+          if [[ "${{ runner.os }}" == "Windows" ]]; then
+            ./.smoke-test-venv/Scripts/halidoscope --version
+          elif [[ "${{ runner.os }}" == "Linux" ]]; then
+            # tauri::Builder::run() initializes tao's GTK-backed event loop
+            # before dispatching to any CLI subcommand, so even `--version`
+            # needs a display on Linux.
+            xvfb-run -a ./.smoke-test-venv/bin/halidoscope --version
+          else
+            ./.smoke-test-venv/bin/halidoscope --version
+          fi
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: wheels-halidoscope-${{ matrix.platform_tag }}
+          path: tools/halidoscope/wheelhouse/*.whl

.gitignore

@@ -19,10 +19,18 @@
 ################################################################################
 ## Halide-specific exclusions
 
-# Images only allowed in apps and directories named "images"
+# Images only allowed in apps, directories named "images", and Halidoscope's
+# icon set
 *.png
 !apps/**/*.png
 !**/images/**/*.png
+!tools/halidoscope/src-tauri/icons/*.png
+
+# Halidoscope is desktop-only; `tauri icon` also emits mobile (Android/iOS)
+# assets we don't want to commit.
+tools/halidoscope/src-tauri/icons/android/
+tools/halidoscope/src-tauri/icons/ios/
+
 
 # Pre-trained weights only allowed in autoscheduler directories
 *.weights

pyproject.toml

@@ -142,6 +142,18 @@ src = "vcpkg.json"
 [[tool.tbump.file]]
 src = "apps/vcpkg.json"
 
+[[tool.tbump.file]]
+src = "tools/halidoscope/src-tauri/Cargo.toml"
+search = 'version = "{current_version}"'
+
+[[tool.tbump.file]]
+src = "tools/halidoscope/src-tauri/tauri.conf.json"
+search = '"version": "{current_version}"'
+
+[[tool.tbump.file]]
+src = "tools/halidoscope/package.json"
+search = '"version": "{current_version}"'
+
 [[tool.tbump.file]]
 src = "src/runtime/HalideRuntime.h"
 version_template = "{major}"

python_bindings/halide/src/halide_/PyPipeline.cpp

@@ -123,6 +123,17 @@ void define_pipeline(py::module &m) {
             return "<halide.AutoschedulerParams>";
         });
 
+    py::class_<HalidoscopeOptions>(m, "HalidoscopeOptions")
+        .def(py::init<>())
+        .def_readwrite("halidoscope_path", &HalidoscopeOptions::halidoscope_path)
+        .def_readwrite("halidoscope_output_dir", &HalidoscopeOptions::halidoscope_output_dir)
+        .def_readwrite("halidoscope_profile_runs", &HalidoscopeOptions::halidoscope_profile_runs)
+        .def("__repr__", [](const HalidoscopeOptions &o) -> std::string {
+            return "<halide.HalidoscopeOptions halidoscope_path='" + o.halidoscope_path.value_or("halidoscope") +
+                   "' halidoscope_output_dir='" + o.halidoscope_output_dir.value_or("") +
+                   "' halidoscope_profile_runs=" + std::to_string(o.halidoscope_profile_runs.value_or(1)) + ">";
+        });
+
     auto pipeline_class =
         py::class_<Pipeline>(m, "Pipeline")
             .def(py::init<>())
@@ -283,6 +294,35 @@ void define_pipeline(py::module &m) {
                  },
                  py::arg("dst"), py::arg("target") = Target())
 
+            // Development/debugging aid: see Pipeline::halidoscope() in Pipeline.h.
+            // Blocks until the Halidoscope window is closed, so the GIL must be
+            // released for the duration of the call, same as realize() above.
+            .def("halidoscope",  //
+                 [](Pipeline &p, Buffer<> buffer, const HalidoscopeOptions &options, const Target &target) -> void {
+                     py::gil_scoped_release release;
+                     p.halidoscope(Realization(std::move(buffer)), options, target);  //
+                 },
+                 py::arg("dst"), py::arg("options") = HalidoscopeOptions(), py::arg("target") = Target())
+
+            // See the comment on the corresponding realize() overload above: this
+            // overload must be declared before the list-of-sizes one, so that an
+            // empty list [] is resolved as list-of-sizes (a 0-dimensional Buffer)
+            // rather than as an ambiguous empty list-of-buffers.
+            .def("halidoscope",  //
+                 [](Pipeline &p, std::vector<int32_t> sizes, const HalidoscopeOptions &options, const Target &target) -> void {
+                     py::gil_scoped_release release;
+                     p.halidoscope(std::move(sizes), options, target);  //
+                 },
+                 py::arg("sizes") = std::vector<int32_t>{}, py::arg("options") = HalidoscopeOptions(), py::arg("target") = Target())
+
+            // This will actually allow a list-of-buffers as well as a tuple-of-buffers, but that's OK.
+            .def("halidoscope",  //
+                 [](Pipeline &p, std::vector<Buffer<>> buffers, const HalidoscopeOptions &options, const Target &target) -> void {
+                     py::gil_scoped_release release;
+                     p.halidoscope(Realization(std::move(buffers)), options, target);  //
+                 },
+                 py::arg("dst"), py::arg("options") = HalidoscopeOptions(), py::arg("target") = Target())
+
             .def("infer_input_bounds",  //
                  [](Pipeline &p, const py::object &dst, const Target &target) -> void {
                      const Target t = to_jit_target(target);