Open-source alternatives to Halide

This project provides the core framework and system API layer for the Android operating system. It consists of the fundamental Java and C++ libraries that define system behavior and establish the interface contracts required for system applications and hardware abstraction. The project includes a runtime optimizer used to reduce startup time and improve execution speed by pre-compiling methods and configuring boot images. It also features a software quality toolchain that enforces code formatting, audits commit metadata, and manages API compatibility to ensure stable interface contracts acros

This project is a modular image manipulation framework and processing pipeline library designed for Ruby applications. It provides a programmable interface for executing complex image transformations, including resizing, cropping, rotating, and compositing, while managing file input and output parameters. The library distinguishes itself through a fluent, chainable interface that allows developers to construct sophisticated processing workflows by linking modular operations together. It functions as an image transformation engine that delegates heavy lifting to external native binary tools, e

Nim is a statically typed, compiled systems programming language designed for high performance and cross-platform development. It translates high-level source code into C, C++, or JavaScript, allowing developers to produce efficient native binaries or web-compatible scripts from a single codebase. The language emphasizes a clean, indentation-based syntax that simplifies code hierarchy while maintaining the power of a full-featured systems language. What distinguishes Nim is its robust metaprogramming framework, which allows developers to inspect, modify, and generate code structures during th

Mozjpeg is a high-performance C library for encoding, decoding, and transcoding JPEG images. It serves as a binary-compatible, drop-in replacement for standard JPEG libraries, maintaining existing function signatures to improve compression efficiency without requiring changes to application logic. The library functions as an image optimizer that reduces file sizes through lossless progressive encoding and coefficient optimization. It utilizes trellis-based quantization and SIMD-accelerated processing to optimize the trade-off between visual quality and file size. Its broader capabilities inc

This library provides a collection of image processing extensions for the native image class on iOS. It functions as a toolkit for applying artistic filters, color adjustments, and sharpening algorithms directly to image objects within mobile applications. The framework distinguishes itself by integrating with the native image pipeline to execute pixel-level operations on the graphics processor. It utilizes a declarative approach to chain modular processing units, allowing for the construction of complex visual effects while maintaining non-destructive transformations through the generation o

Scala Native is an ahead-of-time compiler that transforms Scala source code into standalone native binaries for direct execution on hardware. It provides a native binary toolchain designed to eliminate virtual machine warm-up times and ensure instant startup by compiling code into optimized executables. The project features a C interoperability interface and foreign function interface that map native C headers to language objects, allowing for the direct execution of external libraries. It includes a low-level memory manager that supports direct pointer manipulation and the use of structs for

This is a Glide image transformation library for Android that provides a collection of image processing filters and shapes. It functions as a suite of hardware-accelerated tools for image cropping, artistic filtering, and transformation pipeline management. The project distinguishes itself through an image filter pipeline that allows for sequential transformation chaining, enabling multiple visual effects and color modifications to be applied in a single pass. It utilizes GPU acceleration to implement artistic effects such as pixelation, sketching, and blur. The library covers a broad range

Moshi is a JSON serialization library and parser for Kotlin and Java. It functions as a reflectionless JSON encoder that converts typed objects to JSON strings and parses JSON data back into language objects. The library distinguishes itself through compile-time adapter generation, which removes the performance overhead associated with runtime reflection. It also provides a polymorphic JSON mapper that uses type identifiers to resolve and instantiate specific subclasses of a common base type. The framework supports custom adapter definitions for specialized type conversion, including nullabi

Typia is a compile-time code generator that transforms TypeScript type annotations into runtime validation, serialization, and schema functions without requiring decorators or separate schema files. It generates optimized validation and serialization code during TypeScript compilation, producing dedicated functions for each type that eliminate runtime schema objects for faster execution. The project extends this core capability into several integrated areas. It generates fully typed client SDKs from NestJS controller source code, keeping server and client types synchronized automatically. It

Surge is a Swift library for high-performance numerical analysis, linear algebra, digital signal processing, and accelerated image manipulation. It utilizes the Accelerate framework to provide hardware-accelerated tools for matrix mathematics and signal processing. The library provides specialized capabilities for digital signal processing, including convolution, signal similarity analysis through cross-correlation, and domain transformations using fast Fourier transforms. It also includes a suite of tools for the rapid transformation and analysis of pixel buffers and image data. Beyond sign

Templ is a type-safe HTML templating engine and UI framework for Go. It provides a system for building reusable HTML components that compile into Go code for server-side rendering, ensuring type safety and compile-time validation of data and logic. The project features a dedicated language server that provides autocomplete and syntax validation for template files within supported code editors. It employs compile-time code generation to transform a custom template language into Go source code, enabling the creation of modular HTML fragments and logic blocks. The framework includes automated s

libjpeg-turbo is a high-performance image codec library used for encoding and decoding JPEG images. It serves as a compression library for converting raw image data into JPEG format and as a utility for transforming pixel data between different color models and buffer formats. The library utilizes SIMD instructions to accelerate the encoding and decoding process. It includes a lossless transformer that allows for cropping and resizing of JPEG data without re-encoding pixels to preserve image quality. Its broader capabilities cover image scaling during the compression process and high-perform

Ent is a statically typed entity framework for Go that models database structures as a graph of nodes and edges. It functions as a code generation engine that transforms schema definitions into type-safe database clients, query builders, and migration scripts. By representing data as interconnected entities, the framework enables intuitive traversal of complex relationships and ensures that database interactions remain consistent with the application model at compile time. The framework distinguishes itself through its graph-based approach to data modeling and its reliance on compile-time cod

Ajv is a high-performance data validation framework that compiles JSON schemas into optimized, standalone JavaScript functions. By transforming declarative schema definitions into executable code, it eliminates runtime interpretation overhead and provides a secure, efficient way to enforce data integrity across both browser and server environments. The library distinguishes itself through its focus on performance and type safety. It employs advanced compilation techniques, including abstract syntax tree optimization and function caching, to ensure rapid validation. Beyond standard checks, it

This project is a framework for the efficient serialization and deserialization of data structures. It provides a unified, macro-based interface that automates the conversion of complex internal objects into standardized formats and reconstructs them from raw input streams or buffers. By leveraging compile-time code generation, the library minimizes manual implementation overhead while ensuring consistent logic across diverse data types. The framework distinguishes itself through a format-agnostic data model and a visitor-based parsing architecture that decouples data structures from specific

Relay is a GraphQL client framework and state manager used for building data-driven applications. It functions as a declarative data fetching layer and a GraphQL compiler that transforms declarations into optimized runtime code with automatic type generation. The framework distinguishes itself through a build-time compilation process that generates optimized queries and a data masking system that prevents components from accessing undeclared data. It employs a normalized client-side cache to maintain consistency across entities and an optimistic update mechanism to provide immediate interface

CarrierWave is a Ruby file upload library used to manage the uploading, storing, and retrieval of files within web frameworks such as Rails and Sinatra. It functions as an Active Record file manager that associates uploaded assets with database records. The project includes an image processing pipeline for generating thumbnails and derivative versions of uploaded images. It also features a file validation engine to restrict uploads based on allowlists or denylists of extensions and content types, and provides cloud storage integration to manage assets on remote providers. The library covers

FEX is an emulator that executes 32-bit and 64-bit x86 binaries on ARM64 hardware. It functions as a binary translation framework that converts guest machine code into host instructions using a JIT compilation engine and a persistent code cache. The project features a Vulkan graphics wrapper that translates OpenGL and Vulkan API calls to native host drivers, enabling cross-architecture graphics rendering. It includes a dedicated root filesystem manager for downloading, mounting, and switching between compressed filesystem images required for guest application environments. The system provide

gm is a JavaScript image processing library and Node.js manipulation tool that serves as a programmatic wrapper for the GraphicsMagick engine. It translates JavaScript method calls into shell commands to automate the resizing, cropping, and transformation of images. The library provides an interface to execute specific GraphicsMagick operations while allowing raw command passthrough for custom arguments or engine features not covered by the standard API. Its capabilities cover geometric manipulation, color and tone adjustment, and image quality optimization. It includes tools for image compo

Sonic is a high-performance Go JSON serialization library that provides tools for encoding and decoding native data structures. It functions as a JIT-accelerated encoder, a JSON AST parser, a stream processor, and a lazy decoder. The project utilizes just-in-time machine code generation to optimize the encoding of large data schemas and employs a JIT assembler to maximize serialization and deserialization speeds. It features a precompiled schema warmup process to prevent latency spikes during initial execution and leverages SIMD hardware instructions for accelerated parsing. The library cove

Wasmtime is a WebAssembly runtime and sandboxed bytecode executor designed to run WebAssembly bytecode on a host system. It functions as an embeddable engine that integrates into applications through native APIs and language-specific bindings, as well as a standalone execution environment accessible via a command line interface. It is a WASI compatible runtime, implementing the WebAssembly System Interface to provide portable access to system resources. The engine utilizes a JIT compilation model to translate intermediate representation into optimized machine code for various CPU architecture

Porffor is an ahead-of-time compiler that converts JavaScript and TypeScript source code into native machine code or C binaries. It functions as a native binary generator and transpiler, producing standalone executable files that do not require a runtime or virtual machine. The project translates source code into C language files and WebAssembly binary formats. It includes a direct-to-binary pipeline for TypeScript, allowing for the generation of target executables without a separate transpilation step to JavaScript. The toolset also includes an interactive read-eval-print loop for real-time

The Swift OpenAPI Generator is a build-time tool that produces type-safe Swift client and server code directly from OpenAPI specification documents. By integrating with build systems through native plugins, it automates the creation of strongly-typed interfaces and protocol stubs that map network operations to native methods, ensuring that application code remains strictly consistent with defined data schemas. The project distinguishes itself through a protocol-oriented architecture that decouples business logic from specific transport implementations. It utilizes a pluggable transport layer

Apollo Kotlin is a strongly-typed GraphQL client and code generation library designed for Kotlin and JVM applications. It functions as a comprehensive development tool that transforms GraphQL schema definitions and query documents into type-safe models during the build process, ensuring that data access errors are identified at compile time rather than at runtime. The project distinguishes itself through its multiplatform runtime abstraction, which allows developers to share data fetching and caching logic across Android, iOS, and desktop environments. It provides a normalized local caching s

AsmJit is a runtime machine code generator and JIT compiler backend that translates high-level definitions into executable processor instructions. It provides a unified instruction emission API and an executable memory manager to allocate and protect virtual memory pages across multiple CPU architectures. The library functions as an assembly engine for x86 and ARM, supporting cross-platform assembly generation through a unified backend. It enables the creation of optimized machine code for different CPUs while maintaining a single codebase. The project covers low-level system abstractions in

chaiNNer is a GPU-accelerated AI image upscaling application that uses a visual node-based interface for constructing image processing pipelines. At its core, it provides a node-based visual programming environment where users connect processing nodes in a directed acyclic graph, with a graph execution scheduler that traverses the pipeline in topological order. The application includes an iterator-based batch processing system that automatically applies the same pipeline to multiple files, and a model format conversion pipeline that transforms neural network models between PyTorch, ONNX, and N

Floorp is a privacy-focused web browser built on the Firefox engine. It functions as a customizable browser shell that allows users to modify the layout and functional behavior of the interface. The project emphasizes a customizable browser interface, enabling the organization and arrangement of toolbars, sidebars, and menus to create a personalized workspace. It integrates privacy-focused browsing and secure online navigation to minimize data tracking and protect user identity from third-party observers. Additional capabilities include eco-friendly internet usage designed to reduce the envi