MLX is an array framework for machine learning on Apple Silicon and NVIDIA GPUs, developed by Apple's machine learning research team. It provides a NumPy-like API for Python and C++ with composable function transformations (autograd, vectorization, graph optimization), lazy computation, dynamic graph construction, and multi-backend support (CPU, Apple Metal, NVIDIA CUDA). The framework includes high-level neural network layers, optimizers, distributed training primitives, quantization support, and model I/O (safetensors, GGUF). It is designed for efficient on-device ML research and inference, with an emphasis on performance via custom GPU kernels, JIT compilation, and unified memory.
Atomic Chat is a full-featured desktop application for running local large language models and connecting to cloud AI providers. Built with Tauri v2 (Rust backend) and a React/TypeScript frontend, it provides a unified chat interface, agent mode with tool execution, MCP server integration, model hub, and an OpenAI-compatible local API server. The application supports multiple inference backends (llama.cpp, MLX, Apple Foundation Models) and handles model downloads, hardware detection, and agent orchestration. It includes extensive testing, telemetry (PostHog/Sentry), and a plugin architecture for extensibility. The codebase demonstrates clean separation of concerns through a service hub pattern, consistent state management with versioned persistence, and robust resource handling for MCP lifecycle and grammar-safe tool calling. Some duplication exists between two llama.cpp provider plugins, but overall architecture is well-structured.
This is the Asahi Linux fork of U-Boot, the universal bootloader, primarily targeting Apple Silicon Macs. The codebase is a full-featured bootloader with support for multiple architectures (ARM, RISC-V, x86, MIPS, PowerPC, etc.), a driver model (DM) for hardware abstraction, device tree support, SPL/TPL multi-stage boot, and a rich command-line interface. It includes bundled libraries for networking (lwIP), cryptography (mbedTLS), and compression (zstd, lzma). The Asahi-specific modifications add support for Apple's M1/M2 SoCs, including early boot initialization, memory mapping, and device tree bindings. The repository is actively maintained with recent commits and a responsive issue tracker.
Iris is a high-performance C inference engine for diffusion image generation models, specifically designed for FLUX.2 Klein (4B/9B) and Z-Image-Turbo (6B) architectures. It provides a complete pipeline from text encoding (Qwen3-4B/8B) through transformer denoising to VAE decoding, outputting PNG or PPM images. The system operates as both a standalone CLI tool with an interactive REPL and a C library (libiris.a), featuring memory-mapped weight loading for efficiency (~4-5GB peak for 4B model) and optional Metal GPU acceleration on Apple Silicon for significant speedups. The architecture is modular: separate components handle safetensors weight loading, BPE tokenization, transformer blocks (double/single stream for Flux, main/refiner for Z-Image), VAE decoding, and image I/O (PNG/JPEG/PPM). The CLI supports text-to-image, image-to-image, multi-reference generation, and various scheduling strategies (shifted sigmoid, linear, power). Memory optimization techniques include releasing the text encoder after embedding extraction, embedding caching with 4-bit quantization, and dynamic attention memory budgeting for reference images. The codebase demonstrates deep systems engineering and ML inference expertise, with hand-optimized kernels, custom Metal shaders, and detailed performance instrumentation. It is self-contained with no external dependencies beyond standard C libraries and optional BLAS/Metal, making it portable across Linux and macOS. The project includes regression test vectors and a JPEG decoder fuzzer, indicating a focus on correctness and reliability.
Cocoa-Way is a macOS-native Wayland compositor that runs Linux GUI applications inside container runtimes (Apple Container, Docker, OrbStack, or via SSH/Waypipe) and renders them to macOS windows using Metal. The core architecture consists of a Rust binary that serves as both a desktop compositor (single window with tiled layout) and a rootless mode that maps each xdg-toplevel to a native macOS window. It features bidirectional clipboard relay (text and PNG, up to 64 MiB), CoreAudio forwarding, a control API over Unix sockets, and an optional MCP server for AI-assisted diagnostics and onboarding. The project demonstrates high craftsmanship in its Metal renderer with texture caching and damage-coalescing, as well as in its container session management, which handles multiple runtime backends and complex lifecycle orchestration. The codebase is well-structured but contains a few monolithic files (e.g., main.rs, container_mode.rs) that handle a large amount of state and UI logic.
rules_ios is a Bazel rule set for building Apple platform applications (iOS, macOS, tvOS, watchOS). It provides rules for creating apps, frameworks, extensions, app clips, tests, and handling Apple-specific complexities like code signing, resource bundling, and multi-architecture support. The repository integrates with rules_apple and rules_swift, offering a Bazel-native alternative to Xcode builds. Key features include automatic handling of Apple Silicon compatibility via import_middleman, VFS overlays for faster builds, and comprehensive test generation. The tooling directory contains utilities like arm64-to-sim for running arm64 binaries in x86_64 simulators and SSH password helpers for VM-based testing.
PMetal is a comprehensive machine learning framework specifically optimized for Apple Silicon hardware. It provides a complete suite for LLM training, fine-tuning, inference, and deployment through multiple interfaces (CLI, TUI, GUI, Python SDK, and REST API). The framework leverages Apple-specific technologies like Metal GPU, ANE, and UltraFusion for performance optimization while supporting standard ML workflows including LoRA/QLoRA fine-tuning, knowledge distillation, model merging, and quantization to formats like GGUF. The architecture follows a modular workspace design with over 20 specialized crates handling different aspects of the ML lifecycle, unified through a job specification system and configuration framework.
This repository is an educational companion to the book 'Programming with 64-Bit ARM Assembly Language', adapted for Apple Silicon (ARM64 macOS, iOS, watchOS, tvOS). It contains 16 chapters of progressively complex assembly examples, covering system calls, memory addressing, functions, floating-point, NEON, and optimization. The code demonstrates key differences between Linux and Darwin (Apple) ABIs, such as syscall numbers, addressing modes (ADRP/ADD vs LDR =symbol), and variadic function calling conventions. It includes reusable debug macros (printReg, printStr) for register inspection, file I/O macros, and a toupper function callable from C, Python, and Swift. The project also features an Xcode SwiftUI app that integrates assembly code across multiple Apple platforms. The repository is well-maintained and actively used as a reference for Apple Silicon assembly development.
exo is a distributed inference system for running large language models (LLMs) and image generation models across clusters of devices, primarily targeting Apple Silicon hardware via the MLX framework. It enables running models larger than a single device's memory by sharding them across multiple nodes using pipeline and tensor parallelism. The system provides an OpenAI-compatible API, a web dashboard, and a native macOS application. The architecture is event-sourced, with a master node managing state and workers executing inference tasks. Communication is handled by a custom Rust networking layer built on Zenoh, supporting peer discovery and RDMA over Thunderbolt. The codebase demonstrates strong engineering in several areas, including immutable state models (FrozenModel), typed pub/sub routing, and sophisticated KV-cache management for LLM inference. While the core architecture is sound, the project carries significant technical debt through custom forks of critical dependencies (zenoh, mlx-lm), extensive monkey-patching to work around upstream library limitations, and a highly complex Nix-based build system. The codebase is tightly coupled to the Apple Silicon ecosystem, limiting portability but enabling deep optimization. It is a high-quality, ambitious project under active development, but its complexity and ecosystem coupling present challenges for long-term maintainability and external contribution.
Hermes Desktop is a native macOS desktop application that serves as a companion for the Hermes AI agent framework. It provides a rich GUI for managing remote Hermes instances over SSH or local connections, including session browsing (chat transcripts), a full terminal emulator (via the vendored SwiftTerm library), Kanban board management, cron job scheduling, file editing, skill browsing, usage analytics, and workflow presets. The architecture is a monolithic SwiftUI + AppKit app with a service layer that communicates with the remote host by generating and executing Python scripts over SSH, parsing JSON responses. The app is designed to be a direct client without any intermediate backend, treating the remote Hermes host as the sole source of truth. It includes a custom design system (HermesUI), localization support (en, zh-Hans, ru), and comprehensive test coverage. While the codebase is well-structured and demonstrates strong SwiftUI and macOS development practices, it has some monolithic views and relies on fragile embedded Python scripts for remote operations.
spank is a macOS CLI tool that detects physical hits/slaps on Apple Silicon MacBooks via the accelerometer and plays audio responses. It requires sudo for IOKit HID access to the accelerometer and is built as a single-file Go application. The tool reads raw accelerometer data, runs vibration detection algorithms (STA/LTA, CUSUM, kurtosis, peak/MAD), and triggers audio playback when impacts exceed a configurable amplitude threshold. It offers multiple modes: pain (random 'ow!' sounds), sexy (escalating responses based on slap frequency), halo (Halo death sounds), lizard (similar to sexy but with lizard sounds), and custom (user-specified MP3 directory). Audio playback uses the beep package with resampling to a fixed sample rate, optional volume scaling based on impact force, and adjustable playback speed. The application uses Cobra for CLI parsing and Fang for command execution, with audio assets embedded via go:embed. Key reusable components include the audio resampling function that handles sample rate conversion and speed adjustment, and the amplitude-to-volume mapping function that applies a logarithmic curve for natural volume scaling.
speakersafetyd is a Rust system daemon that implements a software Smart Amp speaker protection model for Apple Silicon Macs running Linux. It reads voltage and current sense (V/ISENSE) data from a TAS2764-class codec via an ALSA capture PCM, simulates voice coil and magnet temperatures using per-machine configurable thermal parameters, and reduces speaker volume through ALSA mixer controls when temperatures approach limits. The daemon is fail-safe by design: the kernel keeps speakers volume-limited until the daemon writes an unlock magic value, and any panic causes the daemon to exit so the kernel can restore the safe state.