This repository is a curated documentation project, not a software application or a traditional data pipeline. It functions as a 'Wall of Shame' for mobile device manufacturers and carriers that restrict bootloader unlocking. The 'data' is the collective knowledge of the community, structured into Markdown files with a clear taxonomy (verdicts: Avoid, Terrible, Caution, Safe). The primary data flows are manual curation and community contributions guided by strict formatting rules. It answers the research question: 'Which companies prevent me from controlling my device, and how can I bypass their restrictions?' The repository demonstrates strong data engineering principles in its organization. The directory structure (`brands/<company>/README.md`, `carriers/brands/<carrier>/README.md`) acts as a schema, and the `TEMPLATE.md` and `CONTRIBUTING.md` files define a rigorous data ingestion and validation process. The content itself is highly detailed, with deep dives into specific exploits, legal agreements, and hardware-level bypasses, making it a definitive reference for the mobile device modding community. While it lacks executable code, ETL scripts, or machine learning models, its value as a research artifact is exceptionally high. The reproducibility is perfect: an analyst can clone the repository and immediately access the full dataset without any dependencies or environment setup. The project is actively maintained, with recent commits and a responsive issue tracker.
iPXE is an open-source network boot firmware that provides a full PXE implementation with enhanced capabilities. It operates as a pre-boot environment, replacing or supplementing traditional BIOS/UEFI PXE ROMs. The firmware supports booting over HTTP/HTTPS, iSCSI, Fibre Channel over Ethernet (FCoE), AoE, InfiniBand, and wireless networks, with full TLS 1.2 support including modern cipher suites (ECDHE, GCM, X25519, P-256/P-384). It includes a built-in command-line shell, scripting engine, interactive menus, and extensive hardware drivers for network cards, USB controllers, and storage devices across x86, ARM, RISC-V, LoongArch, and s390x architectures. The architecture is modular and table-driven: drivers, protocols, commands, and startup functions are registered via compile-time tables (e.g., `__pci_driver`, `__net_protocol`, `__command`), enabling a highly configurable build. The core uses an interface/refcount pattern for object-oriented-like composition, with reference-counted objects and asynchronous data transfer via `struct interface`. The codebase is well-structured with clear separation between architecture-specific code (under `src/arch/`), platform interfaces (EFI, BIOS, Linux userspace, SBI), and generic core logic. A comprehensive test suite (over 50 unit tests plus Wycheproof vectors) validates cryptographic primitives, network protocols, and data structures. Key entry points include `src/core/main.c` (generic boot flow), EFI application entry (`efiprefix.c`), BIOS PXE ROM entry, and Linux userspace binary. The firmware is typically embedded into option ROMs, UEFI drivers, or bootable images. External dependencies are minimal—the firmware runs directly on hardware or under a hypervisor, relying only on platform firmware services (UEFI, BIOS, SBI) for low-level operations.
Visor is a modern, feature-rich UEFI boot manager written in C, targeting x86_64 and AArch64. It provides a fast, graphically appealing boot menu with auto-detection of operating systems (Linux via EFI stub or raw bzImage, Windows chainload, and other EFI executables). The system is built as a single self-contained EFI binary (~340 KB) using the gnu-efi toolchain, with a sophisticated feature build system that allows compiling optional capabilities (GUI, animations, audio, encryption, TPM, GPT repair, etc.) into lightweight profiles. It supports Secure Boot (including shim), TPM measured boot, LUKS encrypted boot, btrfs snapshot management (snapper/timeshift), BLS/OSTree deployments, and animated backgrounds (GIF, MJPEG, MP4, custom VBG codec). Configuration is done via a plain-text `boot.conf` file, and a companion CLI tool (`visor`) handles installation, updates, kernel encryption, and asset conversion. The codebase demonstrates high craftsmanship through its modular architecture, comprehensive feature stubbing, custom decoders (PNG, JPEG, GIF), GPT repair logic, and hardware-level audio driver (HDA).
This repository is a bare-metal custom bootloader and graphical recovery environment for the Nintendo Switch (Tegra T210/T210B01). It boots Horizon OS, Linux4Tegra, and third-party payloads by decrypting and patching the encrypted HOS boot chain (package1, package2, package3), deriving console keys from TSEC/EKS data, and applying version-specific binary patches. It also provides emuMMC creation and migration, eMMC and SD card tools, USB gadget modes (mass storage and HID), AutoRCM, fuel gauge/thermal diagnostics, and a full hardware bring-up path including display, touch, Joy-Con input, DRAM training, and power management. The code clearly reflects the bootloader's actual production role: a user-triggered payload running from RCM on real Switch hardware, with a text TUI in the main bootloader and a separate LVGL-based graphical frontend called Nyx. Architecturally, the repo is organized into a hardware abstraction layer called BDK (Board Development Kit), the bootloader core, the Nyx GUI application, and dynamically loadable ELF modules for DRAM training and SDRAM LP0 sleep state. The BDK provides drivers for SoC peripherals, power management ICs, storage controllers, the security engine, USB, input, and display, all written as bare-metal C with direct MMIO register access and no OS dependencies. The bootloader uses an INI-based configuration system, a small graphics console, and a module loader that can load ELF shared objects from SD or eMMC. Nyx is a separate application built on a heavily customized fork of LittlevGL v5, with custom themes, fonts, resource packing, and hardware tools. The code demonstrates strong embedded systems skill: meticulous hardware register definitions, retry and error-counting logic in storage drivers, cryptographic key derivation routines updated through many firmware generations, and carefully structured patch tables for firmware signatures. The main weaknesses are the aging bundled libraries (FatFs and LVGL forks are old and diverged from upstream), duplicated graphics implementations between bootloader and sample module, and a large amount of hardcoded hardware-specific constants and addresses. This is not general-purpose software; it is tightly coupled to Tegra X1 hardware and the Nintendo Switch modding ecosystem, but the BDK driver organization, ELF loader, INI parser, list macros, and compression utilities are genuinely reusable in other low-level projects.
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.
CherryDAP is an embedded firmware project that implements a CMSIS-DAP v2.1 debug probe (DAPLink) based on the CherryUSB stack and ARMmbed DAPLink reference code. It supports SWD and JTAG debugging protocols, a USB-to-UART bridge (CDC ACM), and optional features like SWO trace, custom HID commands, and a UF2 bootloader for firmware updates. The repository contains multiple hardware-specific projects targeting different microcontrollers (HPMicro HPM5301, Bouffalo Lab BL616, Espressif ESP32-S3) and two commercial probe variants (HSLink-Lite and HSLink-Pro). The HSLink-Pro variant adds advanced capabilities: programmable target voltage, NeoPixel LED, multi-function button, settings persistence via FlashDB, and a two-slot bootloader for fail-safe upgrades. The core DAP protocol handling is shared across all projects, while each platform provides its own pin configuration, I/O drivers (GPIO bit-bang or SPI-based protocol emulation), and USB descriptors. The architecture follows a monolithic firmware pattern per project, with a main loop that processes USB requests and handles UART data forwarding. The codebase demonstrates solid embedded engineering practices, including SPI-based protocol emulation for high-speed SWD/JTAG, a clean separation of protocol logic from hardware abstraction, and a feature-rich bootloader. However, there is notable code duplication across projects (e.g., SWD/JTAG I/O files, USB2UART implementations) which increases maintenance burden. The repository is actively maintained with recent commits, CI workflows, and documentation.
Cubeboot is a GameCube bootloader/firmware project that enhances the boot process by restoring customizable boot animations, enabling SD card-based software loading, and providing fallback mechanisms. It patches the system's Initial Program Loader (IPL) to inject custom functionality while maintaining compatibility with official hardware. The project supports multiple GameCube hardware revisions (NTSC/PAL variants), various storage adapters (SDGecko, SD2SP2, RP2040-based PicoBoot), and runtime configuration via INI files. Key features include boot animation customization (colors, logo replacement), button-triggered DOL loading, progressive scan support, and fallback to secondary bootloaders like Swiss. The architecture combines bare-metal C/assembly with modular components for filesystem access, ELF/DOL parsing, and hardware abstraction, built using the devkitPPC toolchain.
MCUboot is a secure bootloader for 32-bit microcontrollers, providing signed and encrypted firmware upgrade capabilities. The repository contains the core bootloader library (C) with support for multiple RTOS platforms (Zephyr, Mynewt, NuttX, Mbed OS, Espressif, Cypress), a Python image signing and management tool (imgtool), a Rust-based simulator for testing boot scenarios, and vendored cryptographic libraries (TinyCrypt, Mbed TLS subset, fiat-crypto). The system architecture is a library with platform-specific ports: the common boot logic (bootutil) handles image validation, swap algorithms (scratch, move, offset, direct-XIP, RAM-load), encryption, and fault-injection hardening. Each platform provides flash map, logging, watchdog, and boot entry point implementations. The codebase is highly configurable via compile-time flags, supporting multiple signature schemes (RSA, ECDSA, Ed25519), encryption backends, and upgrade modes. It is not a standalone application but a bootloader intended to be integrated into embedded firmware projects.
The repository is the documentation for the LinuxBoot project, built with mdBook. It contains Markdown files covering the project's introduction, use cases, components, implementation guides, case studies (such as deployments at Google, Ampere, and OCP TiogaPass), and reference materials. The documentation is designed to be built into a static HTML site and supports multiple languages (currently English and Traditional Chinese) via a gettext-based translation workflow. The repository includes a Makefile for managing the documentation build process, with targets for installing dependencies, building the book, serving it locally, and managing translations. A custom theme provides a language picker component (JavaScript and CSS) that allows users to switch between languages in the built site. Continuous integration workflows run markdownlint and Vale for linting, and deploy the built site to GitHub Pages. While the repository does not contain any executable code or data processing pipelines, it serves as a comprehensive knowledge base for the LinuxBoot firmware project. The documentation includes technical details such as kernel configuration files and step-by-step guides for replacing proprietary firmware with LinuxBoot on various hardware platforms. The project is actively maintained, as evidenced by recent commits and ongoing issue activity. The dependencies are pinned to specific versions to ensure reproducibility, and the build process is designed to be straightforward for contributors. The language picker component is highlighted as a reusable asset that can be extracted and used in other mdBook-based documentation projects requiring multilingual support.
This repository is the RR (Redpill Recovery) bootloader for Synology DSM, a tool that enables installing and booting Synology DiskStation Manager on non-Synology hardware. It provides an interactive initrd-based environment (TUI via dialog/whiptail) for configuring DSM model, version, addons, kernel modules, boot parameters, and then building a patched boot image. The system supports multiple deployment targets (raw image, OVA, VMX, VMDK, VHD, VHDX) and includes a GitHub Actions workflow for on-demand custom builds triggered by issue submissions. It also offers remote management via web interfaces (TTYD, DUFS, HTTP) and extensive internationalization with 15+ language translations. The architecture is modular with separate scripts for boot, init, menu, addon management, kernel module handling, and configuration persistence via YAML. While primarily an application, it includes data files (JSON/XLSX catalogs of models, addons, modules, patches) that serve as configuration metadata for the build process.
This is the U-Boot bootloader fork for NXP i.MX SoCs, providing hardware initialization, boot loading, and driver support for a vast range of ARM, RISC-V, and other embedded boards. It implements the U-Boot driver model, SPL/TPL boot stages, verified boot, and extensive command-line interface for embedded development and debugging. The codebase is a mature, production-grade firmware project with support for hundreds of SoCs and boards, particularly NXP i.MX, TI K3, Rockchip, and Renesas platforms. It features a modular driver model, device tree support, secure boot capabilities, comprehensive testing infrastructure, and image generation tools like binman. While the repository is well-maintained, it contains legacy code and significant duplication across board-specific files.
UEFI:NTFS is a UEFI bootloader application that enables booting from NTFS or exFAT partitions on UEFI systems lacking native drivers for these filesystems. It is primarily designed for use with Rufus to create bootable USB drives with Windows installation media or Windows To Go. The bootloader loads a filesystem driver (NTFS or exFAT), mounts the target partition, and chain-loads the standard UEFI bootloader from that partition. The source code is clean, well-commented, and demonstrates careful handling of UEFI firmware quirks, such as driver conflicts and Secure Boot validation. The project compiles with either gnu-efi or EDK2, supports multiple architectures (x86, x64, ARM, ARM64, RISC-V, LoongArch), and includes Visual Studio and GCC build configurations with CI pipelines. While the code is not reusable outside of UEFI development, it serves as a high-quality reference for writing UEFI applications and chain-loaders.
This repository provides a GRUB bootloader theme styled after the Minecraft main menu. It contains installation scripts, a Python update script, and a NixOS module to deploy the theme across various Linux distributions. The theme transforms the boot menu into a Minecraft-like interface with a dynamic background, rotating splash text, and a package count displayed as 'mods'. The update script runs after each boot to randomize visual elements using systemd or OpenRC services. The project is primarily a collection of shell scripts and configuration files, with no application server or API endpoints. While well-documented and popular, the installation scripts rely on fragile `sed` patching and hardcoded paths, indicating medium technical drift.
This repository contains the firmware for FreeJoy, a highly configurable USB game controller (joystick, HOTAS, steering wheel) based on the STM32F103 (Blue Pill). The firmware implements a composite USB device with joystick HID, custom HID (for configuration), and CDC (for SimHub telemetry). It supports a wide variety of input sensors (ADC, magnetic encoders via SPI/I2C), buttons (GPIO, shift registers), encoders, LEDs (matrix and addressable RGB), and PWM outputs. Configuration is stored in flash and managed via a companion PC tool. A separate USB HID bootloader enables firmware updates. The code is bare-metal, leveraging the deprecated STM32 Standard Peripheral Library and CMSIS 3.5.0, with SEGGER RTT/SysView for debugging. The architecture is monolithic but modular within the firmware, with clear separation between bootloader and application.
This repository is a step-by-step tutorial for building an operating system from scratch, progressing from a simple boot sector to a kernel with interrupts, memory management, and a basic shell. The code is organized into sequential lessons, each building upon the previous. The system boots via a custom boot sector, loads a kernel into memory, transitions to 32-bit protected mode, sets up interrupt handling (including timer and keyboard), and provides a shell that can echo user input and handle basic commands like 'END' to halt and 'PAGE' to test memory allocation. While educational and well-commented, the codebase shows signs of abandonment per the README, though the last commit date indicates recent activity. The architecture is monolithic with modular components for bootloader, kernel, drivers (screen, keyboard, timer), and a lightweight libc.
This repository is a community-maintained hub for Hackintosh (macOS on non-Apple hardware) enthusiasts. It provides a comprehensive, curated index of EFI configurations and installation guides for hundreds of laptop and desktop models, along with a collection of utility scripts and binary tools for system setup, diagnostics, and maintenance. The architecture is a flat collection of independent components: a central README acts as the catalog, and the Tools/ directory contains standalone shell scripts (e.g., mount_efi.sh, build_own.sh, sn.sh) and pre-compiled executables (e.g., gfxutil, macserial, CFGLock.efi) that automate common tasks such as kext building, EFI partition mounting, serial number generation, and hardware verification. While not a single application or data pipeline, it hybridizes documentation, tool distribution, and community contribution. The code quality is functional but uneven; many scripts are straightforward and target-specific, while the gfxutil source demonstrates competent C programming with IOKit and EDK2 integration. The main value lies in the curated hardware compatibility list and the availability of time-saving scripts for Hackintosh builders.
This repository is a custom operating system kernel project (UtopiaKernel) targeting x86-64 with the Limine boot protocol. The kernel entry point is written in Rust (using edition 2024, which is unstable) and is compiled as a bare-metal binary. The boot process uses the Limine bootloader, whose precompiled binaries for multiple architectures (x86_64, aarch64, riscv64, loongarch64, IA-32) are included in the repository. The only substantial source code beyond the kernel entry is a C utility (`limine.c`) for installing the Limine bootloader onto disk images and the Limine protocol header. The project demonstrates a modular adapter pattern for boot protocol abstraction, but the codebase is dominated by opaque binary blobs, limiting inspectability and reusability. It appears to be in active development but carries technical drift risk from using an unstable Rust edition and vendored third-party binaries.
This repository is a curated list (awesome list) of embedded systems resources, including tutorials, books, tools, and links for various microcontrollers, RTOS, Linux kernel development, and more. It contains no executable code, libraries, or applications. The sole source file is a README.md that aggregates external references. As a static index, it serves as a reference for embedded engineers but offers no software architecture, reusable components, or functional logic.