# halide/halide

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/halide-halide).**

6,572 stars · 1,093 forks · C++ · other

## Links

- GitHub: https://github.com/halide/Halide
- Homepage: https://halide-lang.org
- awesome-repositories: https://awesome-repositories.com/repository/halide-halide.md

## Topics

`compiler` `dsl` `gpu` `halide` `hexagon` `image-processing` `performance`

## Tags

### Graphics & Multimedia

- [High-Performance Image](https://awesome-repositories.com/f/graphics-multimedia/media-processing-analysis/media-manipulation/image-processing/libraries/high-performance-image.md) — Provides a C++ DSL for writing image processing algorithms that separate algorithm from schedule.
- [High-Performance Image Pipelines](https://awesome-repositories.com/f/graphics-multimedia/image-editing-processing/image-processing/high-performance-image-pipelines.md) — Expresses image processing algorithms in a concise C++ DSL and compiles them to efficient machine code. ([source](https://halide-lang.org/cvpr2015.html))
- [Learned Cost Model Schedulers](https://awesome-repositories.com/f/graphics-multimedia/image-editing-processing/image-processing/high-performance-image-pipelines/learned-cost-model-schedulers.md) — Finds high-performance schedules using a learned cost model and beam search without manual tuning. ([source](https://halide-lang.org/papers/autoscheduler2019.html))
- [Image Processing Pipelines](https://awesome-repositories.com/f/graphics-multimedia/image-processing-pipelines.md) — Declares image processing pipelines as directed acyclic graphs of functions, variables, and expressions. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [In-Memory Image Buffers](https://awesome-repositories.com/f/graphics-multimedia/in-memory-image-buffers.md) — Stores and manipulates multi-dimensional pixel data with typed containers integrated with pipelines. ([source](https://halide-lang.org/docs))
- [Arbitrary Domain Evaluators](https://awesome-repositories.com/f/graphics-multimedia/arbitrary-domain-evaluators.md) — Evaluates pipelines over non-rectangular or user-defined sets of coordinates. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Domain Scatter Operations](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/post-processing-effects/atmospheric-fog/atmospheric-scattering/domain-scatter-operations.md) — Applies computations repeatedly over multi-dimensional ranges, supporting reductions and scattering. ([source](https://halide-lang.org/docs))

### Artificial Intelligence & ML

- [Schedule Optimization via Learned Cost Models](https://awesome-repositories.com/f/artificial-intelligence-ml/batch-size-tuning/automatic-batch-size-optimization/schedule-optimization-via-learned-cost-models.md) — Ships an automatic scheduler that uses a learned cost model and beam search to optimize pipeline performance.
- [Pipeline](https://awesome-repositories.com/f/artificial-intelligence-ml/gpu-acceleration/pipeline.md) — Offloads pipeline stages to GPU compute APIs such as CUDA, Metal, or DirectX 12.
- [Heterogeneous Hardware Pipeline Compilation](https://awesome-repositories.com/f/artificial-intelligence-ml/local-model-orchestrators/heterogeneous-orchestrators/heterogeneous-hardware-pipeline-compilation.md) — Compiles pipelines to run on CPUs, GPUs, or accelerators without algorithm changes. ([source](https://halide-lang.org/tutorials))
- [Multi-Backend Compilers](https://awesome-repositories.com/f/artificial-intelligence-ml/machine-learning/frameworks/model-construction/multi-backend-abstractions/multi-backend-compilers.md) — Compiles the same pipeline to run on CPUs and GPUs without changing the algorithm. ([source](https://halide-lang.org))
- [Image Pipeline Auto-Schedulers](https://awesome-repositories.com/f/artificial-intelligence-ml/model-operation-schedulers/lazy-scheduling-pipelines/image-pipeline-auto-schedulers.md) — Uses built-in heuristics to automatically choose performant schedules for image processing pipelines. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Image Processing Pipeline Schedulers](https://awesome-repositories.com/f/artificial-intelligence-ml/model-operation-schedulers/lazy-scheduling-pipelines/image-processing-pipeline-schedulers.md) — Provides explicit scheduling directives to control loop mapping, parallelism, and memory layout for image processing pipelines. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Pipeline Schedulers](https://awesome-repositories.com/f/artificial-intelligence-ml/pipeline-schedulers.md) — Uses a learned cost model and beam search to automatically find high-performance schedules.

### Data & Databases

- [Non-Planar Layout Handlers](https://awesome-repositories.com/f/data-databases/memory-layouts/non-planar-layout-handlers.md) — Provides native handling of interleaved, planar, and custom memory layouts without data copying. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))

### Development Tools & Productivity

- [Cross-Architecture Binary Compilation](https://awesome-repositories.com/f/development-tools-productivity/cross-architecture-binary-compilation.md) — Produces code for CPU or GPU architectures different from the host machine. ([source](https://halide-lang.org/tutorials))
- [Cross-Compilation Tooling](https://awesome-repositories.com/f/development-tools-productivity/cross-compilation-tooling.md) — Generates machine code for CPU or GPU architectures different from the host build system. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Pipeline Static Compilers](https://awesome-repositories.com/f/development-tools-productivity/static-binaries/static-binary-compilers/pipeline-static-compilers.md) — Generates standalone object files and headers from pipelines for deployment in larger applications. ([source](https://halide-lang.org/docs))
- [Pipeline Print-Based Debugging](https://awesome-repositories.com/f/development-tools-productivity/print-based-debugging-workflows/pipeline-print-based-debugging.md) — Inserts tracing and print statements into pipelines to inspect intermediate values during execution. ([source](https://halide-lang.org/tutorials))

### DevOps & Infrastructure

- [Cross-Architecture Pipeline Code Generation](https://awesome-repositories.com/f/devops-infrastructure/cross-platform-deployment-targets/cross-platform-execution/cross-architecture-pipeline-code-generation.md) — Compiles the same pipeline to run on different CPU and GPU architectures without algorithm changes.
- [Image Processing Stage Chains](https://awesome-repositories.com/f/devops-infrastructure/dockerfile-utilities/dockerfile-inheritance/multi-stage-build-pipelines/image-processing-stage-chains.md) — Chains multiple image processing functions into sequential stages where each output feeds the next. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Image Processing](https://awesome-repositories.com/f/devops-infrastructure/task-schedulers/stage-schedulers/image-processing.md) — Controls computation order, parallelism, vectorization, and memory layout of image processing pipeline stages. ([source](https://halide-lang.org))

### Hardware & IoT

- [Pipeline GPU Execution](https://awesome-repositories.com/f/hardware-iot/integration-performance/gpu-performance/gpu-computations/pipeline-gpu-execution.md) — Offloads pipeline stages to GPU compute APIs such as CUDA, Metal, or DirectX 12. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))

### Operating Systems & Systems Programming

- [Pipeline GPU Compilers](https://awesome-repositories.com/f/operating-systems-systems-programming/hardware-interfacing-drivers/hardware-acceleration/gpu-acceleration/gpu-accelerated-compilers/pipeline-gpu-compilers.md) — Compiles and runs pipeline stages on a GPU using the appropriate compute API. ([source](https://halide-lang.org/tutorials))

### Programming Languages & Runtimes

- [Ahead-Of-Time Compilation](https://awesome-repositories.com/f/programming-languages-runtimes/ahead-of-time-compilation.md) — Generates standalone object files or shared libraries from pipelines for use in external programs. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Ahead-Of-Time Compilers](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-toolchains/execution-mode-engines/ahead-of-time-kernel-compilation/ahead-of-time-compilers.md) — Compiles pipelines into standalone object files or static libraries for deployment.
- [Image Processing DSLs](https://awesome-repositories.com/f/programming-languages-runtimes/domain-specific-languages/image-processing-dsls.md) — Provides an embedded C++ DSL for defining image processing pipelines as directed acyclic graphs.
- [JIT Compilation Engines](https://awesome-repositories.com/f/programming-languages-runtimes/jit-compilation-engines.md) — Compiles pipelines into machine code at runtime for fast iteration and debugging.
- [Image Processing Loop Transformations](https://awesome-repositories.com/f/programming-languages-runtimes/looping-constructs/loop-unrolling-transformations/image-processing-loop-transformations.md) — Applies SIMD vectorization, multi-core parallelization, loop unrolling, and tiling to accelerate image processing pipelines. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Cross-Architecture Code Generators](https://awesome-repositories.com/f/programming-languages-runtimes/machine-code-generation/cross-architecture-code-generators.md) — Compiles the same pipeline to run on CPUs and GPUs without algorithm changes.
- [Multi-Stage Image Pipeline Compilation](https://awesome-repositories.com/f/programming-languages-runtimes/multi-pass-compiler-pipelines/multi-stage-image-pipeline-compilation.md) — Compiles multi-stage image processing pipelines as directed acyclic graphs into efficient machine code.
- [Image Pipeline](https://awesome-repositories.com/f/programming-languages-runtimes/source-code-compilers/multi-target-compilers/image-pipeline.md) — Compiles image processing pipelines to optimized code for x86, ARM, CUDA, OpenCL, and Metal. ([source](https://halide-lang.org/docs))
- [Domain-Specific Reductions](https://awesome-repositories.com/f/programming-languages-runtimes/array-reductions/domain-specific-reductions.md) — Creates reduction operations that update function values over arbitrary or non-rectangular domains. ([source](https://halide-lang.org/tutorials))
- [Iterative Update Reductions](https://awesome-repositories.com/f/programming-languages-runtimes/array-reductions/iterative-update-reductions.md) — Expresses iterative or reduction operations that modify function values over multiple passes. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Non-Rectangular Domain Reductions](https://awesome-repositories.com/f/programming-languages-runtimes/array-reductions/non-rectangular-domain-reductions.md) — Applies reduction operations over domains defined by arbitrary predicates, not just rectangles. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Tuple Output Compilation](https://awesome-repositories.com/f/programming-languages-runtimes/bytecode-compilation/single-pass-compilation/tuple-output-compilation.md) — Compiles functions that return multiple distinct outputs in a single pass without intermediate storage.
- [JIT Pipeline Compilation](https://awesome-repositories.com/f/programming-languages-runtimes/jit-compilation-engines/jit-pipeline-compilation.md) — Provides JIT compilation of pipelines for rapid prototyping and testing from C++. ([source](https://halide-lang.org))
- [Multiple Return Values](https://awesome-repositories.com/f/programming-languages-runtimes/multiple-return-values.md) — Defines functions that produce tuples of several distinct outputs in a single pass. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Multi-Domain Reductions](https://awesome-repositories.com/f/programming-languages-runtimes/sequence-reduction-operations/multi-domain-reductions.md) — Defines iterative or reduction operations over arbitrary or non-rectangular domains.

### Scientific & Mathematical Computing

- [Image Processing Performance Schedulers](https://awesome-repositories.com/f/scientific-mathematical-computing/high-performance-execution-environments/high-performance-and-parallel-computing/high-performance-computing/high-performance-task-schedulers/image-processing-performance-schedulers.md) — Applies vectorization, parallelization, tiling, and unrolling strategies to optimize image processing pipeline execution. ([source](https://halide-lang.org/tutorials))
- [Scheduling Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/high-performance-execution-environments/scientific-computing-platforms/scientific-computing/scheduling-algorithms.md) — Decouples computation from execution to enable independent optimization of memory, parallelism, and vectorization.
- [Associative Reduction Factoring](https://awesome-repositories.com/f/scientific-mathematical-computing/arithmetic-reductions/associative-reduction-factoring.md) — Splits associative reductions into independent partial results that can be computed in parallel and combined. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))

### Software Engineering & Architecture

- [Compile-Time Code Generation](https://awesome-repositories.com/f/software-engineering-architecture/compile-time-code-generation.md) — Generates optimized machine code for CPUs and GPUs at compile time from a high-level DSL description.
- [Image Processing](https://awesome-repositories.com/f/software-engineering-architecture/execution-control/concurrency-controlled-schedulers/execution-schedulers/image-processing.md) — Controls how image processing pipeline stages are vectorized, parallelized, unrolled, or tiled for target optimization. ([source](https://halide-lang.org/tutorials))
- [Algorithm-Schedule Decoupling](https://awesome-repositories.com/f/software-engineering-architecture/separation-of-concerns/algorithm-schedule-decoupling.md) — Provides the core architectural principle of separating algorithm from schedule for independent optimization.
- [Algorithm-Schedule Separation](https://awesome-repositories.com/f/software-engineering-architecture/separation-of-concerns/algorithm-schedule-separation.md) — Separates algorithm logic from execution scheduling for independent optimization of each. ([source](https://halide-lang.org/cvpr2015.html))
- [Function Duplicators](https://awesome-repositories.com/f/software-engineering-architecture/function-duplicators.md) — Duplicates function definitions so the two copies can be scheduled independently. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Higher-Order Function Wrapping](https://awesome-repositories.com/f/software-engineering-architecture/higher-order-function-wrapping.md) — Creates wrapper functions that transform or filter outputs of existing functions without modifying them. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Pipeline Generators](https://awesome-repositories.com/f/software-engineering-architecture/pipeline-generators.md) — Wraps pipelines into reusable, parameterized generators for external compilation and invocation. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Pipeline Parameterization](https://awesome-repositories.com/f/software-engineering-architecture/transformation-pipelines/input-processing-pipelines/pipeline-parameterization.md) — Declares runtime-configurable scalar and image inputs that can be changed without recompilation. ([source](https://halide-lang.org/docs))

### Web Development

- [Runtime-Measured Schedule Optimizers](https://awesome-repositories.com/f/web-development/performance-optimizations/computational-parallelization/parallel-gpu-schedulers/automated-schedulers/runtime-measured-schedule-optimizers.md) — Refines schedules by measuring actual runtime on target hardware and iterating toward faster configurations. ([source](https://halide-lang.org/papers/autoscheduler2019.html))

### Part of an Awesome List

- [Pipeline Data Type Control](https://awesome-repositories.com/f/awesome-lists/devtools/data-types-and-utilities/pipeline-data-type-control.md) — Controls data types and bit widths for variables, expressions, and buffers in pipelines. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Pipeline Debugging and Profiling](https://awesome-repositories.com/f/awesome-lists/devtools/debugging-and-profiling-tools/pipeline-debugging-and-profiling.md) — Inspects generated code, traces intermediate values, and prints debug output during pipeline execution. ([source](https://halide-lang.org/tutorials))
- [Pipeline Tracing](https://awesome-repositories.com/f/awesome-lists/devtools/debugging-and-tracing/pipeline-tracing.md) — Traces intermediate values and prints variable contents to inspect pipeline behavior step by step. ([source](https://halide-lang.org/tutorials/tutorial_introduction.html))
- [Pipeline Value Tracing](https://awesome-repositories.com/f/awesome-lists/devtools/debugging-and-tracing/pipeline-value-tracing.md) — Inserts trace statements and print calls into pipelines to inspect intermediate values during execution. ([source](https://halide-lang.org/tutorials))
- [C Geospatial Libraries](https://awesome-repositories.com/f/awesome-lists/devtools/c-geospatial-libraries.md) — Language for high-performance image processing code.