Projects sharing features with Ispc

The Android NDK samples provide a comprehensive collection of code examples demonstrating how to integrate C and C++ native code into Android applications. This repository serves as a practical guide for developers utilizing the Android Native Development Kit to implement performance-critical application components that require direct hardware access and low-level system interaction. The project highlights the use of the Java Native Interface to bridge managed code with native modules, enabling cross-language function calls and efficient data exchange. It demonstrates how to manage native act

Rust-GPU is a compiler and toolchain that translates Rust source code into SPIR-V bytecode for execution on graphics and compute hardware. It provides a development environment for writing parallel compute kernels and graphics shaders using a custom LLVM backend that maps high-level language constructs to GPU-compatible memory layouts and instructions. The project enables cross-platform shader development, allowing the same Rust code to run across different GPU hardware and graphics APIs via the SPIR-V intermediate representation. It specifically supports the creation of general-purpose compu

This project is a technical curriculum and set of educational resources focused on parallel programming, high-performance computing, and systems programming. It provides a structured course covering the implementation of parallel algorithms and multithreading techniques for processing large datasets. The project includes a systems programming guide for modern language features, a framework for lock-free concurrency patterns, and a manual for optimizing CPU and GPU performance through assembly analysis and cache management. The material covers hardware performance tuning, the implementation o

xtensor is a C++ multidimensional array library for numerical computing that provides N-dimensional containers with an interface mirroring the NumPy API. It utilizes a lazy evaluation expression engine to defer numerical computations until assignment, which minimizes memory allocations and intermediate copies. The library features a foreign memory array adaptor that allows it to wrap external buffers, such as NumPy arrays, to perform numerical operations in-place without duplicating data. It further optimizes performance through lazy broadcasting and a system that manages the lifetime of temp

Zig is a low-level systems programming language designed for writing high-performance software that interacts directly with hardware. It focuses on the transformation of source code into machine binaries for the execution of low-level operations. The project is distinguished by its native support for cross-compilation, allowing binaries for various operating systems and CPU architectures to be built from a single host. It provides direct interoperability with the C language, enabling the import of headers and function calls without a foreign function interface. The language utilizes manual m

Zen-C is a multi-target systems language and source-to-source compiler that translates high-level logic into human-readable GNU C or C11 code. It functions as a JIT-enabled programming language with an in-process compiler for real-time interactive code evaluation and testing. The project serves as a CUDA GPU kernel generator, mapping specialized syntax to CUDA C++ using device attributes to target graphics hardware. It acts as an interoperability layer capable of emitting compatible code for C++, Objective-C, and Lisp to bridge native system frameworks and libraries. The language includes an

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

Swift is a general purpose, compiled systems programming language designed for building high-performance software. It is a strongly typed language that focuses on memory safety and type safety to prevent runtime errors. The language is designed for native code integration, allowing it to interoperate with C and Objective-C libraries to leverage existing system functions and high-performance APIs. The project covers broad capabilities in type-safe application development and cross-platform toolchain engineering. It includes infrastructure for automated language validation, compiler performanc

Accelerate is a framework for high-performance array computing that provides a domain-specific language for expressing complex mathematical and parallel computations. By utilizing a declarative programming interface, it allows users to define high-level array transformations that are automatically translated into optimized machine code for diverse hardware architectures. The system distinguishes itself through a modular architecture that decouples high-level array operations from hardware-specific instructions. It employs just-in-time compilation and kernel fusion to transform programs into e

Codon is an LLVM-based Python compiler and statically typed implementation that translates source code into optimized machine instructions. It functions as a high-performance numerical backend and a GPU computing framework designed to remove runtime overhead. The project implements a compiled alternative to NumPy, translating array logic directly into machine code. It differentiates itself by generating specialized hardware kernels for graphics processors and utilizing static type inference to enable aggressive machine-code optimization. The system provides capabilities for parallel workload

Blade-build is a multi-language build system and software orchestrator designed to automate the compilation, linking, and testing of complex codebases. It functions as an incremental build engine that models project structures as directed acyclic graphs, ensuring that only affected modules are recompiled when source code or header files change. By utilizing declarative build specifications, the system provides a unified approach to managing dependencies and toolchains across diverse programming environments. The system distinguishes itself through a focus on hermetic build environments and re

OpenBLAS is a high-performance implementation of the Basic Linear Algebra Subprograms standard designed for numerical computing and matrix operations. It serves as a hardware-accelerated numerical library and optimized math kernel library, providing a computational engine for large-scale matrix multiplication and vector operations. The library distinguishes itself through the use of hand-tuned assembly kernels and SIMD instruction mapping, such as AVX and SVE, to maximize floating-point performance on specific CPU architectures. It features a multi-threaded framework that manages parallel exe

The Dart SDK is a comprehensive development kit for building cross-platform applications using a multi-paradigm programming language. It provides a unified toolchain that supports both just-in-time compilation for rapid development and ahead-of-time compilation for high-performance native machine code. The platform is built on a sound static type system and an isolate-based concurrency framework, which executes independent tasks in separate memory heaps to achieve parallelism without shared state contention. The SDK distinguishes itself through a versatile compilation pipeline that transforms

This project serves as a comprehensive educational resource for learning parallel programming and high-performance computing using graphics processing units. It provides technical guidance on the fundamental paradigms required to offload computationally intensive tasks from a host system to specialized hardware accelerators. The materials cover the core methodologies for managing data-parallel operations, including the orchestration of memory between host and device spaces and the organization of threads into structured grids and blocks. It details the execution models necessary to distribute

JerryScript is a lightweight, ECMAScript-compliant JavaScript engine and bytecode compiler designed for resource-constrained devices. It serves as an embedded interpreter and IoT scripting runtime, enabling the execution of JavaScript code within native C applications on hardware with limited memory. The project differentiates itself through a focus on low-memory runtime management, utilizing bytecode precompilation and pre-compiled state snapshots to reduce startup time and memory overhead. It features a C-binding native bridge for bidirectional communication between native code and scripts,

OCaml is a strongly typed functional language featuring a sophisticated type system and a focus on safety and expressiveness. It provides a comprehensive compiling toolchain that transforms source code into either portable bytecode or high-performance native binaries. The project is distinguished by a shared memory parallel runtime that executes computations across multiple processor cores using domains, and an algebraic effect system for managing side effects and control flow through execution context handlers. It also includes a dedicated parser generator to automatically create lexers and

Flex is a scanner generator and lexical analyzer generator that transforms regular expression definitions into software capable of converting input text into tokens. It primarily generates C and C++ source code for use in the development of compilers and interpreters. The tool provides a specific generator for producing object-oriented scanner implementations as classes, allowing lexical analysis tools to integrate directly into C++ software projects. It also includes a cross-compilation toolchain to build scanner implementations for target platforms different from the host machine. The proj

Ring is a low-level cryptographic primitive library and security toolset designed for building portable, secure applications. It provides a collection of implementations for RSA, elliptic curve cryptography, and authenticated symmetric encryption. The project focuses on constant-time cryptography to prevent secret data from leaking through timing side-channel attacks. It utilizes a formal verification tool that generates arithmetic logic from templates, ensuring mathematical correctness and eliminating manual implementation errors. The library includes capabilities for producing cryptographi

TinyGo is a specialized compiler and development toolkit designed to bring the Go programming language to resource-constrained microcontrollers and WebAssembly environments. It provides a bare-metal runtime environment that enables high-level code execution without the need for a traditional operating system, utilizing an LLVM-based backend to generate efficient machine instructions. The project distinguishes itself through aggressive optimization techniques tailored for small hardware, including a static memory allocation strategy and whole-program dead code elimination that significantly re

Cargo-zigbuild is a build tool that compiles Rust projects for different operating systems and architectures using the Zig compiler as an external linker. It functions as an environment-driven wrapper that intercepts standard build commands and injects the target configurations, paths, and flags required for cross-compilation without requiring complex native toolchains. The tool enables cross-platform compilation workflows and configures minimum required standard C library versions for Linux builds by appending version suffixes directly to target specifications. It also packages multi-archite

Gleam is a statically typed, functional programming language designed for building scalable and maintainable applications. It operates as a cross-platform development ecosystem that compiles source code to run on the Erlang virtual machine or within JavaScript environments. The language integrates a package manager and build system that automates dependency resolution, project compilation, and the generation of software bills of materials. The language distinguishes itself through a focus on type-driven domain modeling and a robust foreign function interface framework. By encoding business ru

Gox is a cross-platform build automator and command line tool designed for Go cross-compilation. It serves as a toolchain manager that builds and configures the necessary compilation tools and flags required to target diverse hardware platforms. The system automates the setup, installation, and provisioning of the assemblers and linkers needed for different operating systems and architectures. It manages the generation of executable binaries for multiple platforms in parallel, utilizing custom naming templates and linker flags to prepare software releases. The tool provides capabilities for

ZLUDA is a middleware and translation engine designed to enable the execution of unmodified proprietary compute binaries on non-native graphics hardware. It functions as a compatibility layer that bridges vendor-specific compute interfaces with open standards, allowing software originally restricted to a single hardware ecosystem to operate on alternative graphics processing units. The project achieves this through a combination of dynamic library interception and runtime instruction translation. By replacing standard system libraries and mapping proprietary compute calls to open standards, t

electron-builder is a cross-platform build automator and packaging tool for Electron applications. It bundles source code and dependencies into platform-specific installers, portable executables, and app store formats for Windows, macOS, and Linux. The project functions as a distribution pipeline that orchestrates the signing and notarization of binaries to ensure authenticity and bypass security warnings. It also serves as an auto-update orchestrator, preparing application packages and distribution channels to support automatic background software updates. Its capability surface covers the

This project is a Vue.js plugin and build tool designed to package web applications into standalone desktop executables using Electron. It functions as a desktop application bundler and packaging tool that transforms web code into distributable installation packages across multiple operating systems and architectures. The tool provides a dedicated development environment that runs a live-reloading server and a desktop window simultaneously to enable rapid iteration. It automates the setup and configuration required to bundle background and foreground processes into a single executable. The p

This project is a game source code decompilation effort that reconstructs a functional C source code representation of a commercial game from its original binary. It provides a compilation system designed to produce binary ROM files that are bit-for-bit identical to original commercial releases. The project utilizes a containerized toolchain environment to ensure consistent compilation of legacy game source code across different operating systems. This pipeline transforms the decompiled C source into hardware-compatible binaries for the Nintendo 64. The workflow encompasses C-based source re

Carp is a statically typed Lisp compiler that compiles Lisp-like syntax directly to C source code, enabling seamless integration with existing C libraries and low-level system programming. It manages memory deterministically at compile time using ownership tracking and linear types, eliminating garbage collection pauses and runtime overhead while ensuring type safety through an inferred static type system. The language distinguishes itself through compile-time macro expansion and metaprogramming capabilities, allowing code generation and transformation before final binary output. It enforces