JAX is a high-performance numerical computing library developed by Google Research. It provides a NumPy-compatible API (jax.numpy), automatic differentiation (jax.grad), just-in-time compilation via XLA (jax.jit), automatic vectorization (jax.vmap), and large-scale parallelization (jax.pmap, jax.shard_map). The library is designed for machine learning research and scientific computing, supporting CPU, GPU (NVIDIA, AMD, Intel), and Google TPU hardware. The system is a hybrid Python/C++ library. The Python layer (jax/) handles function tracing into a JAX intermediate representation (JAXpr), applies transformations (autodiff, batching, sharding), and lowers the computation to MLIR/StableHLO. The C++ backend (jaxlib/) compiles this representation via XLA and manages execution on target hardware. It includes a sophisticated plugin system for hardware backends and a custom kernel DSL (Pallas/Mosaic) for writing high-performance fused operations. While primarily an application/library, JAX has strong research roots. It is explicitly described as a research project, and its experimental/ directory contains rapidly evolving features like custom kernel authoring (Pallas), TensorFlow interop (jax2tf), and sparse array support. The codebase is a blend of production-grade engineering (robust CI, deprecation policies, extensive testing) and cutting-edge research (new autodiff algorithms, novel sharding strategies, experimental hardware support). The repository contains several high-quality, isolated components that are reusable in other Python/C++ projects. These include a file-based LRU cache, a weak-reference LRU cache, thread-safe reentrant hash maps, a lazy module loader, a deprecation framework, and a traceback filtering utility. The core autodiff and JIT compilation patterns are the primary value, but these supporting utilities demonstrate excellent software craftsmanship.
AsmJit is a low-level C++ library for runtime machine-code generation and execution (JIT compilation). It is not an application but a reusable library, with its main entry points in `asmjit/core.h`, `asmjit/x86.h`, `asmjit/a64.h`, and `asmjit/ujit.h`. The library provides three emitter tiers built on a shared emitter abstraction: `BaseAssembler` for direct binary encoding, `BaseBuilder` for node-based IR manipulation, and `BaseCompiler` for high-level code with virtual registers, liveness analysis, and automatic register allocation. The x86/x64 and AArch64 backends are the primary production targets; AArch32 database infrastructure exists but is not a fully implemented backend.
Scholar is a comprehensive machine learning library for Elixir, built directly on Nx (Numerical Elixir). It provides a scikit-learn-inspired API with fit/predict/transform patterns across supervised learning (linear/logistic/ridge/Bayesian ridge regression, SVM, naive Bayes variants, discriminant analysis), unsupervised learning (KMeans, DBSCAN, OPTICS, HDBSCAN, GMM, hierarchical clustering, PCA, KernelPCA, t-SNE, MDS, TriMap), preprocessing (scalers, encoders, imputers), metrics (classification, regression, clustering, ranking, distance), model selection (cross-validation, grid search), optimization (BFGS, Nelder-Mead, Brent), interpolation, and numerical integration. The library is designed for JIT/GPU execution via EXLA, with all numerical kernels written as Nx defn functions and models as Nx.Container structs. The included Livebook notebooks are educational demos, not the primary artifact, so the repository is fundamentally an application/library rather than a data-research project.
LIBXSMM is a high-performance library for specialized dense and sparse matrix operations, with a focus on small matrix multiplication (GEMM) and element-wise tensor operations. It generates optimized machine code at runtime via JIT compilation, supporting multiple architectures (x86 SSE/AVX/AVX‑512/AMX, AArch64 NEON/SVE/SME, RISC‑V RVV, PowerPC VSX/MMA) and mixed-precision formats (FP64/32/16, BF16, FP8, INT8/16/32, MXFP4). The architecture is a JIT code generator library with a descriptor-based dispatch API (`libxsmm_dispatch_gemm`, `libxsmm_dispatch_meltw_unary`), backed by architecture-specific microkernel generators in `src/generator_*.c`. Key entry points include the public header `include/libxsmm.h`, the CPU feature detection (`libxsmm_cpuid_*.c`), and the binary export tool for offline kernel generation. Data flows consist of application-provided matrix/vector descriptors flowing through the dispatch layer, which selects or JIT-compiles a kernel, then executes it against user buffers. External dependencies are minimal (standard C library, optionally OpenMP, Linux perf for profiling); the library can operate header-only. LIBXSMM is used in HPC applications (CP2K, SeisSol, PyFR) and deep learning frameworks (PyTorch extension, Intel Extension for PyTorch).
ArrayFire is a mature, production-grade tensor and array computing library implemented in C++, exposing both a C API (af_* functions) and a C++ API (af::array). It provides hundreds of accelerated numerical operations — dense and sparse linear algebra (LU, QR, SVD, Cholesky, solve), FFT and signal processing, image transforms and filtering, computer vision feature detection (FAST, SIFT, ORB, SUSAN, homography), statistics, and random number generation — across four hardware backends: CPU, CUDA, OpenCL, and oneAPI/SYCL. The architecture is layered: thin C API wrappers and C++ classes in src/api/c and src/api/cpp dispatch through a unified runtime layer (src/api/unified) that lazily loads backend shared libraries via a symbol manager; each backend implements the same templated operation set over device-resident arrays with backend-specific kernels under src/backend/*/kernel. The genuinely interesting engineering lives in src/backend/common: a JIT expression-tree system that fuses array operations into compiled kernels, deterministic hash-based kernel caching, a memory manager with JIT-pressure eviction heuristics, FFT plan caching, and cross-platform dynamic library loading. The test suite is unusually rigorous for a numerical library — well over 100 gtest programs covering correctness across all dtypes, large dimensions, random-number quality via PractRand, and death tests — while examples span image processing, machine learning, financial Monte Carlo, and PDE simulation. Maintenance is active (commits through 2026, CI workflows, source releases), but technical drift is medium: the oneAPI backend is explicitly incomplete with many operations stubbed as ONEAPI_NOT_SUPPORTED, deprecated compatibility APIs remain (include/af/compatible.h), the four backends duplicate a large amount of near-identical code, and some packaging artifacts (Tegra toolchain pinned to gcc-5, vendored vcpkg LAPACK patches, Debian postinst hardcoding MKL/CUDA paths) are stale. This is a software library rather than a data pipeline — there are no notebooks, datasets, or analytical artifacts — though its algorithms are directly applicable to computer vision and scientific computing workloads.
This repository, NVlabs/tiny-cuda-nn, is a high-performance C++/CUDA library and PyTorch extension for training and querying neural networks with a focus on extreme GPU efficiency. It provides a modular, JSON-configurable framework of specialized components: input encodings (multiresolution hash grids, spherical harmonics, frequency, etc.), network architectures (fully fused MLP using Tensor Cores, CUTLASS-based MLP), loss functions, and optimizers (Adam, Shampoo, Novograd, etc.). The library supports runtime JIT compilation to fuse forward, backward, and loss kernels into single CUDA kernels, yielding up to 5x speedups. It is the engine behind NVIDIA's Instant Neural Graphics Primitives (Instant NGP) and is widely used in NeRF and neural rendering research. The codebase is production‑quality, with extensive use of templates, GPU memory arenas, CUDA graphs, multi‑stream parallelism, and comprehensive CI across many CUDA versions and GPU architectures. Although primarily a library, it includes sample applications and benchmarks that demonstrate its use in image overfitting and throughput measurement. PyTorch bindings via pybind11 make it accessible for Python‑based research workflows.