EpicGames/raddebuggerPublic

A native, user-mode, multi-process, graphical debugger.

AI summary: A native, user-mode, multi-process graphical debugger for Windows x64 and Linux.

Stars
8.9K
+23 today
Forks
472
Watchers
64
Open issues
294
Open PRs
61
Contributors
~25
Commits
4.8K
Branches
7

CMITCreated Jan 10, 2024Last push 3d agoLatest release v0.9.29-alpha+34 stars this week+248 this month

Quick answers

What is raddebugger?
A native, user-mode, multi-process graphical debugger for Windows x64 and Linux.
What does raddebugger do?
The RAD Debugger is a high-performance graphical debugger designed for native user-mode applications. It features a custom backend built from scratch rather than wrapping existing debugging APIs, allowing it to provide tight integration between its engine and user interface. The debugger is engineered to handle multiple processes simultaneously with minimal overhead. It prioritizes speed and predictability in its debugging workflows.
Who is raddebugger for?
Systems programmers, game developers, and engineers working in C or C++ who need a high-performance graphical debugger. Users should be familiar with low-level systems architecture and native development workflows.
How popular is raddebugger on GitHub?
EpicGames/raddebugger has 8,872 stars and 472 forks on GitHub, and gained 34 stars in the last 7 days.
What license does raddebugger use?
EpicGames/raddebugger is released under the MIT license.

Star history

since Oct 7, 2026
02.5K5K7.5KOct 2026Oct 2026Nov 2026Nov 2026
8.9K stars as of Nov 21, 2026. Measured daily since Oct 7, 2026; GitHub no longer exposes earlier star timestamps.

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-16: 0 commits2025-11-17: 0 commits2025-11-18: 0 commits2025-11-19: 5 commits2025-11-20: 0 commits2025-11-21: 3 commits2025-11-22: 0 commits2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 1 commit2025-11-26: 4 commits2025-11-27: 1 commit2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 2 commits2025-12-03: 0 commits2025-12-04: 0 commits2025-12-05: 4 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 1 commit2025-12-09: 3 commits2025-12-10: 0 commits2025-12-11: 1 commit2025-12-12: 2 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 0 commits2025-12-16: 7 commits2025-12-17: 1 commit2025-12-18: 3 commits2025-12-19: 2 commits2025-12-20: 1 commit2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 1 commit2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 0 commits2026-01-07: 0 commits2026-01-08: 0 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 3 commits2026-01-13: 0 commits2026-01-14: 0 commits2026-01-15: 3 commits2026-01-16: 5 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 6 commits2026-01-21: 0 commits2026-01-22: 6 commits2026-01-23: 0 commits2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 0 commits2026-01-27: 4 commits2026-01-28: 4 commits2026-01-29: 1 commit2026-01-30: 4 commits2026-01-31: 0 commits2026-02-01: 1 commit2026-02-02: 3 commits2026-02-03: 4 commits2026-02-04: 3 commits2026-02-05: 7 commits2026-02-06: 1 commit2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 5 commits2026-02-10: 6 commits2026-02-11: 11 commits2026-02-12: 3 commits2026-02-13: 8 commits2026-02-14: 0 commits2026-02-15: 2 commits2026-02-16: 4 commits2026-02-17: 2 commits2026-02-18: 15 commits2026-02-19: 3 commits2026-02-20: 8 commits2026-02-21: 0 commits2026-02-22: 3 commits2026-02-23: 6 commits2026-02-24: 7 commits2026-02-25: 5 commits2026-02-26: 4 commits2026-02-27: 2 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 3 commits2026-03-03: 1 commit2026-03-04: 7 commits2026-03-05: 0 commits2026-03-06: 0 commits2026-03-07: 0 commits2026-03-08: 0 commits2026-03-09: 4 commits2026-03-10: 1 commit2026-03-11: 2 commits2026-03-12: 3 commits2026-03-13: 3 commits2026-03-14: 0 commits2026-03-15: 2 commits2026-03-16: 3 commits2026-03-17: 5 commits2026-03-18: 10 commits2026-03-19: 8 commits2026-03-20: 1 commit2026-03-21: 0 commits2026-03-22: 0 commits2026-03-23: 0 commits2026-03-24: 3 commits2026-03-25: 1 commit2026-03-26: 1 commit2026-03-27: 2 commits2026-03-28: 0 commits2026-03-29: 3 commits2026-03-30: 0 commits2026-03-31: 12 commits2026-04-01: 2 commits2026-04-02: 2 commits2026-04-03: 2 commits2026-04-04: 0 commits2026-04-05: 0 commits2026-04-06: 6 commits2026-04-07: 6 commits2026-04-08: 4 commits2026-04-09: 6 commits2026-04-10: 3 commits2026-04-11: 6 commits2026-04-12: 0 commits2026-04-13: 2 commits2026-04-14: 4 commits2026-04-15: 12 commits2026-04-16: 11 commits2026-04-17: 4 commits2026-04-18: 4 commits2026-04-19: 2 commits2026-04-20: 15 commits2026-04-21: 9 commits2026-04-22: 13 commits2026-04-23: 10 commits2026-04-24: 4 commits2026-04-25: 1 commit2026-04-26: 0 commits2026-04-27: 13 commits2026-04-28: 7 commits2026-04-29: 5 commits2026-04-30: 10 commits2026-05-01: 6 commits2026-05-02: 1 commit2026-05-03: 3 commits2026-05-04: 2 commits2026-05-05: 21 commits2026-05-06: 5 commits2026-05-07: 17 commits2026-05-08: 13 commits2026-05-09: 11 commits2026-05-10: 2 commits2026-05-11: 12 commits2026-05-12: 20 commits2026-05-13: 18 commits2026-05-14: 8 commits2026-05-15: 4 commits2026-05-16: 2 commits2026-05-17: 1 commit2026-05-18: 15 commits2026-05-19: 10 commits2026-05-20: 16 commits2026-05-21: 4 commits2026-05-22: 9 commits2026-05-23: 5 commits2026-05-24: 3 commits2026-05-25: 1 commit2026-05-26: 10 commits2026-05-27: 3 commits2026-05-28: 0 commits2026-05-29: 3 commits2026-05-30: 0 commits2026-05-31: 0 commits2026-06-01: 0 commits2026-06-02: 10 commits2026-06-03: 10 commits2026-06-04: 0 commits2026-06-05: 0 commits2026-06-06: 4 commits2026-06-07: 0 commits2026-06-08: 5 commits2026-06-09: 14 commits2026-06-10: 7 commits2026-06-11: 5 commits2026-06-12: 13 commits2026-06-13: 4 commits2026-06-14: 1 commit2026-06-15: 3 commits2026-06-16: 3 commits2026-06-17: 5 commits2026-06-18: 11 commits2026-06-19: 7 commits2026-06-20: 0 commits2026-06-21: 7 commits2026-06-22: 12 commits2026-06-23: 5 commits2026-06-24: 3 commits2026-06-25: 7 commits2026-06-26: 6 commits2026-06-27: 6 commits2026-06-28: 1 commit2026-06-29: 0 commits2026-06-30: 2 commits2026-07-01: 0 commits2026-07-02: 0 commits2026-07-03: 3 commits2026-07-04: 0 commits2026-07-05: 0 commits2026-07-06: 1 commit2026-07-07: 1 commit2026-07-08: 0 commits2026-07-09: 2 commits2026-07-10: 3 commits2026-07-11: 3 commits2026-07-12: 4 commits2026-07-13: 9 commits2026-07-14: 2 commits2026-07-15: 0 commits2026-07-16: 2 commits2026-07-17: 2 commits2026-07-18: 2 commits2026-07-19: 2 commits2026-07-20: 6 commits2026-07-21: 2 commits2026-07-22: 2 commits2026-07-23: 2 commits2026-07-24: 0 commits2026-07-25: 0 commits2026-07-26: 0 commits2026-07-27: 12 commits2026-07-28: 3 commits2026-07-29: 3 commits2026-07-30: 0 commits2026-07-31: 0 commits2026-08-01: 0 commits2026-08-02: 0 commits2026-08-03: 0 commits2026-08-04: 2 commits2026-08-05: 7 commits2026-08-06: 10 commits2026-08-07: 4 commits2026-08-08: 1 commit2026-08-09: 1 commit2026-08-10: 5 commits2026-08-11: 7 commits2026-08-12: 3 commits2026-08-13: 4 commits2026-08-14: 1 commit2026-08-15: 0 commits2026-08-16: 0 commits2026-08-17: 4 commits2026-08-18: 3 commits2026-08-19: 6 commits2026-08-20: 6 commits2026-08-21: 24 commits2026-08-22: 0 commits2026-08-23: 0 commits2026-08-24: 3 commits2026-08-25: 6 commits2026-08-26: 13 commits2026-08-27: 8 commits2026-08-28: 0 commits2026-08-29: 0 commits2026-08-30: 0 commits2026-08-31: 0 commits2026-09-01: 0 commits2026-09-02: 3 commits2026-09-03: 16 commits2026-09-04: 0 commits2026-09-05: 1 commit2026-09-06: 0 commits2026-09-07: 0 commits2026-09-08: 1 commit2026-09-09: 2 commits2026-09-10: 4 commits2026-09-11: 1 commit2026-09-12: 4 commits2026-09-13: 2 commits2026-09-14: 0 commits2026-09-15: 4 commits2026-09-16: 3 commits2026-09-17: 1 commit2026-09-18: 0 commits2026-09-19: 3 commits2026-09-20: 0 commits2026-09-21: 5 commits2026-09-22: 2 commits2026-09-23: 3 commits2026-09-24: 3 commits2026-09-25: 7 commits2026-09-26: 1 commit2026-09-27: 0 commits2026-09-28: 4 commits2026-09-29: 7 commits2026-09-30: 19 commits2026-10-01: 13 commits2026-10-02: 9 commits2026-10-03: 1 commit2026-10-04: 0 commits2026-10-05: 0 commits2026-10-06: 1 commit2026-10-07: 7 commits2026-10-08: 0 commits2026-10-09: 2 commits2026-10-10: 0 commits2026-10-11: 0 commits2026-10-12: 7 commits2026-10-13: 0 commits2026-10-14: 2 commits2026-10-15: 1 commit2026-10-16: 6 commits2026-10-17: 0 commits2026-10-18: 1 commit2026-10-19: 5 commits2026-10-20: 3 commits2026-10-21: 0 commits2026-10-22: 4 commits2026-10-23: 3 commits2026-10-24: 0 commits2026-10-25: 2 commits2026-10-26: 6 commits2026-10-27: 10 commits2026-10-28: 17 commits2026-10-29: 4 commits2026-10-30: 6 commits2026-10-31: 1 commit2026-11-01: 2 commits2026-11-02: 1 commit2026-11-03: 14 commits2026-11-04: 2 commits2026-11-05: 0 commits2026-11-06: 0 commits2026-11-07: 0 commits2026-11-08: 0 commits2026-11-09: 0 commits2026-11-10: 0 commits2026-11-11: 0 commits2026-11-12: 0 commits2026-11-13: 0 commits2026-11-14: 0 commits
1,215 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Very active

    1,215 commits in 52 weeks

  • Permissive license

    MIT

  • Continuous integration

    Automated checks passing

  • Repeat trending

    11 trending appearances

What raddebugger does

The RAD Debugger is a high-performance graphical debugger designed for native user-mode applications. It features a custom backend built from scratch rather than wrapping existing debugging APIs, allowing it to provide tight integration between its engine and user interface. The debugger is engineered to handle multiple processes simultaneously with minimal overhead. It prioritizes speed and predictability in its debugging workflows.

Systems programmers, game developers, and engineers working in C or C++ who need a high-performance graphical debugger. Users should be familiar with low-level systems architecture and native development workflows.

  • Native Debugging: Targets native C/C++ applications operating in user-mode environments.
  • Multi-Process Support: Can attach to and debug multiple distinct processes simultaneously.
  • Graphical Interface: Provides a visual, interactive GUI specifically designed for complex debugging tasks.
  • Custom Engine: Built with a bespoke debugging backend to optimize performance and control.
  • Cross-Platform Architecture: Currently supports Windows x64 with Linux and other platforms in development.

Where teams use it

Game Engine Debugging

Debug complex, multi-threaded game engines and applications that require high performance.

Native C/C++ Development

Step through low-level systems programming tasks with fine-grained control over execution.

Multi-Process Systems

Trace issues across multiple interacting user-mode processes in a single debugging session.

Performance Profiling

Identify bottlenecks in application logic using a debugger built for minimal intrusion.

README

master branch

The RAD Debugger Project

NOTE: This README does not document usage instructions and tips for the debugger itself, and is intended as a technical overview of the project. The debugger's README, which includes usage instructions and tips, can be found packaged along with debugger releases, or within the build folder after a local copy has been built. You can find pre-built release binaries here.

The RAD Debugger is a native, user-mode, multi-process, graphical debugger. It currently only supports local-machine x64 debugging on both Windows and Linux (although Linux support is still very early). We plan to expand support to other architectures, and to implement remote and multi-machine debugging.

The debugger is currently in ALPHA. In order to get the debugger bullet-proof, it'd greatly help out if you submitted the issues you find here, along with any information you can gather, like dump files (along with the build you used), instructions to reproduce, test executables, and so on.

In addition to the debugger, we aim to further improve the toolchain with two additional related technologies: (1) the RAD Debug Info (RDI) format, and (2) the RAD Linker.

The RAD Debug Info (RDI) Format

The RAD Debug Info (RDI) format is our custom debug information format, which the debugger parses and uses, rather than the debug information natively produced by toolchains, like PDB or DWARF. To work with these existing toolchains, we convert PDB and DWARF to the RDI format on-demand.

The RDI format is currently specified in code, in the files within the src/lib_rdi folder. In rdi.h and rdi.c, the types and functions which define the format itself are specified. In rdi_parse.h and rdi_parse.c, helpers for parsing the format are included.

We also have an in-progress library for constructing and serializing RDI data, located within the src/lib_rdi_make folder.

Our radbin utility (accessible through the debugger too, via the --bin command line argument) is capable of converting native debug information formats to RDI, and of producing textual dumps of contents stored within RDI files.

The RAD Linker

The RAD Linker is a new performance linker for generating x64 PE/COFF binaries. It is designed to be very fast when creating gigantic executables. It generates standard PDB files for debugging, but it can also (optionally) natively create RAD Debug Info too, which is useful both to eliminate on-demand conversion time when debugging, but also for huge executables that otherwise create broken PDBs that overflow internal 32-bit tables.

The RAD Linker is primarily optimized to handle huge linking projects. In our test cases (where debug info is multiple gigabytes), we see 50% faster link times.

The command line syntax is fully compatible with MSVC; you can get a full list of implemented switches from /help.

Our current designed-for use case for the linker is to help with the compile-debug cycle of huge projects. We don't yet have support for link-time-optimizations, but this feature is on the road map.

By default, the linker spawns as many threads as there are cores, so if you plan to run multiple linkers in parallel, you can limit the number of thread workers via /rad_workers.

We also have support for large memory pages, which, when enabled, reduce link time by another 25%. To link with large pages, you need to explicitly request them via /rad_large_pages. Large pages are off by default, since Windows support for large pages is a bit buggy; we recommend they only be used in Docker or VM images where the environment is reset after each link. In a standard Windows environment, using large pages otherwise will fragment memory quickly, forcing a reboot. We are working on a Linux port of the linker that will be able to build with large pages robustly.

A benchmark of the linker's performance is below:

AMD Ryzen Threadripper PRO 3995WX 64-Cores, 256 GiB RAM (Windows x64)


Project Development Setup / Local Build Instructions

The project is actively developed both on Windows x64 and Linux x64 development machines. Click on whichever you'd like to use.

Windows x64

1. Installing the Required Tools (MSVC & Windows SDK)

First, you'll need the Microsoft C/C++ Build Tools v15 (2017) or later, for the Windows SDK, and the MSVC compiler and linker.

If the Windows SDK is installed (e.g. via installation of the Microsoft C/C++ Build Tools), you may also build with Clang.

2. Build Environment Setup

Building the codebase can be done in a terminal which is equipped with the ability to call either MSVC or Clang from command line.

This is generally done by calling vcvarsall.bat x64, which is included in the Microsoft C/C++ Build Tools. This script is automatically called by the x64 Native Tools Command Prompt for VS <year> variant of the vanilla cmd.exe. If you've installed the build tools, this command prompt may be easily located by searching for Native from the Windows Start Menu search.

You can ensure that the MSVC compiler is accessible from your command line by running:

cl

If everything is set up correctly, you should have output very similar to the following:

Microsoft (R) C/C++ Optimizing Compiler Version 19.29.30151 for x64
Copyright (C) Microsoft Corporation.  All rights reserved.

usage: cl [ option... ] filename... [ /link linkoption... ]

3. Building

Within this terminal, cd to the root directory of the codebase, and just run the build.bat script:

build

You should see the following output:

[debug mode]
[msvc compile]
[default mode, assuming `raddbg` build]
metagen_main.c
searching C:\devel\raddebugger/src... 458 files found
parsing metadesk... 16 metadesk files parsed
gathering tables... 97 tables found
generating layer code...
raddbg_main.c

If everything worked correctly, there will be a build folder in the root level of the codebase, and it will contain a freshly-built raddbg.exe.

This raddbg.exe will have been built in debug mode, which is not built with optimizations, and may perform worse. To produce a release mode executable, run build.bat with a release argument:

build release

This build will take significantly longer.

By default, build.bat only builds the debugger if no arguments (or just release) are passed, but additional arguments can be passed to build the RAD Linker, or the radbin CLI binary file utility:

build radlink release
build radbin release

Linux x64

1. Installing the Required Tools (GCC or Clang, Libraries)

First, you'll need either GCC or Clang, if you don't already have them. They can be obtained by running one of the following commands, depending on your toolchain of choice and distribution:

GCC on Ubuntu / Debian / Mint
sudo apt update && sudo apt install build-essential
Clang on Ubuntu / Debian / Mint
sudo apt update && sudo apt install clang llvm
GCC on Arch / Manjaro
sudo pacman -S base-devel
Clang on Arch / Manjaro
sudo pacman -S clang llvm

If you've installed the Clang and LLVM tooling required, you can run:

clang --version && llvm-ar --version

You should see output similar to the following:

Ubuntu clang version 18.1.3 (1ubuntu1)
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
Ubuntu LLVM version 18.1.3
  Optimized build.

If you've installed the GCC tooling required, you can run:

gcc --version && gcc-ar --version

You should see output similar to the following:

gcc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0
Copyright (C) 2023 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

GNU ar (GNU Binutils for Ubuntu) 2.42
Copyright (C) 2024 Free Software Foundation, Inc.
This program is free software; you may redistribute it under the terms of
the GNU General Public License version 3 or (at your option) any later version.
This program has absolutely no warranty.

2. Installing Dependencies

The debugger project relies on a few dynamically linked libraries being present on the system:

  • libfreetype
  • libx11
  • libxext
  • libxfixes
  • libxrandr
  • libgl
  • libegl

You'll need the development packages for them in order to build. These can be installed using one of the following commands, depending on your distribution:

Ubuntu / Debian / Mint
sudo apt install -y libfreetype6-dev libx11-dev libxext-dev libxfixes-dev libxrandr-dev libgl-dev libegl-dev
Arch / Manjaro
sudo pacman -S --needed freetype2 libx11 libxext libxfixes libxrandr libglvnd

3. Building

To build, cd to the root directory of the codebase, and run the build.sh script:

./build.sh

You should see something similar to the following output:

[clang compile]
[debug mode]
[building metagen]
searching /mnt/c/devel/raddebugger/src... 562 files found
parsing metadesk... 23 metadesk files parsed
gathering tables... 138 tables found
generating layer code...

If everything worked correctly, there will be a build folder in the root level of the codebase, and it will contain a freshly-built raddbg binary.

This raddbg will have been built in debug mode, which is not built with optimizations, and may perform worse. To produce a release mode executable, run build.sh with a release argument:

./build.sh release

This build will take significantly longer.

By default, build.sh only builds the debugger if no arguments (or just release) are passed, but additional arguments can be passed to build the RAD Linker, or the radbin CLI binary file utility:

./build.sh radlink release
./build.sh radbin release

Codebase Introduction

Top-Level Directory Descriptions

  • data: Small binary files which are used when building, either to embed within build artifacts, or to package with them.
  • src: All source code.

After setting up the codebase and building, the following directories will also exist:

  • build: All build artifacts. Not checked in to version control.
  • local: Local files, used for local build configuration input files. Not checked in to version control.

Layer Descriptions

The codebase is organized into layers. Layers are separated either to isolate certain problems, and to allow inclusion into various builds without needing to pull everything in the codebase into a build. Layers correspond with folders inside of the src directory. Sometimes, one folder inside of the src directory will include multiple sub-layers, but the structure is intended to be fairly flat.

Layers correspond roughly 1-to-1 with namespaces. The term "namespaces" in this context does not refer to specific namespace language features, but rather a naming convention for C-style namespaces, which are written in the codebase as a short prefix, usually 1-3 characters, followed by an underscore. These namespaces are used such that the layer to which certain code belongs may be quickly understood by glancing at code. The namespaces are generally quite short to ensure that they aren't much of a hassle to write. Sometimes, multiple sub- layers will share a namespace. A few layers do not have a namespace, but most do. Namespaces are either all-caps or lowercase depending on the context in which they're used. For types, enum values, and some macros, they are capitalized. For functions and global variables, they are lowercase.

Layers depend on other layers, but circular dependencies would break the separability and isolation utility of layers (in effect, forming one big layer), so in other words, layers are arranged into a directed acyclic graph.

A few layers are built to be used completely independently from the rest of the codebase, as libraries in other codebases and projects. As such, these layers do not depend on any other layers in the codebase. The folders which contain these layers are prefixed with lib_, like lib_rdi.

A list of the layers in the codebase and their associated namespaces is below:

  • artifact_cache (AC_): Implements an asynchronously-filled cache of computation artifacts, which are automatically evicted when not accessed. Used for asynchronously streaming and caching process memory and file system contents, as well as asynchronously preparing visualizer data.
  • base (no namespace): Universal, codebase-wide constructs. Strings, math, memory allocators, helper macros, command-line parsing, and so on. Requires no other codebase layers.
  • codeview (CV_): Code for parsing and writing the CodeView format.
  • coff (COFF_): Code for parsing and writing the COFF (Common Object File Format) file format.
  • content (C_): Implements a cache for general data blobs, keyed by a 128-bit hash of the data. Also implements a keying system on top, where keys refer to a unique identity which corresponds to a history of 128-bit hashes. Used as a general data store by other layers.
  • ctrl (CTRL_): The debugger's "control system" layer. Implements asynchronous process control, stepping, and breakpoints for all attached processes. Runs in lockstep with attached processes. When it runs, attached processes are halted. When attached processes are running, it is halted. Driven by a debugger frontend on another thread.
  • dbg_engine (D_): Implements the core debugger system, without any graphical components. This contains top-level logic for things like stepping, launching, freezing threads, mid-run breakpoint addition, some caches, and so on.
  • dbg_info (DI_): Implements asynchronous debug info conversion and loading. Maintains a cache for loaded debug info. Loads RAD Debug Info (RDI) files. Launches separate processes for on-demand conversion to the RDI format if necessary. Also provides various asynchronous operations for using debug info, like fuzzy searching across all records in loaded debug info.
  • demon (DMN_): An abstraction layer for local-machine, low-level process control. The abstraction is used to provide a common interface for process control on target platforms. Used to implement part of ctrl.
  • disasm (DASM_): Implements disassembly generation, including exposing the ability to compute and cache disassembly asynchronously.
  • draw (DR_): Implements a high-level graphics drawing API for the debugger's purposes, using the underlying render abstraction layer. Provides high-level APIs for various draw commands, but takes care of batching them, and so on.
  • dwarf (DW_): Code for parsing the DWARF format.
  • eh (EH_): Code for parsing the EH frame format.
  • elf (ELF_): Code for parsing the ELF format.
  • eval (E_): A compiler for an expression language, built for evaluation of variables, registers, types, and more, from debugger-attached processes, debug info, debugger state, and files. Broken into several phases mostly corresponding to traditional compiler phases: lexer, parser, type-checker, IR generation, and IR evaluation.
  • eval_visualization (EV_): Implements the core non-graphical evaluation visualization engine, which can be used to visualize evaluations (provided by the eval layer) in a number of ways. Implements core data structures and transforms for watch tables.
  • file_stream (FS_): Implements asynchronous file streaming, storing the artifacts inside of the cache implemented by the content and artifact_cache layers, hot-reloading the contents of files when they change. Allows callers to map file paths to data hashes, which can then be used to obtain the file's data.
  • font_cache (FNT_): Implements a cache of rasterized font data, both in CPU-side data for text shaping, and in GPU texture atlases for rasterized glyphs. All cache information is sourced from the font_provider abstraction layer.
  • font_provider (FP_): An abstraction layer for various font file decoding and font rasterization backends.
  • lib_raddbg_markup (RADDBG_): Standalone library for marking up user programs to work with various features in the debugger. Does not depend on base, and can be independently relocated to other codebases.
  • lib_rdi (RDI_): Standalone library which defines the core RDI types and helper functions for reading and writing the RDI debug info file format. Does not depend on base, and can be independently relocated to other codebases.
  • lib_rdi_make (RDIM_): Standalone library for constructing RDI debug info data. Does not depend on base, and can be independently relocated to other codebases.
  • linker (LNK_): The layer which implements the RAD Linker executable itself.
  • mdesk (MD_): Code for parsing Metadesk files (stored as .mdesk), which is the JSON-like (technically a JSON superset) text format used for the debugger's user and project configuration files and metacode, which is parsed and used to generate code with the metagen layer.
  • metagen (MG_): A metaprogram which is used to generate primarily code and data tables. Consumes Metadesk files, stored with the extension .mdesk, and generates C code which is then included by hand-written C code. Currently, it does not analyze the codebase's hand-written C code, but in principle this is possible. This allows easier & less-error-prone management of large data tables, which are then used to produce e.g. C enums and a number of associated data tables. There are also a number of other generation features, like embedding binary files or complex multi-line strings into source code.
  • msf (MSF_): Code for parsing and writing the MSF file format.
  • msvc_crt (MSCRT_): Code for parsing that's specific to the MSVC CRT.
  • mule (no namespace): Test executables for battle testing debugger functionality.
  • mutable_text (MTX_): Implements an asynchronously-filled-and-mutated cache for text buffers which are mutated across time. In the debugger, this is used to implement the Output log.
  • natvis (no namespace): NatVis files for type visualization of the codebase's types in other debuggers.
  • os/core (OS_): An abstraction layer providing core, non-graphical functionality from the operating system under an abstract API, which is implemented per-target-operating-system.
  • os/gfx (OS_): An abstraction layer, building on os/core, providing graphical operating system features under an abstract API, which is implemented per-target-operating-system.
  • pdb (PDB_): Code for parsing and writing the PDB file format.
  • pe (PE_): Code for parsing and writing the PE (Portable Executable) file format.
  • radbin (RB_): The layer implementing the radbin binary utility executable.
  • raddbg (RD_): The layer which ties everything together for the main graphical debugger executable. Implements the debugger's graphical frontend, all of the debugger-specific UI, the debugger executable's command line interface, and all of the built-in visualizers.
  • rdi (RDI_): A layer which includes the lib_rdi layer and bundles it with codebase-specific helpers, to easily include the library in codebase programs, and have it be integrated with codebase constructs.
  • rdi_from_coff (C2R_): Code for converting information in COFF files to the equivalent RDI data.
  • rdi_from_dwarf (D2R_): In-progress code for converting DWARF to the equivalent RDI data.
  • rdi_from_elf (E2R_)): Code for converting ELF data to the equivalent RDI data.
  • rdi_from_pdb (P2R_): Code for converting PDB data to the equivalent RDI data.
  • rdi_make (RDIM_): A layer which includes the lib_rdi_make layer and bundles it with codebase-specific helpers, to easily include the library in codebase programs, and have it be integrated with codebase constructs.
  • regs (REGS_): Types, helper functions, and metadata for registers on supported architectures. Used in reading/writing registers in demon, or in looking up register metadata.
  • render (R_): An abstraction layer providing an abstract API for rendering using various GPU APIs under a common interface. Does not implement a high level drawing API - this layer is strictly for minimally abstracting on an as-needed basis. Higher level drawing features are implemented in the draw layer.
  • scratch (no namespace): Scratch space for small and transient test programs.
  • tester (no namespace): A program used for automated testing.
  • text (TXT_): Implements text processing functions, like parsing line breaks, and lexing and parsing source code. Also offers an API to do this asynchronously.
  • third_party (no namespace): External code from other projects, which some layers in the codebase depend on. All external code is included and built directly within the codebase.
  • ui (UI_): Machinery for building graphical user interfaces. Provides a core immediate mode hierarchical user interface data structure building API, and has helper layers for building some higher-level widgets.
View on GitHub

Recent activity

commits and pull requests

Releases and announcements

30 total
  1. The RAD Debugger / Linker v0.9.29-alphav0.9.29-alphaSep 30, 20265K downloads

    ## Debugger Changes - **The debugger now has preliminary support for native Linux x64 debugging.** It's still *very early*, and there is surely a lot to fix, so please expect a less stable experience than on Windows! But it is now finally in a state that we feel it'd be helpful for people to try it, so that we can begin battle-testing the debugger on Linux also. Here are a list of known issues and caveats: - We are not releasing any binaries for Linux yet, so we've provided instructions for locally building the debugger in the codebase's `README.md`. - We do not support debugging of code which uses `fork` and `vfork` yet. - When computing locations of thread-local storage, we currently assume that the debuggee uses the same libc version as the debugger. - We do not currently correctly unwind when the `.eh_frame_hdr` section is missing. This is normally there by default, but this may explain some broken callstacks you encounter. It can be enabled by passing the `--eh-frame-hdr` flag to the linker, if it's not enabled by default. - Bitfield type info is not yet supported correctly. - In some cases, our type deduplication (when converting from DWARF to RDI) is not w

  2. The RAD Debugger / Linker v0.9.28-alphav0.9.28-alphaAug 21, 20262.3K downloads

    # v0.9.28-alpha ### Debugger Changes - First pass (will only work for simple cases currently) of watch expressions locks, allowing the same address (with the same type) to be evaluated after the expression goes out of scope. - Improved disassembly snapping behavior when not viewing disassembly. Now, if you do not have disassembly open, the debugger will prefer snapping to a call stack frame which has line info. - Added some visual and discoverability improvements to the UI. - Fixed a crash in the new (as of 0.9.27) unwinder. (#893, #882, #877, #869, #867, #865, #857, #848, #855, #824, #823) - Fixed a number of memory leaks, causing out-of-control memory usage in some cases. (#850) - Fixed certain cases of location information being incorrectly generated (notably in optimized builds, and functions with large stack usage). (#864) - Fixed incorrect session start logic (debug string clearing, breakpoint hit count resets) in multi-process debugging scenarios. - Fixed rare issues with call stack computation reliability. - Fixed cursor trails not being toggled by the `Animations` setting. - Fixed cursor trails being incorrectly rendered when a cursor is first scrolled into

  3. The RAD Debugger / Linker v0.9.27-alphav0.9.27-alphaJun 12, 20264.5K downloads

    ### Debugger Changes - Added preliminary support for symbol servers. First, the debugger can attempt to download debug info for any module via the `Download Module Debug Info` command (also accessible by right-clicking a module). Second, the debugger can be configured to automatically do this for all modules which don't have debug info via the `Auto Download Debug Info` setting. The local cache path and server URLs used by the debugger for downloading symbols are parsed from the `_NT_SYMBOL_PATH` environment variable. If that environment variable is not configured, then it falls back to the defaults of `C:/SymbolCache` and `https://msdl.microsoft.com/download/symbols`. - Added the ability to disambiguate symbol names by module name, debug info name, or compilation unit name in expressions. This can be done using the usual syntax, e.g. `my_module.dll!foo`, or `my_unit.obj!foo`. `:` can also be used instead of `!`. - Added the ability to redirect debug string output to any label on a per-target basis. Those labels can then be evaluated in any watch window or text visualizer. By default, all targets write to `output`, which is automatically visualized by an `Output` tab. But if y

  4. The RAD Debugger / Linker v0.9.26-alphav0.9.26-alphaMay 19, 20262.1K downloads

    ### Debugger Changes - Added scope ending visualizations to the text view, to display the header of a scope at the closing position of the scope. This can be turned off via the `Cursor Scope End Annotations` setting. - Added the ability to evaluate `autos`, which is a collection of expressions that the debugger determines refer to symbols which are being (or about to be) changed by the selected thread. - Added source-inline and disassembly-inline visualization of auto expressions. This can be turned off via the `Show Auto Watches In Source / Disassembly` setting. - Added the ability to evaluate local static variables unambiguously, when the same name is used for multiple local static variables, even when outside the function containing the local static. This can be done by namespacing the variable name with the containing function, either using a `::` or `.` operator. (#359) - Added a setting, `Transient Tabs`, to disable transient tabs being opened, when the debugger automatically snaps to new code locations. - Added a setting, `Display Pointer Addresses Before Contents`, to always force the debugger to show pointer addresses before attempting to visualize to what the poin

  5. The RAD Debugger / Linker v0.9.25-alphav0.9.25-alphaApr 16, 20262.6K downloads

    This is a smaller release for the debugger and linker, containing some optimizations, many improvements and bug fixes, and some new features. ### Debugger Changes - Added a dedicated cursor address bar to the memory view. This can be focused with the keyboard with the `Focus Menu` command. By default, this command is bound to `Alt + D`, but if you have existing configuration, you will need to bind it yourself manually (this can be done in the palette, or in the memory view itself). This address bar accepts any expression, and controls the cursor's address. All other configuration options are still available in the memory view settings. - Added "Peek Types" to the memory view. These control the set of types which are used to interpret bytes at the cursor. Options exist for basic cases, like integers and floats, but the view also supports entering a list of full type expressions, which can include user-defined types like structures. - Added annotations for members of structure variables to the memory view. - Added a dedicated zoom setting for the memory view. - Added a setting for automatically determining the number of columns in the memory view based on the available spac

Code frequency

additions and deletions
+50K-50KWeek of 2025-11-02: +2,891 linesWeek of 2025-11-02: -1,111 linesWeek of 2025-11-09: +6,924 linesWeek of 2025-11-09: -5,522 linesWeek of 2025-11-16: +1,931 linesWeek of 2025-11-16: -1,700 linesWeek of 2025-11-23: +457 linesWeek of 2025-11-23: -314 linesWeek of 2025-11-30: +572 linesWeek of 2025-11-30: -2,409 linesWeek of 2025-12-07: +2,666 linesWeek of 2025-12-07: -2,367 linesWeek of 2025-12-14: +2,145 linesWeek of 2025-12-14: -1,678 linesWeek of 2025-12-21: +0 linesWeek of 2025-12-21: -0 linesWeek of 2025-12-28: +328 linesWeek of 2025-12-28: -369 linesWeek of 2026-01-04: +0 linesWeek of 2026-01-04: -0 linesWeek of 2026-01-11: +317 linesWeek of 2026-01-11: -230 linesWeek of 2026-01-18: +2,039 linesWeek of 2026-01-18: -1,610 linesWeek of 2026-01-25: +4,767 linesWeek of 2026-01-25: -5,679 linesWeek of 2026-02-01: +3,317 linesWeek of 2026-02-01: -2,554 linesWeek of 2026-02-08: +4,718 linesWeek of 2026-02-08: -3,106 linesWeek of 2026-02-15: +2,854 linesWeek of 2026-02-15: -1,507 linesWeek of 2026-02-22: +1,511 linesWeek of 2026-02-22: -432 linesWeek of 2026-03-01: +2,053 linesWeek of 2026-03-01: -1,632 linesWeek of 2026-03-08: +2,652 linesWeek of 2026-03-08: -2,007 linesWeek of 2026-03-15: +2,992 linesWeek of 2026-03-15: -3,125 linesWeek of 2026-03-22: +1,942 linesWeek of 2026-03-22: -1,859 linesWeek of 2026-03-29: +1,094 linesWeek of 2026-03-29: -1,882 linesWeek of 2026-04-05: +3,528 linesWeek of 2026-04-05: -1,941 linesWeek of 2026-04-12: +4,216 linesWeek of 2026-04-12: -4,107 linesWeek of 2026-04-19: +26,395 linesWeek of 2026-04-19: -22,697 linesWeek of 2026-04-26: +7,299 linesWeek of 2026-04-26: -2,192 linesWeek of 2026-05-03: +26,777 linesWeek of 2026-05-03: -29,293 linesWeek of 2026-05-10: +11,850 linesWeek of 2026-05-10: -20,461 linesWeek of 2026-05-17: +42,091 linesWeek of 2026-05-17: -49,980 linesWeek of 2026-05-24: +16,638 linesWeek of 2026-05-24: -2,067 linesWeek of 2026-05-31: +31,133 linesWeek of 2026-05-31: -27,360 linesWeek of 2026-06-07: +6,741 linesWeek of 2026-06-07: -2,822 linesWeek of 2026-06-14: +14,491 linesWeek of 2026-06-14: -8,157 linesWeek of 2026-06-21: +5,564 linesWeek of 2026-06-21: -11,944 linesWeek of 2026-06-28: +2,348 linesWeek of 2026-06-28: -279 linesWeek of 2026-07-05: +1,472 linesWeek of 2026-07-05: -1,090 linesWeek of 2026-07-12: +3,343 linesWeek of 2026-07-12: -1,078 linesWeek of 2026-07-19: +1,770 linesWeek of 2026-07-19: -603 linesWeek of 2026-07-26: +2,613 linesWeek of 2026-07-26: -653 linesWeek of 2026-08-02: +4,803 linesWeek of 2026-08-02: -3,680 linesWeek of 2026-08-09: +4,090 linesWeek of 2026-08-09: -2,324 linesWeek of 2026-08-16: +3,618 linesWeek of 2026-08-16: -2,605 linesWeek of 2026-08-23: +2,765 linesWeek of 2026-08-23: -1,438 linesWeek of 2026-08-30: +22,711 linesWeek of 2026-08-30: -24,939 linesWeek of 2026-09-06: +761 linesWeek of 2026-09-06: -75 linesWeek of 2026-09-13: +2,360 linesWeek of 2026-09-13: -2,990 linesWeek of 2026-09-20: +876 linesWeek of 2026-09-20: -553 linesWeek of 2026-09-27: +6,273 linesWeek of 2026-09-27: -2,913 linesWeek of 2026-10-04: +1,288 linesWeek of 2026-10-04: -691 linesWeek of 2026-10-11: +2,090 linesWeek of 2026-10-11: -1,119 linesWeek of 2026-10-18: +2,178 linesWeek of 2026-10-18: -1,023 linesWeek of 2026-10-25: +0 linesWeek of 2026-10-25: -0 linesNov 2, 2025Oct 25, 2026
+310.3K lines added, -272.2K removed over the last year.

Commits per week

last 52 weeks
720Week of 2025-11-16: 8 commitsWeek of 2025-11-23: 6 commitsWeek of 2025-11-30: 6 commitsWeek of 2025-12-07: 7 commitsWeek of 2025-12-14: 14 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 1 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 11 commitsWeek of 2026-01-18: 12 commitsWeek of 2026-01-25: 13 commitsWeek of 2026-02-01: 19 commitsWeek of 2026-02-08: 33 commitsWeek of 2026-02-15: 34 commitsWeek of 2026-02-22: 27 commitsWeek of 2026-03-01: 11 commitsWeek of 2026-03-08: 13 commitsWeek of 2026-03-15: 29 commitsWeek of 2026-03-22: 7 commitsWeek of 2026-03-29: 21 commitsWeek of 2026-04-05: 31 commitsWeek of 2026-04-12: 37 commitsWeek of 2026-04-19: 54 commitsWeek of 2026-04-26: 42 commitsWeek of 2026-05-03: 72 commitsWeek of 2026-05-10: 66 commitsWeek of 2026-05-17: 60 commitsWeek of 2026-05-24: 20 commitsWeek of 2026-05-31: 24 commitsWeek of 2026-06-07: 48 commitsWeek of 2026-06-14: 30 commitsWeek of 2026-06-21: 46 commitsWeek of 2026-06-28: 6 commitsWeek of 2026-07-05: 10 commitsWeek of 2026-07-12: 21 commitsWeek of 2026-07-19: 14 commitsWeek of 2026-07-26: 18 commitsWeek of 2026-08-02: 24 commitsWeek of 2026-08-09: 21 commitsWeek of 2026-08-16: 43 commitsWeek of 2026-08-23: 30 commitsWeek of 2026-08-30: 20 commitsWeek of 2026-09-06: 12 commitsWeek of 2026-09-13: 13 commitsWeek of 2026-09-20: 21 commitsWeek of 2026-09-27: 53 commitsWeek of 2026-10-04: 10 commitsWeek of 2026-10-11: 16 commitsWeek of 2026-10-18: 16 commitsWeek of 2026-10-25: 46 commitsWeek of 2026-11-01: 19 commitsWeek of 2026-11-08: 0 commitsNov 16, 2025Nov 8, 2026
1.2K commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 2 commitsSun 1:00 — 1 commitsSun 2:00 — 0 commitsSun 3:00 — 2 commitsSun 4:00 — 0 commitsSun 5:00 — 0 commitsSun 6:00 — 1 commitsSun 7:00 — 2 commitsSun 8:00 — 3 commitsSun 9:00 — 9 commitsSun 10:00 — 5 commitsSun 11:00 — 8 commitsSun 12:00 — 13 commitsSun 13:00 — 18 commitsSun 14:00 — 17 commitsSun 15:00 — 15 commitsSun 16:00 — 16 commitsSun 17:00 — 8 commitsSun 18:00 — 12 commitsSun 19:00 — 15 commitsSun 20:00 — 20 commitsSun 21:00 — 18 commitsSun 22:00 — 11 commitsSun 23:00 — 9 commitsMon 0:00 — 7 commitsMon 1:00 — 1 commitsMon 2:00 — 2 commitsMon 3:00 — 4 commitsMon 4:00 — 0 commitsMon 5:00 — 1 commitsMon 6:00 — 3 commitsMon 7:00 — 2 commitsMon 8:00 — 18 commitsMon 9:00 — 44 commitsMon 10:00 — 50 commitsMon 11:00 — 99 commitsMon 12:00 — 45 commitsMon 13:00 — 88 commitsMon 14:00 — 97 commitsMon 15:00 — 110 commitsMon 16:00 — 96 commitsMon 17:00 — 73 commitsMon 18:00 — 24 commitsMon 19:00 — 23 commitsMon 20:00 — 15 commitsMon 21:00 — 13 commitsMon 22:00 — 15 commitsMon 23:00 — 8 commitsTue 0:00 — 0 commitsTue 1:00 — 1 commitsTue 2:00 — 0 commitsTue 3:00 — 4 commitsTue 4:00 — 0 commitsTue 5:00 — 1 commitsTue 6:00 — 10 commitsTue 7:00 — 13 commitsTue 8:00 — 24 commitsTue 9:00 — 45 commitsTue 10:00 — 70 commitsTue 11:00 — 122 commitsTue 12:00 — 43 commitsTue 13:00 — 80 commitsTue 14:00 — 118 commitsTue 15:00 — 105 commitsTue 16:00 — 123 commitsTue 17:00 — 66 commitsTue 18:00 — 32 commitsTue 19:00 — 24 commitsTue 20:00 — 16 commitsTue 21:00 — 21 commitsTue 22:00 — 9 commitsTue 23:00 — 13 commitsWed 0:00 — 12 commitsWed 1:00 — 6 commitsWed 2:00 — 0 commitsWed 3:00 — 6 commitsWed 4:00 — 2 commitsWed 5:00 — 3 commitsWed 6:00 — 9 commitsWed 7:00 — 9 commitsWed 8:00 — 23 commitsWed 9:00 — 39 commitsWed 10:00 — 51 commitsWed 11:00 — 86 commitsWed 12:00 — 68 commitsWed 13:00 — 84 commitsWed 14:00 — 93 commitsWed 15:00 — 115 commitsWed 16:00 — 92 commitsWed 17:00 — 62 commitsWed 18:00 — 19 commitsWed 19:00 — 22 commitsWed 20:00 — 15 commitsWed 21:00 — 12 commitsWed 22:00 — 8 commitsWed 23:00 — 3 commitsThu 0:00 — 10 commitsThu 1:00 — 2 commitsThu 2:00 — 1 commitsThu 3:00 — 0 commitsThu 4:00 — 1 commitsThu 5:00 — 0 commitsThu 6:00 — 3 commitsThu 7:00 — 18 commitsThu 8:00 — 22 commitsThu 9:00 — 43 commitsThu 10:00 — 55 commitsThu 11:00 — 99 commitsThu 12:00 — 51 commitsThu 13:00 — 86 commitsThu 14:00 — 114 commitsThu 15:00 — 113 commitsThu 16:00 — 105 commitsThu 17:00 — 84 commitsThu 18:00 — 27 commitsThu 19:00 — 9 commitsThu 20:00 — 13 commitsThu 21:00 — 15 commitsThu 22:00 — 10 commitsThu 23:00 — 5 commitsFri 0:00 — 5 commitsFri 1:00 — 10 commitsFri 2:00 — 1 commitsFri 3:00 — 2 commitsFri 4:00 — 2 commitsFri 5:00 — 6 commitsFri 6:00 — 2 commitsFri 7:00 — 10 commitsFri 8:00 — 30 commitsFri 9:00 — 42 commitsFri 10:00 — 61 commitsFri 11:00 — 111 commitsFri 12:00 — 65 commitsFri 13:00 — 96 commitsFri 14:00 — 68 commitsFri 15:00 — 74 commitsFri 16:00 — 78 commitsFri 17:00 — 42 commitsFri 18:00 — 25 commitsFri 19:00 — 12 commitsFri 20:00 — 19 commitsFri 21:00 — 14 commitsFri 22:00 — 17 commitsFri 23:00 — 10 commitsSat 0:00 — 3 commitsSat 1:00 — 1 commitsSat 2:00 — 1 commitsSat 3:00 — 1 commitsSat 4:00 — 3 commitsSat 5:00 — 3 commitsSat 6:00 — 5 commitsSat 7:00 — 4 commitsSat 8:00 — 6 commitsSat 9:00 — 16 commitsSat 10:00 — 23 commitsSat 11:00 — 27 commitsSat 12:00 — 29 commitsSat 13:00 — 13 commitsSat 14:00 — 25 commitsSat 15:00 — 8 commitsSat 16:00 — 12 commitsSat 17:00 — 10 commitsSat 18:00 — 12 commitsSat 19:00 — 27 commitsSat 20:00 — 16 commitsSat 21:00 — 10 commitsSat 22:00 — 2 commitsSat 23:00 — 8 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.
DateListRankStars gained
Oct 16, 2026weekly#4+814
Oct 15, 2026weekly#4+814
Oct 14, 2026weekly#3+857
Oct 13, 2026weekly#3+845
Oct 12, 2026weekly#3+740
Oct 11, 2026weekly#3+740
Oct 10, 2026weekly#2+654
Oct 9, 2026daily#3+283
Oct 9, 2026weekly#5+448
Oct 8, 2026daily#3+283
Oct 7, 2026daily#5+82
  • Genymobile/scrcpy

    Display and control your Android device

    155.3K stars · C

  • microsoft/PowerToys

    Microsoft PowerToys is a collection of utilities that supercharge productivity and customization on Windows

    141.2K stars · C

  • JustVugg/colibri

    A hierarchical inference engine for frontier MoE models: hot experts on the GPU (CUDA, Vulkan), warm ones in RAM, cold ones streamed from NVMe. Written in C, runs on the hardware you already own.

    51.7K stars · C

  • DeusData/codebase-memory-mcp

    Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.

    48.9K stars · C

  • php/php-src

    The PHP Interpreter

    41.8K stars · C

  • mpv-player/mpv

    🎥 Command line media player

    38.2K stars · C