qddd — Visualizing Complex Program State During Debugging
Debugging complex systems is often not about where the code goes wrong,
but about what the program state actually looks like at runtime.
Traditional debuggers are excellent at stepping through execution,
but they tend to break down when dealing with:
- deeply nested structures
- pointer-heavy data models
- complex object graphs
- non-trivial runtime relationships between variables
qddd is an experimental debugger UI focused on understanding program state,
not just control flow.
What is qddd?
qddd is a Qt-based graphical debugger frontend designed to visualize
complex runtime data structures in a more structural and graphical way.
Instead of presenting variables only as text trees,
qddd aims to show relationships between objects, pointers, and nested data
to make complex state easier to reason about.
The project communicates with GDB through the Machine Interface (MI)
and is built with a strict separation between the UI layer
and the debugging backend.
⚠️ Experimental project — APIs and UI are evolving.
Screenshot
UI and layout are still evolving as the project develops.
Why qddd?
Most debuggers optimize for execution flow:
breakpoints, stepping, stack navigation.
However, many real-world bugs live in data shape, not in control flow:
- invalid object relationships
- corrupted or unexpected graphs
- broken invariants inside complex structures
qddd focuses on understanding runtime state first,
treating execution control as secondary.
Key ideas
State-first debugging
qddd shifts the main question from:
“What line of code am I on?”
to:
“What does my program look like right now?”
The goal is to inspect and reason about state
before worrying about how execution arrived there.
Structured variable model
Variables are represented as structured runtime entities:
- hierarchical expansion
- explicit memory-oriented modeling
- foundations for future graph-based visualization
The intention is to reflect how data exists in memory,
not just how it prints as text.
Separation between UI and debugger backend
The architecture keeps UI concerns independent
from the underlying debugger implementation.
Core components include:
DebugSession
Manages the GDB process lifecycle and MI communication,
translating debugger events into Qt signals.ConsoleWidget
Interactive MI console showing raw debugger input and output.Variable Model
Tree-based representation of debugger variables,
designed to mirror real memory layouts
and enable future graph-style views.
This design keeps the project flexible and experimentation-friendly.
What qddd is NOT
To avoid confusion, qddd explicitly does not aim to:
- replace a full-featured IDE debugger
- compete with existing IDEs on feature parity
- optimize for beginners
qddd targets developers dealing with
complex in-memory state where textual inspection is insufficient.
Project status
qddd is a work in progress:
- features are incomplete
- internal models are evolving
- UI is still experimental
At this stage, conceptual feedback and discussion
are more valuable than bug reports.
Source code
GitHub repository:
👉 https://github.com/manux81/qddd
Feedback, ideas, and prior-art pointers are very welcome.