# hoffstadt/DearPyGui

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/hoffstadt-dearpygui).**

15,217 stars · 766 forks · C++ · mit

## Links

- GitHub: https://github.com/hoffstadt/DearPyGui
- Homepage: https://dearpygui.readthedocs.io/en/latest/
- awesome-repositories: https://awesome-repositories.com/repository/hoffstadt-dearpygui.md

## Topics

`cpp` `cross-platform` `dearpygui` `graphics` `gui` `imgui` `linux` `macos` `native` `python` `python-gui` `toolkit` `tools` `ui` `windows`

## Description

DearPyGui is a GPU-accelerated, immediate-mode graphical user interface framework for Python. It provides a high-performance toolkit for building interactive desktop applications by leveraging native hardware-accelerated rendering backends across multiple operating systems. By utilizing an immediate-mode execution model, the library offers direct control over the rendering loop and element state, enabling the creation of responsive, dynamic interfaces.

The framework distinguishes itself through its ability to handle complex, high-frequency visual updates, making it suitable for real-time data visualization and scientific instrumentation. It includes specialized support for constructing node-based editors, interactive data plots, and custom drawing canvases. Developers can manage interface complexity through a hierarchical registry system that uses unique identifiers to reference and manipulate components dynamically at runtime.

The library covers a broad capability surface, including advanced layout management with window docking, custom visual theming, and integrated diagnostic tools for inspecting application state. It supports asynchronous task execution to maintain interface responsiveness during intensive computations and provides extensive hooks for event-driven callbacks.

The project is distributed as a Python library, providing a high-level interface to a compiled C++ core that manages the underlying rendering and layout logic.

## Tags

### User Interface & Experience

- [Desktop Applications](https://awesome-repositories.com/f/user-interface-experience/desktop-applications.md) — Construct interactive desktop interfaces with support for node-based editors, drawing tools, and multi-window layouts for specialized software. ([source](https://github.com/hoffstadt/DearPyGui/wiki/Showcase-apps-older-Dear-PyGui-versions))
- [Immediate Mode GUI Toolkits](https://awesome-repositories.com/f/user-interface-experience/immediate-mode-gui-toolkits.md) — Implements an immediate-mode GUI paradigm that provides direct control over the rendering loop and element state.
- [Python GUI Frameworks](https://awesome-repositories.com/f/user-interface-experience/ui-architecture/gui-toolkits/python-gui-frameworks.md) — Provides a GPU-accelerated, immediate-mode framework for building interactive desktop applications and real-time data visualizations in Python.
- [Cross-Platform UI Toolkits](https://awesome-repositories.com/f/user-interface-experience/cross-platform-ui-toolkits.md) — Provides a cross-platform toolkit for building native-looking graphical interfaces with hardware-accelerated rendering.
- [Graphical User Interfaces](https://awesome-repositories.com/f/user-interface-experience/graphical-user-interfaces.md) — Constructs interactive graphical interfaces using a high-performance, hardware-accelerated rendering engine. ([source](https://cdn.jsdelivr.net/gh/hoffstadt/DearPyGui@master/README.md))
- [Immediate-Mode Rendering](https://awesome-repositories.com/f/user-interface-experience/immediate-mode-rendering.md) — Renders the entire interface every frame by sending drawing commands directly to the graphics processor.
- [Graphical Interface Frameworks](https://awesome-repositories.com/f/user-interface-experience/programmatic-element-construction/graphical-interface-frameworks.md) — Provides a high-performance, GPU-accelerated framework for building interactive desktop applications with immediate-mode rendering. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/item-creation.html))
- [Node-Based UI Editors](https://awesome-repositories.com/f/user-interface-experience/node-based-ui-editors.md) — Enables the construction of interactive node-based editors for visual data flow management. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/node-editor.html))
- [Component Hierarchies](https://awesome-repositories.com/f/user-interface-experience/component-hierarchies.md) — Manages the structural organization of graphical elements through hierarchical parent-child relationships. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/container-stack.html))
- [Dynamic Component Rendering](https://awesome-repositories.com/f/user-interface-experience/dynamic-component-rendering.md) — Generates high-performance, real-time plots and dynamic visual elements that update based on runtime data. ([source](https://dearpygui.readthedocs.io/en/latest/))
- [Interface Interaction Management](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/interaction-and-event-handling/general-interaction-frameworks/interface-interaction-management.md) — Enables the construction and lifecycle management of interactive widgets within a hierarchical interface. ([source](https://dearpygui.readthedocs.io/en/latest/tutorials/item-usage.html))
- [Rendering Loops](https://awesome-repositories.com/f/user-interface-experience/rendering-loops.md) — Provides direct control over the rendering loop to execute custom logic on every frame for high-performance visual updates. ([source](https://dearpygui.readthedocs.io/en/latest/tutorials/dpg-structure.html))
- [Visual Node Editors](https://awesome-repositories.com/f/user-interface-experience/visual-node-editors.md) — Implements intuitive node-based interfaces for visual programming and complex data flow management. ([source](https://cdn.jsdelivr.net/gh/hoffstadt/DearPyGui@master/README.md))
- [Composition Hierarchies](https://awesome-repositories.com/f/user-interface-experience/composition-hierarchies.md) — Structures interface elements into nested hierarchies using context managers for layout definition. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/container-context-manager.html))
- [Event Handling](https://awesome-repositories.com/f/user-interface-experience/event-handling.md) — Registers event listeners to detect and respond to user input and state changes. ([source](https://dearpygui.readthedocs.io/en/latest/tutorials/item-usage.html))
- [Event-Driven Input Handlers](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/input-handling/event-driven-input-handlers.md) — Routes input events and state changes through a centralized registry to trigger user-defined logic.
- [Interaction Callbacks](https://awesome-repositories.com/f/user-interface-experience/form-and-input-management/interaction-and-event-handling/interaction-logic-hooks/interaction-callbacks.md) — Executes custom logic via event-driven callbacks when users interact with interface elements. ([source](https://dearpygui.readthedocs.io/en/latest/tutorials/item-usage.html))
- [Interaction Event Handlers](https://awesome-repositories.com/f/user-interface-experience/interaction-event-handlers.md) — Executes custom logic in response to user interactions like clicks, resizing, and focus changes on interface elements. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/io-handlers-state.html))
- [Window Docking Systems](https://awesome-repositories.com/f/user-interface-experience/layout-containers/window-docking-systems.md) — Provides functionality for snapping and arranging windows within the viewport to create custom layouts. ([source](https://dearpygui.readthedocs.io/en/latest/extra/video-tutorials.html))
- [Layout Management](https://awesome-repositories.com/f/user-interface-experience/layout-management.md) — Organizes interface elements into functional structures using containers, node editors, and flexible windowing systems. ([source](https://dearpygui.readthedocs.io/en/latest/_sources/index.rst.txt))
- [Visual Themes](https://awesome-repositories.com/f/user-interface-experience/visual-themes.md) — Defines and binds color and style properties globally or to specific interface components. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/themes.html))
- [Component Property Configurators](https://awesome-repositories.com/f/user-interface-experience/component-property-systems/component-property-configurators.md) — Modifies the properties and visual state of existing graphical components dynamically after initialization. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/item-configuration.html))
- [Component Identifiers](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/component-apis/interface-configuration-definitions/ui-component-configuration/component-identifiers.md) — Assigns unique identifiers to interface elements to enable dynamic runtime access and modification. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/item-id-system.html))
- [Data Visualization Widgets](https://awesome-repositories.com/f/user-interface-experience/data-visualization-widgets.md) — Renders interactive data plots and histograms with support for embedding complex widgets within tooltips. ([source](https://dearpygui.readthedocs.io/en/latest/extra/video-tutorials.html))
- [Grid Layouts](https://awesome-repositories.com/f/user-interface-experience/grid-layouts.md) — Organizes interface elements into structured grid layouts with support for custom padding and cell management. ([source](https://github.com/hoffstadt/DearPyGui/wiki/Tools-and-Widgets))
- [Interface Layout Managers](https://awesome-repositories.com/f/user-interface-experience/interface-layout-managers.md) — Adds, removes, or reorders interface elements at runtime to create responsive layouts. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/item-creation.html))
- [Drag and Drop Utilities](https://awesome-repositories.com/f/user-interface-experience/ui-components/form-input-components/drag-and-drop-utilities.md) — Enables moving items between interface components or importing files via drag-and-drop. ([source](https://github.com/hoffstadt/DearPyGui/wiki/Tools-and-Widgets))
- [Visual Styling Frameworks](https://awesome-repositories.com/f/user-interface-experience/visual-styling-frameworks.md) — Adjusts colors, padding, and rounding settings at runtime to preview and apply design changes. ([source](https://dearpygui.readthedocs.io/en/latest/tutorials/tips-resources.html))
- [Widget Data Bindings](https://awesome-repositories.com/f/user-interface-experience/widget-data-bindings.md) — Synchronizes widget values in a centralized system to allow multiple components to share and manipulate data. ([source](https://dearpygui.readthedocs.io/en/latest/extra/video-tutorials.html))
- [Application Window Managers](https://awesome-repositories.com/f/user-interface-experience/application-window-managers.md) — Controls primary application window properties including dimensions, titles, and icons for the main interface container. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/viewport.html))
- [Component References](https://awesome-repositories.com/f/user-interface-experience/component-references.md) — Allows referencing interface components using human-readable string aliases instead of numeric tags. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/item-id-system.html))
- [Performance Rendering Techniques](https://awesome-repositories.com/f/user-interface-experience/data-visualization-tools/data-visualization/performance-rendering-techniques.md) — Optimizes large table performance by rendering only visible rows to maintain high frame rates. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/tables.html))
- [Drag and Drop Utilities](https://awesome-repositories.com/f/user-interface-experience/drag-and-drop-utilities.md) — Facilitates data transfer and element movement between components using drag-and-drop gestures. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/item-callbacks.html))
- [Interface Layouts](https://awesome-repositories.com/f/user-interface-experience/interface-layouts.md) — Facilitates the composition of complex, nested user interfaces that respond to layout changes. ([source](https://dearpygui.readthedocs.io/en/latest/tutorials/dpg-structure.html))
- [Nested Menus](https://awesome-repositories.com/f/user-interface-experience/nested-menus.md) — Organizes interactive commands and nested sub-menus within a top-level bar attached to the main application. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/menus.html))
- [Selection Management](https://awesome-repositories.com/f/user-interface-experience/selection-management.md) — Queries and clears the selection state of nodes and links within a graph editor. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/node-editor.html))
- [Contextual Popups](https://awesome-repositories.com/f/user-interface-experience/styled-properties/popup-styling/contextual-popups.md) — Triggers temporary windows upon user interaction to provide context-sensitive menus or dialogs. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/popups.html))
- [Table Sorting Logic](https://awesome-repositories.com/f/user-interface-experience/tables/column-reorderers/table-sorting-logic.md) — Triggers custom logic when users interact with column headers to reorder table rows based on specific data criteria. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/tables.html))
- [User Interface Components](https://awesome-repositories.com/f/user-interface-experience/user-interface-components.md) — Structures interface elements into hierarchical containers to manage complex layouts and component relationships. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/container-slots.html))
- [Visual Theme Configurations](https://awesome-repositories.com/f/user-interface-experience/visual-theme-configurations.md) — Supports defining and persisting custom visual styles and themes for interface components. ([source](https://github.com/hoffstadt/DearPyGui/wiki/Tools-and-Widgets))
- [Window State Persistence](https://awesome-repositories.com/f/user-interface-experience/window-state-persistence.md) — Persists window geometry and layout configurations across sessions to maintain user experience. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/init-files.html))

### Graphics & Multimedia

- [Cross-Platform Rendering Layers](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/engines/graphics-pipeline-architectures/hardware-accelerated-rendering/cross-platform-rendering-layers.md) — Provides cross-platform graphical interface rendering by leveraging native hardware acceleration APIs like DirectX, Metal, and OpenGL. ([source](https://dearpygui.readthedocs.io/en/latest/about/repo-info.html))
- [GPU-Accelerated UI Rendering](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/systems/gpu-accelerated-ui-rendering.md) — Leverages GPU acceleration to render high-performance interface elements and complex visualizations directly from Python. ([source](https://dearpygui.readthedocs.io/en/latest/about/what-why.html))
- [Custom Shape Rendering](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/engines/canvas-vector-graphics/custom-shape-rendering.md) — Provides a coordinate-based API for drawing primitive shapes, text, and images directly onto application windows. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/drawing-api.html))
- [Hardware-Accelerated Rendering](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/engines/graphics-pipeline-architectures/hardware-accelerated-rendering.md) — Interfaces directly with native graphics APIs to display rendered content across different operating systems.
- [UI Hierarchy Organizers](https://awesome-repositories.com/f/graphics-multimedia/element-organizers/ui-hierarchy-organizers.md) — Organizes graphical elements into parent-child stacks to manage nested containers like windows and groups. ([source](https://dearpygui.readthedocs.io/en/latest/extra/video-tutorials.html))
- [Frame-Based Render Hooks](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/engines/canvas-vector-graphics/custom-shape-rendering/custom-renderable-interfaces/frame-based-render-hooks.md) — Allows running user-defined code during every frame to maintain manual control over the update cycle. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/render-loop.html))
- [Dynamic Texture](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/dynamic-texture.md) — Supports registering and updating image data as textures for high-performance rendering within the interface. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/textures.html))
- [Custom Drawing Routines](https://awesome-repositories.com/f/graphics-multimedia/graphics-engines-rendering/rendering/engines/canvas-vector-graphics/custom-shape-rendering/custom-renderable-interfaces/custom-drawing-routines.md) — Enables implementation of bespoke drawing routines by accessing raw pixel-space coordinates and interaction data. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/plots.html))
- [Animation Controllers](https://awesome-repositories.com/f/graphics-multimedia/real-time-neural-renderers/real-time-3d-rendering-engines/animation-controllers.md) — Supports high-frequency graphical updates for real-time animations and dynamic visual simulations. ([source](https://dearpygui.readthedocs.io/en/latest/extra/showcase.html))

### Development Tools & Productivity

- [Real-Time Data Streams](https://awesome-repositories.com/f/development-tools-productivity/real-time-data-streams.md) — Renders complex datasets and live signal streams at high frame rates for real-time scientific and engineering analysis.
- [Runtime Debugging](https://awesome-repositories.com/f/development-tools-productivity/debugging-profiling-testing/debugging-diagnostics/debugging-inspection-tools/debugging-and-inspection-tools/runtime-debugging.md) — Includes diagnostic tools for inspecting item hierarchies, font glyphs, and performance metrics during development. ([source](https://dearpygui.readthedocs.io/en/latest/extra/video-tutorials.html))

### Operating Systems & Systems Programming

- [Compiled Core Wrappers](https://awesome-repositories.com/f/operating-systems-systems-programming/compiled-core-wrappers.md) — Provides a high-level Python interface to a compiled C++ core for performance-critical rendering and layout logic.
- [Graphics Context Initializers](https://awesome-repositories.com/f/operating-systems-systems-programming/desktop-environment-frameworks/desktop-environment-components/window-management-systems/graphics-context-initializers.md) — Initializes the graphics context and manages the application lifecycle for hardware-accelerated rendering. ([source](https://dearpygui.readthedocs.io/en/latest/tutorials/first-steps.html))

### Data & Databases

- [High-Performance Visualizers](https://awesome-repositories.com/f/data-databases/data-visualization-charts/high-performance-visualizers.md) — Renders high-performance charts capable of displaying over one million data points at sixty frames per second. ([source](https://cdn.jsdelivr.net/gh/hoffstadt/DearPyGui@master/README.md))
- [Data Visualization](https://awesome-repositories.com/f/data-databases/data-analysis-visualization/visualization-frameworks-libraries/data-visualization.md) — Renders incoming signal data and frequency analysis in real-time using high-performance visual plotting. ([source](https://dearpygui.readthedocs.io/en/latest/extra/showcase.html))
- [Data Table Components](https://awesome-repositories.com/f/data-databases/data-table-components.md) — Constructs structured grids with rows, columns, and cells to display information with configurable borders. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/tables.html))
- [Interactive Data Exploration Tools](https://awesome-repositories.com/f/data-databases/interactive-data-exploration-tools.md) — Supports interactive data exploration with built-in panning, zooming, and legend-based visibility toggling. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/plots.html))
- [Application State Containers](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/data-persistence-storage/data-storage/application-state-containers.md) — Provides non-visual data containers for managing application state across interface elements. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/item-value.html))
- [Dataframe Visualizers](https://awesome-repositories.com/f/data-databases/data-engineering/data-visualization-libraries/dataframe-visualizers.md) — Displays structured data tables and manages grid-based positioning for data analysis. ([source](https://github.com/hoffstadt/DearPyGui/wiki/Tools-and-Widgets))
- [Component Identifier Mappings](https://awesome-repositories.com/f/data-databases/identifier-configurations/identifier-mappings/integer-mappings/component-identifier-mappings.md) — Uses integer or string tags to reference and manipulate specific interface components dynamically.
- [Reactive Data Sharing](https://awesome-repositories.com/f/data-databases/shared-memory-data-exchange/reactive-data-sharing.md) — Links multiple interface components to shared data sources for automatic, synchronized updates. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/item-value.html))

### System Administration & Monitoring

- [Performance Visualization](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/observability-platforms/metric-performance-monitors/performance-visualization.md) — Renders complex datasets and scientific measurements in real-time with high-performance graphical plotting. ([source](https://github.com/hoffstadt/DearPyGui/wiki/Showcase-apps-older-Dear-PyGui-versions))
- [Plotting Components](https://awesome-repositories.com/f/system-administration-monitoring/numerical-data-visualizers/plotting-components.md) — Renders numerical data as line graphs and histograms with support for dynamic, real-time updates. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/simple-plots.html))
- [Instrumentation Libraries](https://awesome-repositories.com/f/system-administration-monitoring/instrumentation-libraries.md) — Enables the development of specialized interfaces for real-time hardware control, sensor monitoring, and data acquisition.

### Software Engineering & Architecture

- [Asynchronous Task Execution](https://awesome-repositories.com/f/software-engineering-architecture/concurrency-models/asynchronous-task-execution.md) — Executes non-blocking operations to keep the main interface responsive during heavy processing. ([source](https://github.com/hoffstadt/DearPyGui/wiki/Tools-and-Widgets))
- [Configuration Value Resolvers](https://awesome-repositories.com/f/software-engineering-architecture/default-configuration-values/configuration-value-resolvers.md) — Updates and retrieves data values associated with input widgets to reflect application state. ([source](https://dearpygui.readthedocs.io/en/latest/tutorials/item-usage.html))
- [Hierarchical Registries](https://awesome-repositories.com/f/software-engineering-architecture/hierarchical-registries.md) — Manages interface elements through a centralized tree structure defining layout nesting and lifecycle ownership.
- [Concurrent Task Runners](https://awesome-repositories.com/f/software-engineering-architecture/concurrent-task-runners.md) — Executes multiple background processes in parallel to maintain interface responsiveness during intensive computation. ([source](https://dearpygui.readthedocs.io/en/latest/about/what-why.html))

### Business & Productivity Software

- [Deferred UI Item Creation](https://awesome-repositories.com/f/business-productivity-software/resource-creation-interfaces/deferred-ui-item-creation.md) — Pre-builds interface components in a hidden staging area to be rendered or attached at a later time. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/staging.html))

### Game Development

- [Interface Command Staging](https://awesome-repositories.com/f/game-development/engine-architecture/command-buffers/deferred-command-encoders/interface-command-staging.md) — Pre-builds interface components in a hidden state to optimize rendering and layout updates.

### Programming Languages & Runtimes

- [Texture Loaders](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/systems-languages/swift-projects/image-loading-libraries/texture-loaders.md) — Imports image files from disk to provide pixel data for rendering as textures. ([source](https://dearpygui.readthedocs.io/en/latest/documentation/textures.html))