Projects sharing features with SteamAchievementManager

STM32duino-bootloader is a firmware bootloader and microcontroller firmware flasher designed for STM32 microcontrollers. Operating as a low-level startup routine, it initializes microcontroller peripherals, handles USB communication routines, and launches user applications upon system reset. This enables direct USB programming and application execution on the hardware without requiring external hardware programmers. The bootloader supports firmware updates by presenting the microcontroller as a USB storage device that accepts binary drag-and-drop file transfers. It writes incoming firmware by

ZealOS is a 64-bit operating system designed for bare-metal deployment and custom kernel development. It provides a self-contained environment that operates within a single-address-space memory model, where all software executes in a ring-zero privilege level to eliminate context switching and facilitate direct hardware interaction. The system distinguishes itself through a monolithic architecture that integrates just-in-time compilation, allowing source code to be translated into machine instructions during runtime. It bypasses traditional abstraction layers by utilizing direct hardware memo

JNA is a foreign function interface and native memory mapper that allows Java applications to call functions in shared native libraries without writing custom JNI wrapper code. It serves as a JNI alternative framework for invoking C functions and mapping native data structures using high-level interfaces. The library distinguishes itself through its ability to translate Java objects and primitives into C-style structs, unions, and pointers for cross-platform memory exchange. On Windows, it provides a dedicated toolkit for interacting with Component Object Model objects using both early and la

TIC-80 is a fantasy console platform and multi-language game engine that provides a virtual retro game development environment. It operates via a bytecode virtual machine that executes game logic within fixed memory and resolution constraints. The project distinguishes itself by offering integrated asset editors for pixel art, tile maps, and a pattern-based chiptune audio workstation all within a single environment. It supports multi-language scripting, allowing developers to write logic in Lua, JavaScript, or Ruby, and provides a standalone game exporter to package projects into native execu

PINCE is a dynamic debugger, instruction tracer, and memory scanner designed for the analysis and manipulation of running processes. It functions as a process memory manipulator and editor, allowing for the identification, modification, and monitoring of values within a target application's active memory. The tool distinguishes itself through memory pointer analysis, tracing addresses and offsets to locate static pointers that lead to dynamic data across different sessions. It also enables the execution of internal functions within a running process by manipulating the instruction pointer and

pwndbg is a GDB plugin and binary analysis framework designed for reverse engineering, exploit development, and low-level program analysis. It extends the core functionality of the debugger to provide advanced memory inspection and automation tools. The project distinguishes itself with specialized capabilities for heap analysis across glibc, jemalloc, and musl, as well as a comprehensive kernel debugging toolkit for inspecting Linux kernel tasks and slab allocators. It includes an integrated ROP gadget searcher for constructing exploit chains and an LLM-powered debugging assistant that provi

This project is a reference library of firmware examples and a development framework for creating embedded C applications on the RP2040 microcontroller. It provides a collection of hardware peripheral drivers and foundational patterns for managing system resources in resource-constrained environments. The library features reference implementations for programmable I/O state machines, allowing for the creation of custom hardware-level protocols. It also provides a multicore embedded framework to distribute computational workloads across multiple processor cores using symmetric processing. The

mGBA is a high-accuracy Game Boy Advance emulator and hardware-level debugger designed to run handheld console ROMs on modern computers. It serves as a scriptable emulation environment that allows for the execution of portable hardware software and the simulation of associated peripherals. The project distinguishes itself through its focus on technical analysis, providing a suite of tools for retro game debugging and game logic inspection. It includes a host-client debug protocol that enables external debugger connectivity via TCP socket communication and an event-driven scripting engine for

MimiPenguin is a Linux memory credential extractor and password recovery tool designed to isolate and retrieve cleartext user login passwords from active process memory. It functions as a post-exploitation utility for extracting sensitive credentials from desktop user sessions during security assessments. The tool performs Linux memory forensics by analyzing system process memory to identify and isolate credentials. It is used for security penetration testing and evaluating risks associated with memory-based attacks, as well as testing for local privilege escalation. The system targets user-

WiringPi is a GPIO hardware control library and embedded hardware interface designed for managing General Purpose Input Output pins on single board computers. It provides a standardized software layer for interacting with hardware registers, facilitating low-latency pin manipulation. The project includes a GPIO command line interface that allows users to inspect pin states and manage hardware input and output levels directly from the terminal. It supports embedded hardware prototyping and hardware state monitoring, specifically targeting Raspberry Pi boards to interact with external electron

Dexposed is a set of runtime tools and engines designed for dynamic patching, framework interception, and code instrumentation on Android devices. It functions as a hooking framework and instrumentation tool used to load custom code into running processes to alter logic without modifying the original bytecode. The project enables the interception and modification of method behavior within both Android applications and the system framework. It specifically provides capabilities for bypassing operating system limitations by overriding framework calls and applying hot patches to live processes w

This repository is a collection of reference implementations and programming examples for the CUDA Toolkit. It serves as a GPGPU implementation guide and a parallel computing reference, providing code for using graphics hardware to perform general-purpose calculations and high-performance parallel processing. The project provides specific samples for GPU kernel development and resource management. These include demonstrations of multi-GPU communication, peer-to-peer memory access, and system hardware inspection to coordinate distributed GPU resources. The codebase covers a wide range of capa

PKHeX is a Pokémon save file editor and save data converter. It serves as an entity data modifier and external data importer used to change game save data and memory images across multiple software generations. The project enables the transformation of game data between different software versions and file formats to ensure cross-generation compatibility. It integrates external files and codes into existing save records to update game state. The tool provides capabilities for save file management and game state manipulation, allowing for the modification of individual entity records, charact

frida-dexdump is an Android memory forensics tool that recovers Dalvik Executable (DEX) files from running application processes using the Frida dynamic instrumentation framework. It functions as a Frida-based runtime analyzer and DEX memory dumper, capable of extracting obfuscated or packed DEX files without modifying the Android system. The tool distinguishes itself through its ability to repair corrupted or missing DEX file headers using heuristic analysis and fuzzy matching techniques. It employs fuzzy boundary detection to identify DEX file boundaries in memory even when headers are dama

pcileech is a toolkit for executing DMA attacks, analyzing PCIe bus traffic, performing kernel patching, and conducting remote volatile memory forensics. It functions as a hardware memory acquisition tool and a PCIe DMA attack framework designed to read and write remote system memory via direct hardware interfaces. The project provides capabilities for capturing and displaying raw transaction layer packets from the PCIe bus and mounting live RAM as local drives for analysis. It enables the modification of system memory signatures and the execution of shellcode or implants within the kernel wi

probe-rs is an embedded debugging toolset used for flashing, debugging, and inspecting microcontrollers via hardware debug probes. It functions as an embedded firmware flasher, a memory manager for reading and writing to processor registers, and a server implementing the Debug Adapter Protocol to connect hardware debugging to various code editors. The project includes a CMSIS-Pack target parser to extract device metadata and flash configurations from industry-standard definition files. It provides a driver-based probe abstraction to interact with various hardware debug probes regardless of th

TShock is a server management tool and plugin framework for dedicated Terraria servers. It functions as an administrative suite and anti-cheat tool designed to control player permissions, monitor game integrity, and extend server functionality. The project provides a framework for creating custom plugins that modify the game world and implement new commands. It enables internal state modification through bytecode injection, packet interception, and memory manipulation to bypass engine restrictions and alter live game environments. Administrative capabilities include a hierarchical role-based

Cerebro is a cross-platform productivity tool and keyboard-driven command palette. It serves as a central search interface and desktop application launcher for finding and initiating the execution of local files, installed software, and web services. The application is an extensible search tool that supports a plugin system, allowing third-party modules to register custom search providers and new functional capabilities. The software covers several capability areas, including local file system navigation and preview, integrated web search, and productivity utilities for natural language mat

This project is a QML desktop shell designed for desktop environment orchestration and interface customization. It functions as a system status dashboard and a declarative user interface for managing system hardware, window metadata, and user sessions. The shell features a dynamic theme generator that extracts dominant colors from wallpapers to automatically synchronize the global visual color palette. It utilizes an inter-process communication system to orchestrate shell functions and a hierarchical JSON configuration framework to manage global and per-monitor interface layouts. The system

tarpc is a remote procedure call framework for Rust that generates server traits and client stubs for network communication. It provides an asynchronous service interface that allows remote functions to be called as if they were local asynchronous tasks. The framework utilizes a serialized transport layer to move request and response data via TCP sockets, Unix domain sockets, or in-process channels. It includes a request lifecycle interceptor for injecting custom logic to handle authorization, throttling, and load balancing, as well as a distributed request telemetry system that attaches dead

vgpu_unlock is a set of software tools and driver modifications designed to unlock enterprise-grade virtualization features on consumer graphics hardware. It functions as a vGPU unlock tool and hardware device ID spoofer that allows a single graphics card to be shared across multiple virtual machines. The project achieves this by employing driver-level hooking, dynamic memory patching, and kernel-level device spoofing. These techniques intercept hardware identification queries and modify the operational state of the GPU driver at runtime to bypass manufacturer-imposed software restrictions.

The 1BRC (One Billion Row Challenge) is a Java performance benchmarking exercise that processes one billion temperature records from a text file to compute the minimum, mean, and maximum temperature per weather station. At its core, it is a large-scale data aggregation challenge designed to test how efficiently a Java program can parse and aggregate structured data from a plain text file, serving as both a programming exercise and a benchmark for Java performance optimization. The project distinguishes itself through a collection of performance-oriented architectural patterns for high-through

Silk.NET is a low-level API binding library for the .NET ecosystem that provides high-performance interfaces for graphics, audio, and input APIs. It consists of a C header binding generator that converts headers into type-safe language bindings, a graphics API interface for GPU compute and rendering, and a cross-platform windowing wrapper. The project utilizes a customizable pipeline to automate the generation of language bindings from C headers by mapping metadata to syntax trees. Its windowing and input abstraction provides a unified interface to manage application windows across different

LearningNotes is a technical knowledge base and engineering study guide focused on Android framework internals, system architecture, and mobile performance optimization. It serves as a reference for analyzing the Android boot sequence, process bootstrapping, and system service initialization. The project provides detailed guides on mobile performance, including strategies for reducing memory footprints, identifying memory leaks, and optimizing image decoding. It further covers Android inter-process communication using AIDL and the Binder kernel driver, as well as software architecture manuals

This repository provides a collection of interactive sample applications and reference implementations for the Electron framework. It serves as a library of API reference demos designed to help developers learn how to implement core desktop features. The project features visual demonstrations of cross-platform GUI management and practical examples of native operating system integration. It includes dedicated samples for handling native modules, crash reports, and the configuration of security implementations such as content security policies and process sandboxing. The codebase covers a broa

This project is a minimal project structure and boilerplate for starting new desktop applications using the Electron framework. It serves as a starter template and reference implementation that provides the essential file layout required for a cross-platform desktop application. The repository is designed to bootstrap a minimal application, allowing for quick desktop application prototyping and the establishment of a basic development environment. This stripped-down structure is also used for software bug isolation to reproduce specific behaviors without the complexity of a full project. The

HyperDbg is a hardware-assisted kernel-mode debugging platform that leverages virtualization to monitor and control system execution. By utilizing hypervisor-level primitives, it enables deep system analysis and instrumentation without relying on standard operating system debugging interfaces. The framework provides a comprehensive environment for inspecting both kernel and user-mode processes, allowing for granular control over execution flow and system state. The project distinguishes itself through a transparent debugging layer designed to remain invisible to the target environment. It emp