Convert Figma logo to code with AI

KDAB logoGammaRay

GammaRay is a tool to poke around in a Qt-application and also to manipulate the application to some extent.

1,592
279
1,592
100
View on GitHub

Top Related Projects

Seldaek's avatar

monolog

20,944

Sends your logs to files, sockets, inboxes, databases and various web services

Kitware's avatar

ParaView

1,283

VTK-based Data Analysis and Visualization Application

Kitware's avatar

VTK

2,653

Mirror of Visualization Toolkit repository

Kitware's avatar

CMake

6,748

Mirror of CMake upstream repository

Quick Overview

GammaRay is a powerful Qt application inspection and debugging tool that provides deep insights into the internals of Qt-based applications. It allows developers to inspect and manipulate the Qt object graph, view and edit properties, and debug various aspects of their applications.

Pros

  • Comprehensive Inspection: GammaRay offers a wide range of features for inspecting and debugging Qt-based applications, including object graph visualization, property editors, and support for various Qt components.
  • Powerful Debugging Tools: The tool provides advanced debugging capabilities, such as the ability to inspect and modify the state of objects at runtime, set breakpoints, and step through the application's execution.
  • Cross-Platform Support: GammaRay is designed to work across multiple platforms, including Windows, macOS, and Linux, making it a versatile tool for Qt developers.
  • Active Development and Community: The project is actively maintained by the KDAB team and has a strong community of contributors, ensuring ongoing improvements and support.

Cons

  • Steep Learning Curve: GammaRay's extensive feature set and complex user interface can make it challenging for new users to get started and fully utilize the tool's capabilities.
  • Performance Impact: Depending on the application being inspected, the use of GammaRay can have a noticeable impact on the application's performance, which may be a concern for some developers.
  • Limited Integration with IDEs: While GammaRay can be used as a standalone application, its integration with popular IDEs (Integrated Development Environments) like Qt Creator or Visual Studio is limited, which may be a drawback for some developers.
  • Potential Compatibility Issues: As a third-party tool, GammaRay may occasionally encounter compatibility issues with certain versions of Qt or other dependencies, which can require additional troubleshooting or workarounds.

Code Examples

Since GammaRay is primarily a debugging and inspection tool for Qt-based applications, it does not provide a code library for direct integration. However, you can use GammaRay to inspect and debug your Qt applications during development.

Getting Started

To get started with GammaRay, follow these steps:

  1. Download the latest version of GammaRay from the official website.
  2. Install GammaRay on your system, following the instructions for your specific platform.
  3. Launch your Qt-based application with GammaRay attached. You can do this by either:
    • Launching your application from the GammaRay user interface.
    • Attaching GammaRay to a running application by using the gammaray command-line tool.
  4. Once GammaRay is attached to your application, you can explore the various features and tools it provides, such as:
    • Inspecting the Qt object graph
    • Viewing and editing object properties
    • Debugging signals and slots
    • Analyzing memory usage and performance
    • Profiling the application's execution

For more detailed instructions and usage examples, please refer to the GammaRay documentation.

Competitor Comparisons

Seldaek logo

monolog

20,944

Sends your logs to files, sockets, inboxes, databases and various web services

Pros of Monolog

  • Monolog is a widely-used and well-established logging library for PHP, with a large and active community.
  • It provides a wide range of handlers and formatters, allowing for flexible and customizable logging.
  • Monolog is easy to integrate into existing PHP projects and has good documentation.

Cons of Monolog

  • Monolog is primarily focused on PHP, while GammaRay is a more general-purpose debugging and profiling tool.
  • Monolog may not provide the same level of advanced features and functionality as GammaRay for in-depth application analysis.
  • Monolog's logging capabilities are limited to text-based output, while GammaRay offers a more visual and interactive debugging experience.

Code Comparison

Monolog (PHP):

$logger = new Monolog\Logger('name');
$logger->pushHandler(new Monolog\Handler\StreamHandler('app.log', Monolog\Logger::WARNING));
$logger->warning('Foo');

GammaRay (C++):

auto probe = GammaRay::Probe::create();
probe->registerObject("myObject", new MyObject());
probe->selectObject("myObject");
Kitware logo

ParaView

1,283

VTK-based Data Analysis and Visualization Application

Pros of ParaView

  • ParaView is a powerful and feature-rich data visualization tool, supporting a wide range of data formats and providing advanced visualization capabilities.
  • The project has a large and active community, with extensive documentation and a wealth of online resources.
  • ParaView is highly customizable and can be extended with plugins, allowing users to tailor the tool to their specific needs.

Cons of ParaView

  • ParaView can have a steeper learning curve compared to GammaRay, especially for users who are not familiar with scientific visualization tools.
  • The project's codebase is larger and more complex than GammaRay, which may make it more challenging for new contributors to get involved.

Code Comparison

GammaRay (KDAB/GammaRay):

void GammaRayProbeAwareApplication::initializeGammaRay()
{
    if (isGammaRayProbeAvailable()) {
        GammaRay::registerProbeInstance(this);
    } else {
        qWarning() << "GammaRay probe not available, disabling GammaRay integration.";
    }
}

ParaView (Kitware/ParaView):

vtkStandardNewMacro(vtkPVArrayInformation);

vtkPVArrayInformation::vtkPVArrayInformation()
{
  this->ComponentRange[0] = VTK_DOUBLE_MAX;
  this->ComponentRange[1] = VTK_DOUBLE_MIN;
  this->NumberOfComponents = 0;
  this->Name = nullptr;
  this->Type = VTK_VOID;
}
Kitware logo

VTK

2,653

Mirror of Visualization Toolkit repository

Pros of VTK

  • VTK is a widely-used and well-established open-source library for scientific visualization and data analysis, with a large and active community.
  • VTK provides a comprehensive set of features and tools for a wide range of applications, including medical imaging, computational fluid dynamics, and geospatial analysis.
  • VTK is highly extensible and can be integrated with other libraries and frameworks, such as Python, R, and MATLAB.

Cons of VTK

  • VTK has a steep learning curve, especially for beginners, due to its extensive feature set and complex API.
  • VTK can be resource-intensive, particularly for large datasets or complex visualizations, which may impact performance on some systems.
  • VTK's development is primarily driven by the Kitware team, which may limit the ability of external contributors to influence the project's direction.

Code Comparison

VTK (C++):

vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
sphereSource->SetCenter(0.0, 0.0, 0.0);
sphereSource->SetRadius(5.0);
sphereSource->Update();

vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(sphereSource->GetOutputPort());

vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(mapper);

GammaRay (C++):

auto probe = new GammaRay::ObjectInspector(this);
probe->setObjectName("ObjectInspector");
probe->setWindowTitle(tr("Object Inspector"));
probe->show();
Kitware logo

CMake

6,748

Mirror of CMake upstream repository

Pros of CMake

  • CMake is a widely-used, cross-platform build system that supports a variety of compilers and platforms.
  • CMake provides a consistent and standardized way to manage build configurations, making it easier to maintain and distribute projects.
  • CMake has a large and active community, with extensive documentation and a wealth of resources available.

Cons of CMake

  • CMake's learning curve can be steep, especially for complex projects or users unfamiliar with build systems.
  • CMake's syntax and configuration files can be verbose and difficult to read, especially for larger projects.
  • CMake's dependency management can be challenging, particularly when dealing with third-party libraries.

Code Comparison

CMake (Kitware/CMake):

project(MyProject)

add_executable(myapp main.cpp)

target_link_libraries(myapp PRIVATE mylib)

add_library(mylib STATIC lib.cpp)

GammaRay (KDAB/GammaRay):

#include <GammaRay/GammaRay>

int main(int argc, char** argv)
{
    GammaRay app(argc, argv);
    app.exec();
    return 0;
}

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Logo

GammaRay is a software introspection tool for Qt applications developed by KDAB. Leveraging the QObject introspection mechanism it allows you to observe and manipulate your application at runtime. This works both locally on your workstation and remotely on an embedded target.

Augmenting your instruction-level debugger, GammaRay allows you to work on a much higher level, with the same concepts as the frameworks you use. This is especially useful for the more complex Qt frameworks such as model/view, state machines or scene graphs.

Among other things GammaRay can:

  • Browse the QObject tree with live updates.
  • View and edit object properties.
  • View and invoke slots of a QObject, and monitor its signals.
  • List all QObject inbound and outbound signal/slot connections.
  • Provide a layout information overlay for QWidget and QtQuick2 applications.
  • Inspect all QPainter operations used to draw a specific widget.
  • Browse the QtQuick2 item tree and scenegraph.
  • Inspect shaders and geometry data of QtQuick2 items.
  • Plot object lifetime and emitted signals.
  • Browse the QAbstractProxyModel hierarchy and inspect intermediate results in a proxy model chain.
  • Visual live inspection of QStateMachines.
  • Browse the item tree of any QGraphicsView scene.
  • Show a live preview of QGraphicsView items, including showing their coordinate system, transformation origin, rotate/zoom/pan, etc.
  • Intercept translations and change them at runtime.
  • Inspect all building blocks of a QStyle.
  • Show all QTimers and their statistics (number of wakeups, wakeup time, ...)
  • Browse all QTextDocuments, along with the ability to edit them and view their internal structures.
  • Act as a complete java script debugger, attachable to any QScriptEngine (including the usually not accessible one used by QtQuick1 internally).
  • Perform HTML/CSS/DOM/JS introspection/editing/profiling on any QWebPage, thanks to QWebInspector.
  • Browse the QResource tree and its content.
  • Show all registered meta types.
  • Show all installed fonts.
  • Show all available codecs.

Building GammaRay

See installation notes

Contact

Stay up-to-date with KDAB product announcements:

Get Involved

If you want to contribute, please check out: https://github.com/KDAB/GammaRay/wiki/Get-Involved

Please submit your contributions or issue reports from our GitHub space at https://github.com/KDAB/GammaRay.

KDAB will happily accept external contributions; however, all contributions require a signed KDAB Copyright Assignment Agreement.

  • Individual contributors (non-employees) are required to electronically agree to the KDAB CLA using the GitHub cla-assistant hook.

  • Employees, representing their company, must email a completed and signed KDAB Copyright Assignment Agreement to info@kdab.com.

This is needed so we can continue to dual-license GammaRay. Contact info@kdab.com for more information.

Thanks to our contributors.

License

The GammaRay Software is © Klarälvdalens Datakonsult AB (KDAB), and is available under the terms of the GPL version 2 (or any later version, at your option). See GPL-2.0-or-later.txt for license details.

Contact KDAB at info@kdab.com to inquire about commercial licensing.

For terms of redistribution, refer to the corresponding license agreement.

Note that this software relies on 3rd party MIT-licensed projects and various other freely distributable files some of which are unused only for testing and not part of the application itself.

For convenience, GammaRay source bundles (.tar.gz or .zip files) contain code for the graphviz library which is licensed according to the Eclipse Public License v1.0.

About KDAB

GammaRay is supported and maintained by Klarälvdalens Datakonsult AB (KDAB).

The KDAB Group is the global No.1 software consultancy for Qt, C++ and OpenGL applications across desktop, embedded and mobile platforms.

The KDAB Group provides consulting and mentoring for developing Qt applications from scratch and in porting from all popular and legacy frameworks to Qt. We continue to help develop parts of Qt and are one of the major contributors to the Qt Project. We can give advanced or standard trainings anywhere around the globe on Qt as well as C++, OpenGL, 3D and more.

If you would like to have a custom plugin for GammaRay to visualize, profile or debug your own specific components or applications, get in touch with us via https://www.kdab.com/contact. KDAB engineers know how to write GammaRay plugins and can be contracted to help you get yours working and improve your development efficiency.

GammaRay and the GammaRay logo are registered trademarks of Klarälvdalens Datakonsult AB in the European Union, the United States and/or other countries. Other product and company names and logos may be trademarks or registered trademarks of their respective companies.