Meta built a vendor-neutral accelerator plugin architecture inside lldb-server that lets developers debug applications spanning CPUs and GPUs in a single session, the company disclosed on November 9, 20261.
The design represents the CPU and accelerator as separate LLDB targets, each with its own architecture, threads, registers, address space, and execution state, while presenting them together in one debugging session. The shared infrastructure remains independent of any single GPU, and hardware vendors implement device-specific behavior through a plugin interface.
How the plugin works
LLDB uses lldb-server to launch or attach to a program and communicates through the GDB remote protocol. The new plugin interface lets a hardware-specific backend operate alongside the normal CPU debugger. A plugin can ask LLDB to set internal breakpoints in the host process that identify runtime events such as the point at which a GPU debugging session can begin. When the accelerator becomes available, the plugin provides a second connection that LLDB uses to create the device target.
Device threads, registers, memory, modules, and breakpoints use LLDB's existing abstractions. For CPU-only applications, LLDB and lldb-server continue through the established native debugging path without incurring runtime computational overhead; GPU debugging support activates only when the debugged application uses a supported GPU runtime.
Meta also built a mock accelerator plugin that exercises the full discovery, breakpoint-coordination, connection-creation, and device-state flow without specialized hardware, enabling the LLVM test suite to verify the framework. The framework supports postmortem GPU debugging through core-dump plugins as well as live sessions. A sample session using a vector dot-product HIP program showed a pending breakpoint that resolved when the GPU module loaded, with the resulting backtrace coming from the GPU target.
Upstream status and intent
At the time of writing, Meta had upstreamed most of the common framework to LLVM. The upstreamed work includes the lldb-server plugin interface, GDB-remote packets for plugin discovery, initialization, runtime-event coordination, and GPU connection creation, as well as support for multiple address spaces, associating CPU and GPU debugger processes, and hardware-independent mock tests. Meta plans to finish upstreaming the remaining common infrastructure and expand the vendor integrations built on it. The company's stated goal is that integrating new hardware with LLDB should require only a vendor-specific plugin rather than a separate debugger to build and maintain.
Historically, GPU vendors built device-specific debuggers — AMD's ROCgdb and Nvidia Corp.'s CUDA-GDB — meaning common debugger capabilities had to be implemented and maintained separately. The architecture has evolved through contributions from engineers at Meta and across the accelerator ecosystem.
ANALYSIS By routing GPU debugging through a shared LLDB infrastructure rather than per-vendor tools, the framework reduces the duplicated effort each hardware maker must invest to support mixed CPU-GPU workloads — a direct concern for AI development teams that move computation across host and device boundaries.