{"id":13606466,"url":"https://github.com/EpicGamesExt/raddebugger","last_synced_at":"2025-04-12T08:31:14.333Z","repository":{"id":216711970,"uuid":"741625310","full_name":"EpicGamesExt/raddebugger","owner":"EpicGamesExt","description":"A native, user-mode, multi-process, graphical debugger.","archived":false,"fork":false,"pushed_at":"2025-04-10T02:32:52.000Z","size":15981,"stargazers_count":4289,"open_issues_count":136,"forks_count":212,"subscribers_count":49,"default_branch":"master","last_synced_at":"2025-04-10T15:56:43.610Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":"C","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/EpicGamesExt.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-01-10T19:24:08.000Z","updated_at":"2025-04-10T04:01:57.000Z","dependencies_parsed_at":"2024-05-28T16:10:28.537Z","dependency_job_id":"f89b3d94-1ad7-42f6-9621-4ca563406bfa","html_url":"https://github.com/EpicGamesExt/raddebugger","commit_stats":null,"previous_names":["epicgames/raddebugger","epicgamesext/raddebugger"],"tags_count":16,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/EpicGamesExt%2Fraddebugger","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/EpicGamesExt%2Fraddebugger/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/EpicGamesExt%2Fraddebugger/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/EpicGamesExt%2Fraddebugger/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/EpicGamesExt","download_url":"https://codeload.github.com/EpicGamesExt/raddebugger/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":248539821,"owners_count":21121239,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-08-01T19:01:09.409Z","updated_at":"2025-04-12T08:31:14.327Z","avatar_url":"https://github.com/EpicGamesExt.png","language":"C","funding_links":[],"categories":["C","By Industry","C/C++程序设计"],"sub_categories":["Gaming","资源传输下载"],"readme":"# The RAD Debugger Project\r\n\r\n_**Note:** This README does not document usage instructions and tips for the\r\ndebugger itself, and is intended as a technical overview of the project. The\r\ndebugger's README, which includes usage instructions and tips, can be found\r\npackaged along with debugger releases, or within the `build` folder after a\r\nlocal copy has been built._\r\n\r\nThe RAD Debugger is a native, user-mode, multi-process, graphical debugger. It\r\ncurrently only supports local-machine Windows x64 debugging with PDBs, with\r\nplans to expand and port in the future. In the future we'll expand to also\r\nsupport native Linux debugging and DWARF debug info.\r\n\r\nThe RAD Debugger is currently in *ALPHA*. In order to get the debugger bullet-\r\nproof, it'd greatly help out if you submitted the issues you find here, along\r\nwith any information you can gather, like dump files (along with the build you\r\nused), instructions to reproduce, test executables, and so on.\r\n\r\nYou can download pre-built binaries for the debugger\r\n[here](https://github.com/EpicGamesExt/raddebugger/releases).\r\n\r\nThe RAD Debugger project aims to simplify the debugger by simplifying and\r\nunifying the underlying debug info format. In that pursuit we've built the RAD\r\nDebug Info (RDI) format, which is what the debugger parses and uses. To work\r\nwith existing toolchains, we convert PDB (and eventually PE/ELF files with\r\nembedded DWARF) into the RDI format on-demand.\r\n\r\nThe RDI format is currently specified in code, in the files within the\r\n`src/lib_rdi_format` folder. The other relevant folders for working with the\r\nformat are:\r\n\r\n- `lib_rdi_make`: The \"RAD Debug Info Make\" library, for making RDI debug info.\r\n- `rdi_from_pdb`: Our PDB-to-RDI converter. Can be used as a helper codebase\r\n  layer, or built as an executable with a command line interface frontend.\r\n- `rdi_from_dwarf`: Our in-progress DWARF-to-RDI converter.\r\n- `rdi_dump`: Our RDI textual dumping utility.\r\n\r\n## Development Setup Instructions\r\n\r\n**Note: Currently, only x64 Windows development is supported.**\r\n\r\n### 1. Installing the Required Tools (MSVC \u0026 Windows SDK)\r\n\r\nIn order to work with the codebase, you'll need the [Microsoft C/C++ Build Tools\r\nv15 (2017) or later](https://aka.ms/vs/17/release/vs_BuildTools.exe), for both\r\nthe Windows SDK and the MSVC compiler and linker.\r\n\r\nIf the Windows SDK is installed (e.g. via installation of the Microsoft C/C++\r\nBuild Tools), you may also build with [Clang](https://releases.llvm.org/).\r\n\r\n### 2. Build Environment Setup\r\n\r\nBuilding the codebase can be done in a terminal which is equipped with the\r\nability to call either MSVC or Clang from command line.\r\n\r\nThis is generally done by calling `vcvarsall.bat x64`, which is included in the\r\nMicrosoft C/C++ Build Tools. This script is automatically called by the `x64\r\nNative Tools Command Prompt for VS \u003cyear\u003e` variant of the vanilla `cmd.exe`. If\r\nyou've installed the build tools, this command prompt may be easily located by\r\nsearching for `Native` from the Windows Start Menu search.\r\n\r\nYou can ensure that the MSVC compiler is accessible from your command line by\r\nrunning:\r\n\r\n```\r\ncl\r\n```\r\n\r\nIf everything is set up correctly, you should have output very similar to the\r\nfollowing:\r\n\r\n```\r\nMicrosoft (R) C/C++ Optimizing Compiler Version 19.29.30151 for x64\r\nCopyright (C) Microsoft Corporation.  All rights reserved.\r\n\r\nusage: cl [ option... ] filename... [ /link linkoption... ]\r\n```\r\n\r\n### 3. Building\r\n\r\nWithin this terminal, `cd` to the root directory of the codebase, and just run\r\nthe `build.bat` script:\r\n\r\n```\r\nbuild\r\n```\r\n\r\nYou should see the following output:\r\n\r\n```\r\n[debug mode]\r\n[msvc compile]\r\nmetagen_main.c\r\nsearching C:\\devel\\raddebugger/src... 309 files found\r\nparsing metadesk... 15 metadesk files parsed\r\ngathering tables... 96 tables found\r\ngenerating layer code...\r\nraddbg_main.c\r\n```\r\n\r\nIf everything worked correctly, there will be a `build` folder in the root\r\nlevel of the codebase, and it will contain a freshly-built `raddbg.exe`.\r\n\r\n## Short-To-Medium-Term Roadmap\r\n\r\n### The Initial Alpha Battle-Testing Phase\r\n\r\nThe first priority for the project is to ensure that the most crucial debugger\r\ncomponents are functioning extremely reliably for local, x64, Windows\r\ndebugging. This would include parts like debug info conversion, debug info\r\nloading, process control, stepping, evaluation (correct usage of both location\r\ninfo and type info), and a robust frontend which ensures the lower level parts\r\nare usable.\r\n\r\nWe feel that the debugger has already come a long way in all of these respects,\r\nbut given the massive set of possible combinations of languages, build\r\nsettings, toolchains, used language features, and patterns of generated code,\r\nthere are still cases where the debugger has not been tested, and so there are\r\nstill issues. So, we feel that the top priority is eliminating these issues,\r\nsuch that the debugging experience is rock solid.\r\n\r\n### Local x64 Linux Debugging Phase\r\n\r\nThe next priority for the project is to take the rock solid x64 Windows\r\ndebugging experience, and port all of the relevant pieces to support local x64\r\nLinux debugging also.\r\n\r\nThe debugger has been written to abstract over the parts that need to differ on\r\neither Linux or Windows, and this is mainly going to be a task in building out\r\ndifferent backends for those abstraction layers.\r\n\r\nThe major parts of this phase are:\r\n\r\n- Porting the `src/demon` layer to implement the Demon local process control\r\nabstraction API.\r\n- Implementing an x64 ELF Linux unwinder in the `src/ctrl` layer.\r\n- Creating a DWARF-to-RDI converter (in the same way that we've built a\r\nPDB-to-RDI converter). A partial implementation of this is in\r\n`src/rdi_from_dwarf`.\r\n- Porting the `src/render` layer to implement all of the rendering features the\r\nfrontend needs on a Linux-compatible API (the backend used on Windows is D3D11).\r\n- Porting the `src/font_provider` layer to a Linux-compatible font\r\nrasterization backend, like FreeType (the backend used on Windows is\r\nDirectWrite).\r\n- Porting the `src/os` layers to Linux. This includes core operating system\r\nabstraction (virtual memory allocation, threading and synchronization\r\nprimitives, and so on), and graphical operating system abstraction (windows,\r\ninput events, and so on).\r\n\r\nOnce the above list is complete, and once every part is rock solid, the Windows\r\ndebugging experience we'll have worked diligently to create will also be\r\navailable natively on Linux machines.\r\n\r\n### And Beyond!\r\n\r\nThere are several directions we might take after these two major phases,\r\nlike remote debugging, porting to different architectures, further improving\r\nthe debugger's features (like improving the visualization engine), and so on.\r\nBut for now, we're mostly focused on those first two phases.\r\n\r\n---\r\n\r\n# The RAD Linker\r\n\r\nThe 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 create RAD Debugger debug info too (useful for huge executables that otherwise create broken PDBs that overflow internal 32-bit tables).\r\n\r\nThe 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. \r\n\r\nThe command line syntax is fully compatible with MSVC and you can get a full list of implemented switches from `/help`.\r\n\r\nOur 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 dead-code-elimination or link-time-optimizations, but these features are on the road map.\r\n\r\nBy default, the RAD 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`.\r\n\r\nWe also have support for large memory pages, which, when enabled, reduce link time by\r\nanother 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.\r\n\r\n## Short Term Roadmap\r\n- Porting linker to Linux (for Windows executables, just running on Linux).\r\n- Debug info features\r\n  - Get DWARF debug info converter up-and-running.\r\n  - Smooth out rough edges in RADDBGI builder.\r\n  - Improve build speed further (especially for tiny and mid sizes projects).\r\n- Other features to come\r\n  - Dead-code-elimination via `/opt:ref`.\r\n  - Link Time Optimizations with the help of clang (we won't support LTCG from MSVC compiler since it is undocumented).\r\n\r\n## To build the RAD Linker\r\n- Setup development environment, [see](#Development-Setup-Instructions)\r\n- Run `build radlink release` or if you have clang installed `build radlink release clang`. We favor latter option for better code generation.\r\n\r\nIf build was successful linker executable is placed in `build` folder under `radlink.exe`.\r\n\r\n## Benchmarks\r\n\r\n![AMD Ryzen Threadripper PRO 3995WX 64-Cores, 256 GiB RAM (Windows x64)](https://github.com/user-attachments/assets/a95b382a-76b4-4a4c-b809-b61fe25e667a)\r\n\r\n---\r\n\r\n## Top-Level Directory Descriptions\r\n\r\n- `data`: Small binary files which are used when building, either to embed\r\n  within build artifacts, or to package with them.\r\n- `src`: All source code.\r\n\r\nAfter setting up the codebase and building, the following directories will\r\nalso exist:\r\n\r\n- `build`: All build artifacts. Not checked in to version control.\r\n- `local`: Local files, used for local build configuration input files. Not\r\n  checked in to version control.\r\n\r\n## Codebase Introduction\r\n\r\nThe codebase is organized into *layers*. Layers are separated either to isolate\r\ncertain problems, and to allow inclusion into various builds without needing to\r\npull everything in the codebase into a build. Layers correspond with folders\r\ninside of the `src` directory. Sometimes, one folder inside of the `src`\r\ndirectory will include multiple sub-layers, but the structure is intended to be\r\nfairly flat.\r\n\r\nLayers correspond roughly 1-to-1 with *namespaces*. The term \"namespaces\" in\r\nthis context does not refer to specific namespace language features, but rather\r\na naming convention for C-style namespaces, which are written in the codebase as\r\na short prefix, usually 1-3 characters, followed by an underscore. These\r\nnamespaces are used such that the layer to which certain code belongs may be\r\nquickly understood by glancing at code. The namespaces are generally quite short\r\nto ensure that they aren't much of a hassle to write. Sometimes, multiple sub-\r\nlayers will share a namespace. A few layers do not have a namespace, but most\r\ndo. Namespaces are either all-caps or lowercase depending on the context in\r\nwhich they're used. For types, enum values, and some macros, they are\r\ncapitalized. For functions and global variables, they are lowercase.\r\n\r\nLayers depend on other layers, but circular dependencies would break the\r\nseparability and isolation utility of layers (in effect, forming one big layer),\r\nso in other words, layers are arranged into a directed acyclic graph.\r\n\r\nA few layers are built to be used completely independently from the rest of the\r\ncodebase, as libraries in other codebases and projects. As such, these layers do\r\nnot depend on any other layers in the codebase. The folders which contain these\r\nlayers are prefixed with `lib_`, like `lib_rdi_format`.\r\n\r\nA list of the layers in the codebase and their associated namespaces is below:\r\n- `async` (`ASYNC_`): Implements a system for asynchronous work to be queued\r\n  and executed on a thread pool.\r\n- `base` (no namespace): Universal, codebase-wide constructs. Strings, math,\r\n  memory allocators, helper macros, command-line parsing, and so on. Depends\r\n  on no other codebase layers.\r\n- `codeview` (`CV_`): Code for parsing and/or writing the CodeView format.\r\n- `coff` (`COFF_`): Code for parsing and/or writing the COFF (Common Object File\r\n  Format) file format.\r\n- `ctrl` (`CTRL_`): The debugger's \"control system\" layer. Implements\r\n  asynchronous process control, stepping, and breakpoints for all attached\r\n  processes. Runs in lockstep with attached processes. When it runs, attached\r\n  processes are halted. When attached processes are running, it is halted.\r\n  Driven by a debugger frontend on another thread.\r\n- `dasm_cache` (`DASM_`): An asynchronous disassembly decoder and cache. Users\r\n  ask for disassembly for some data, with a particular architecture, and other\r\n  various parameters, and threads implemented in this layer decode and cache the\r\n  disassembly for that data with those parameters.\r\n- `dbgi` (`DI_`): An asynchronous debug info loader and cache. Loads debug info\r\n  stored in the RDI format. Users ask for debug info for a particular path, and\r\n  on separate threads, this layer loads the associated debug info file. If\r\n  necessary, it will launch a separate conversion process to convert original\r\n  debug info into the RDI format.\r\n- `dbg_engine` (`D_`): Implements the core debugger system, without any\r\n  graphical components. This contains top-level logic for things like stepping,\r\n  launching, freezing threads, mid-run breakpoint addition, some caching layers,\r\n  and so on.\r\n- `demon` (`DMN_`): An abstraction layer for local-machine, low-level process\r\n  control. The abstraction is used to provide a common interface for process\r\n  control on target platforms. Used to implement part of `ctrl`.\r\n- `draw` (`DR_`): Implements a high-level graphics drawing API for the\r\n  debugger's purposes, using the underlying `render` abstraction layer. Provides\r\n  high-level APIs for various draw commands, but takes care of batching them,\r\n  and so on.\r\n- `eval` (`E_`): Implements a compiler for an expression language built for\r\n  evaluation of variables, registers, types, and more, from debugger-attached\r\n  processes, debug info, debugger state, and files. Broken into several phases\r\n  mostly corresponding to traditional compiler phases - lexer, parser,\r\n  type-checker, IR generation, and IR evaluation.\r\n- `eval_visualization` (`EV_`): Implements the core non-graphical evaluation\r\n  visualization engine, which can be used to visualize evaluations (provided by\r\n  the `eval` layer) in a number of ways. Implements core data structures and\r\n  transforms for the `Watch` view.\r\n- `file_stream` (`FS_`): Provides asynchronous file loading, storing the\r\n  artifacts inside of the cache implemented by the `hash_store` layer, and\r\n  hot-reloading the contents of files when they change. Allows callers to map\r\n  file paths to data hashes, which can then be used to obtain the file's data.\r\n- `font_cache` (`FNT_`): Implements a cache of rasterized font data, both in\r\n  CPU-side data for text shaping, and in GPU texture atlases for rasterized\r\n  glyphs. All cache information is sourced from the `font_provider` abstraction\r\n  layer.\r\n- `font_provider` (`FP_`): An abstraction layer for various font file decoding\r\n  and font rasterization backends.\r\n- `fuzzy_search` (`FZY_`): Provides a fuzzy searching engine for doing\r\n  large, asynchronous fuzzy searches. Used by the debugger for implementing\r\n  things like the symbol lister or the `Procedures` view, which search across\r\n  all loaded debug info records, using fuzzy matching rules.\r\n- `geo_cache` (`GEO_`): Implements an asynchronously-filled cache for GPU\r\n  geometry data, filled by data sourced in the `hash_store` layer's cache. Used\r\n  for asynchronously preparing data for visualization.\r\n- `hash_store` (`HS_`): Implements a cache for general data blobs, keyed by a\r\n  128-bit hash of the data. Also implements a 128-bit key cache on top, where\r\n  the keys refer to a unique identity, associated with a 128-bit hash, where the\r\n  hash may change across time. Used as a general data store by other layers.\r\n- `lib_raddbg_markup` (`RADDBG_`): Standalone library for marking up user\r\n  programs to work with various features in the debugger. Does not depend on\r\n  `base`, and can be independently relocated to other codebases.\r\n- `lib_rdi_format` (`RDI_`): Standalone library which defines the core RDI types\r\n  and helper functions for reading and writing the RDI debug info file format.\r\n  Does not depend on `base`, and can be independently relocated to other\r\n  codebases.\r\n- `lib_rdi_make` (`RDIM_`): Standalone library for constructing RDI debug info\r\n  data. Does not depend on `base`, and can be independently relocated\r\n  to other codebases.\r\n- `mdesk` (`MD_`): Code for parsing Metadesk files (stored as `.mdesk`), which\r\n  is the JSON-like (technically a JSON superset) text format used for the\r\n  debugger's user and project configuration files, view rules, and metacode,\r\n  which is parsed and used to generate code with the `metagen` layer.\r\n- `metagen` (`MG_`): A metaprogram which is used to generate primarily code and\r\n  data tables. Consumes Metadesk files, stored with the extension `.mdesk`, and\r\n  generates C code which is then included by hand-written C code. Currently, it\r\n  does not analyze the codebase's hand-written C code, but in principle this is\r\n  possible. This allows easier \u0026 less-error-prone management of large data\r\n  tables, which are then used to produce e.g. C `enum`s and a number of\r\n  associated data tables. There are also a number of other generation features,\r\n  like embedding binary files or complex multi-line strings into source code.\r\n  This layer cannot depend on any other layer in the codebase directly,\r\n  including `base`, because it may be used to generate code for those layers. To\r\n  still use `base` and `os` layer features in the `metagen` program, a separate,\r\n  duplicate version of `base` and `os` are included in this layer. They are\r\n  updated manually, as needed. This is to ensure the stability of the\r\n  metaprogram.\r\n- `msf` (`MSF_`): Code for parsing and/or writing the MSF file format.\r\n- `mule` (no namespace): Test executables for battle testing debugger\r\n  functionality.\r\n- `mutable_text` (`MTX_`): Implements an asynchronously-filled-and-mutated\r\n  cache for text buffers which are mutated across time. In the debugger, this is\r\n  used to implement the `Output` view.\r\n- `natvis` (no namespace): NatVis files for type visualization of the codebase's\r\n  types in other debuggers.\r\n- `os/core` (`OS_`): An abstraction layer providing core, non-graphical\r\n  functionality from the operating system under an abstract API, which is\r\n  implemented per-target-operating-system.\r\n- `os/gfx` (`OS_`): An abstraction layer, building on `os/core`, providing\r\n  graphical operating system features under an abstract API, which is\r\n  implemented per-target-operating-system.\r\n- `path` (`PATH_`): Small helpers for manipulating file path strings.\r\n- `pdb` (`PDB_`): Code for parsing and/or writing the PDB file format.\r\n- `pe` (`PE_`): Code for parsing and/or writing the PE (Portable Executable)\r\n  file format.\r\n- `raddbg` (`RD_`): The layer which ties everything together for the main\r\n  graphical debugger. Implements the debugger's graphical frontend, all of the\r\n  debugger-specific UI, the debugger executable's command line interface, and\r\n  all of the built-in visualizers.\r\n- `rdi_breakpad_from_pdb` (`P2B_`): Our implementation, using the codebase's RDI\r\n  technology, for extracting information from PDBs and generating Breakpad text\r\n  dumps.\r\n- `rdi_dump` (no namespace): A dumper utility program for dumping\r\n  textualizations of RDI debug info files.\r\n- `rdi_format` (no namespace): A layer which includes the `lib_rdi_format` layer\r\n  and bundles it with codebase-specific helpers, to easily include the library\r\n  in codebase programs, and have it be integrated with codebase constructs.\r\n- `rdi_from_dwarf` (`D2R_`): Our in-progress implementation of DWARF-to-RDI\r\n  conversion.\r\n- `rdi_from_pdb` (`P2R_`): Our implementation of PDB-to-RDI conversion.\r\n- `rdi_make` (no namespace): A layer which includes the `lib_rdi_make` layer and\r\n  bundles it with codebase-specific helpers, to easily include the library in\r\n  codebase programs, and have it be integrated with codebase constructs.\r\n- `regs` (`REGS_`): Types, helper functions, and metadata for registers on\r\n  supported architectures. Used in reading/writing registers in `demon`, or in\r\n  looking up register metadata.\r\n- `render` (`R_`): An abstraction layer providing an abstract API for rendering\r\n  using various GPU APIs under a common interface. Does not implement a high\r\n  level drawing API - this layer is strictly for minimally abstracting on an\r\n  as-needed basis. Higher level drawing features are implemented in the `draw`\r\n  layer.\r\n- `scratch` (no namespace): Scratch space for small and transient test programs.\r\n- `texture_cache` (`TEX_`): Implements an asynchronously-filled cache for GPU\r\n  texture data, filled by data sourced in the `hash_store` layer's cache. Used\r\n  for asynchronously preparing data for visualization.\r\n- `text_cache` (`TXT_`): Implements an asynchronously-filled cache for textual\r\n  analysis data (tokens, line ranges, and so on), filled by data sourced in the\r\n  `hash_store` layer's cache. Used for asynchronously preparing data for\r\n  visualization (like for the source code viewer).\r\n- `third_party` (no namespace): External code from other projects, which some\r\n  layers in the codebase depend on. All external code is included and built\r\n  directly within the codebase.\r\n- `ui` (`UI_`): Machinery for building graphical user interfaces. Provides a\r\n  core immediate mode hierarchical user interface data structure building\r\n  API, and has helper layers for building some higher-level widgets.\r\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2FEpicGamesExt%2Fraddebugger","html_url":"https://awesome.ecosyste.ms/projects/github.com%2FEpicGamesExt%2Fraddebugger","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2FEpicGamesExt%2Fraddebugger/lists"}