Post History

I haven't developed with Perl or DBUS myself (but I have used GTK), so I can only give an answer in general terms rather than specific details.

In most, if not all, GUI frameworks, the "run" or "main" method is simply a convenience that is used by most apps to hand over control of the main event-handling loop to the framework. If you need more control, you can implement the loop yourself.

As the GLib docs [describe here](https://docs.gtk.org/glib/main-loop.html):


 > Single iterations of a `GMainContext` can be run with `g_main_context_iteration()`. In some cases, more detailed control of exactly how the details of the main loop work is desired, for instance, when integrating the `GMainLoop` with an external main loop. In such cases, you can call the component functions of `g_main_context_iteration()` directly. These functions are `g_main_context_prepare()`, `g_main_context_query()`, `g_main_context_check()` and `g_main_context_dispatch()`.

This is for the GLib C API, but I would assume that any decent-quality language binding would expose these same functions. The GTK functionality is built on top of GLib, and offers [similar functions](https://docs.gtk.org/gtk3/func.main_iteration.html) like `gtk_main_iteration()`.

What this means in practice is that if you need two main loops, such as the GTK + DBUS example you describe, at least one of those loops is going to need to be implemented manually in your code, rather than handed over to a "main" or "run" function.

This could be achieved by:

 1. Writing the entire loop manually, interleaving methods like `gtk_main_iteration()` and whatever DBUS offers as an equivalent, ensuring you handle return values, check for pending events or whatever else is required by the API when handling a main loop yourself.
 2. Using `gtk_main()` to hand over control to GTK, then using either [timeouts](https://docs.gtk.org/glib/func.timeout_add.html) or [idle callbacks](https://docs.gtk.org/glib/func.idle_add.html) to periodically invoke your code to receive DBUS events and iterate the DBUS main loop. This may be slightly easier because you only have to implement _one_ of the main loops manually, although you'll have less control over precisely when your event-handling code gets called.