Skyline is a homebrew application framework for the Nintendo Switch that enables runtime code hooking, plugin loading, and enhanced debugging capabilities. It primarily functions as a replacement for game executables (like Super Smash Bros Ultimate) that patches the game's memory to intercept function calls, load user plugins, and provide advanced logging. The architecture centers around three core systems: a sophisticated AArch64 inline hooking engine (And64InlineHook) that safely modifies executable code in memory, a flexible logging subsystem that can output to debugger, SD card, or TCP sockets simultaneously, and a plugin manager that loads and validates user-created Nintendo Relay Object (NRO) files. The framework initializes by setting up memory protections, installing hooks on critical system functions (like file mounting and abort handling), and then transferring control to the target game while maintaining the ability to intercept and modify its behavior. Key technical achievements include the inline hooker's ability to handle various ARM64 branch instructions through trampoline generation and cache management, the logger's thread-safe queue design supporting multiple output destinations, and the plugin system's secure loading process that validates cryptographic hashes before execution. The code demonstrates strong engineering practices with proper resource cleanup, error handling, and separation of concerns.
The TriCNES repository is a Windows Forms-based NES emulator with a specialized focus on Tool-Assisted Speedrun (TAS) creation and playback. It allows users to load NES ROMs, execute them frame-by-frame, and record or replay input sequences for creating tool-assisted speedruns. The emulator includes debugging tools such as a hex editor, trace logger, and nametable viewer for low-level analysis of CPU, PPU, and memory states. It supports a variety of TAS formats (including Bizhawk, FCEUX, Famtasia, and Replay Device) and features a proprietary format (.3ct) designed for experimenting with intercycle cartridge swapping. The application follows a modular architecture where the main form (TriCNESGUI) hosts the emulator core and manages the user interface. Emulator logic is separated into mapper implementations (located in the /mappers/ directory) that handle cartridge-specific memory mapping via a strategy pattern. Tool windows (hex editor, trace logger, etc.) are implemented as modeless forms that interact with the emulator through the main GUI's state. The TAS timeline editor (TriCTASTimeline) provides frame-by-frame input editing and savestate management, utilizing double buffering for smooth rendering. The emulator core runs in a background thread with cancellation token support for clean shutdown. Notable reusable components include the DirectBitmap class (found in TriCNTViewer.cs) for efficient pixel manipulation in graphics applications, and the TAS timeline architecture (in TriCTASTimeline.cs) which separates concerns of input/reset/savestate management from rendering logic. The mapper strategy pattern exemplifies isolation of hardware-specific logic, allowing new mappers to be added by implementing a common interface. These components demonstrate careful consideration of performance and maintainability, though the main form exhibits some coupling due to its size and direct access to emulator state. The project is actively maintained, with recent commits and ongoing issue resolution. It targets the .NET Framework 4.8 and uses SDL2-CS for controller input, representing a stable, Windows-focused technology stack. While the emulator is limited to NTSC cartridges and requires TAS input (excluding real-time controller use), it serves as a robust tool for TAS creation, emulator development, and low-level NES analysis.
DWARF Explorer is a cross-platform GUI utility for visualizing DWARF debugging information in executable files. Built on PyQt6, pyelftools, and filebytes, it allows users to open ELF, Mach-O, PE, WASM, and ar files to browse their DWARF debug information tree. The application provides views for DIEs (Debugging Information Entries), attributes, references, and includes specialized tools for analyzing locals at addresses, function maps, data sections, frame information, and unwind data. The architecture follows a modular design with clear separation between the GUI layer (PyQt6-based interface in __main__.py and ui.py) and the DWARF analysis logic. Core functionality includes parsing various binary formats via formats.py, building and navigating the DIE tree through tree.py and die.py, and performing specialized analyses using utilities in dwarfutil.py, locs.py, and other modules. The application supports features like following DIE references, searching by conditions, highlighting DIEs, and exporting C skeletons. Key strengths include robust error handling with crash reporting, support for multiple binary formats and DWARF versions (including experimental v1 support), and thoughtful UI design with keyboard navigation, bookmarking, and detailed views. The code demonstrates good practices in separating concerns, with reusable components like the Mach-O unwind parser that could be extracted for use in other projects.