Hubbry Logo
GTKGTKMain
Open search
GTK
Community hub
GTK
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
GTK
GTK
GTK
View on Wikipedia
from Wikipedia

Original authorsSpencer Kimball, Peter Mattis
DevelopersThe GNOME Project, eXperimental Computing Facility (XCF)
Initial releaseApril 14, 1998; 27 years ago (1998-04-14)
Stable release
4.20.2[1] Edit this on Wikidata / 30 September 2025; 23 days ago (30 September 2025)
Preview release
4.19.2 / June 27, 2025; 3 months ago (2025-06-27)
Repository
Written inC, CSS[2]
Operating systemLinux, Unix-like, macOS, Windows
TypeWidget toolkit
LicenseLGPLv2.1+
Websitegtk.org

GTK (formerly GIMP ToolKit[3] and GTK+[4]) is a free open-source widget toolkit for creating graphical user interfaces (GUIs)[5] targeted at Linux and specifically GNOME (though with some use in other desktop environments). It is licensed under the terms of the GNU LGPL, allowing both free and proprietary software to use it.[6]

The GTK team releases new versions on a regular basis.[7] GTK 4 and GTK 3 are actively maintained, while GTK 2 is no longer supported.[8] GTK 1 is independently maintained by the CinePaint project.[9]

Software architecture

[edit]
The GTK toolkit
Simplified software architecture of GTK. Pango, GDK, ATK, GIO, Cairo and GLib
GDK contains back-ends to X11, Wayland, Broadway (HTTP), Quartz, and GDI and relies on Cairo for the rendering. Its new SceneGraph is work-in-progress.

The GTK library contains a set of graphical control elements (widgets); version 3.22.16 contains 186 active and 36 deprecated widgets.[10] GTK is an object-oriented widget toolkit written in the programming language C; it uses GObject (that is, the GLib object system) for object orientation. While GTK is mainly used with windowing systems based on Wayland (and prior to that on Wayland's predecessor X11), it works on other platforms, including Microsoft Windows (interfaced with the Windows API), and macOS (interfaced with Quartz). There is also an HTML5 back-end named Broadway, although this was deprecated in 2025 with the X11 backend to indicate both would be removed in GTK version 5.[11][12][13] GTK uses Vulkan or GL to draw most graphical elements.[14]

GTK can be configured to change the look of the widgets drawn; this is done using different display engines. Several display engines exist which try to emulate the look of the native widgets on the platform in use.

GTK Drawing Kit (GDK)

[edit]
Main article: GDK

GDK acts as a wrapper around the low-level functions provided by the underlying windowing and graphics systems.

GTK Scene Graph Kit (GSK)

[edit]
Main article: GTK Scene Graph Kit

GSK is the rendering and scene graph API for GTK. GSK lies between the graphical control elements (widgets) and the rendering. GSK was finally merged into GTK version 3.90 released March 2017.

GtkBuilder

[edit]

GtkBuilder allows user interfaces to be designed without writing code. The interface is described in an Extensible Markup Language (XML) file which is written by hand or generated by a GUI designer, which is then loaded at runtime and the objects created automatically. The description of the user interface is independent from the programming language being used.

Language bindings

[edit]
Main article: List of language bindings for GTK

Language bindings are available for using GTK from languages other than C, including C++, Genie, JavaScript, Perl, Python, Vala, and others.[15]

Backends

[edit]

GTK supports various backends, which provides different ways to display GTK applications depending on the system and environment. Examples of GTK backends are:

  • Wayland – Used with the Wayland display server on Linux systems, it is a modern replacement for X11.
  • X11 – The default on Linux systems using the X.Org display server.
  • Win32 – For running GTK applications on Windows.
  • Quartz – For macOS support.
  • Broadway – Allows GTK applications to run in web browsers using HTML5 and WebSocket.[11][12]

Development tools

[edit]

GUI designers

[edit]
A screenshot of Cambalache Interface Designer

There are several GUI designers for GTK. Here is a selection of GTK GUI designers:

GTK Inspector

[edit]
A screenshot of the GTK Inspector

The GTK Inspector is a built-in interactive debugging tool in GTK, allowing developers to inspect and modify UI elements, test CSS changes, and analyze widget structure in real time. It can be enabled using the Control + Shift + I or Control + Shift + D shortcuts, or by setting the GTK_DEBUG=interactive environment variable.[20] It was introduced with GTK version 3.14.[21][22]

Features

[edit]
  • Interactive debugging
  • Real-time CSS testing and modifications
  • Widget magnification for detailed inspection
  • UI structure analysis and object property examination
  • Customizable display settings via environment variables
  • Detailed object inspection (type, state, properties, CSS, actions, etc.)
  • Global application information display
  • CSS rule debugging
  • Rendering pipeline recording and inspection

Development

[edit]

GTK is mainly developed by The GNOME Project, which also develops the GNOME Development Platform and the GNOME Desktop Environment.[23] GTK is mainly written in C.[24] Many language bindings are available.

GNOME developers and users gather at an annual GNOME Users And Developers European Conference GUADEC meeting to discuss GNOME's current state and future direction.[25] GNOME incorporates standards and programs from freedesktop.org to better interoperate with other desktops.[citation needed]

Many GNOME applications have been ported to GTK 4, which was released in December 2020,[26] however some still use GTK+ 3 (GIMP being a major one).

Build automation

[edit]

The master branch of GTK utilizes Meson for its build automation. GTK (and GNOME, GLib, etc.) formerly utilized the GNU Build System (named Autotools) as the build automation system of choice. Since August 14, 2017, the Autotools build system files have been dropped.[27]

Criticism

[edit]

The most common criticism of GTK is the lack of backward-compatibility in major updates, most notably in the application programming interface (API)[28] and theming.[29] The result is that application developers or theme developers have to rewrite parts of their code to make it work with a newer version of GTK.

The compatibility breaks between minor releases during the GTK 3.x development cycle was explained in 2013 by Benjamin Otte as due to strong pressures to innovate, such as providing the features modern users expect and supporting the increasingly influential Wayland display server protocol. With the release of GTK 4, the pressure from the need to innovate will have been released and the balance between stability and innovation will tip toward stability.[30] Similarly, recent changes to theming are specifically intended to improve and stabilise that part of the API, meaning some investment now should be rewarded later.[citation needed] However, in 2025, GTK 5 is described in the official documentation as "a major new version of GTK that breaks both API and ABI compared to GTK 4.x.", like GTK 3 and 4.[31][32][33]

  • Aurélien Gâteau started Gwenview as GTK application but switched to Qt early in development.[34]
  • Dirk Hohndel, codeveloper of Subsurface and member of Intel's Open-Source Technology Center, criticized the GTK developers for being abrasive and ignoring most community requests.[35]
  • Hong Jen Yee, the creator of LXDE, expressed disdain for the GTK3 toolkit's radical breaking API changes and increased memory usage, leading him to port the project to Qt, renaming it LXQt.[36]
  • The Audacious music player moved to Qt in version 3.6.[37] The reasons stated by the developers for this include a transition to client-side window decorations, which they claim cause the application to look "GNOME-y and out of place."[38]
  • Wireshark has switched to Qt due to not having a good experience with GTK's cross-platform support.[39]
  • EasyEffects, a popular audio equalizer, is being ported to Qt.[40]

Use

[edit]
GTK's support for Wayland requires applications to be adapted to Wayland as well.
Screenshot of GIMP 2.8 - GTK is responsible for managing the interface components of the program, including the menus, buttons, and input fields.

Applications

[edit]
Main pages: List of GTK applications and Category:Software that uses GTK

Some notable applications that use GTK as a widget toolkit include:

GTK programs can be run on desktop environments based on X11 and Wayland, or others including ones not made with GTK, provided the needed libraries are installed; this includes macOS if X11.app is installed. GTK can be also run on Microsoft Windows. It is used by some popular cross-platform applications like Pidgin and GIMP. wxWidgets, a cross-platform GUI toolkit, uses GTK on Linux by default.[41] Other ports include DirectFB (for example used by the Debian installer).

Desktop environments

[edit]
Main page: Desktop environments based on GTK

Several desktop environments utilize GTK as the widget toolkit.

Current

[edit]

Inactive

[edit]

Window managers

[edit]

The following window managers use GTK:

GtkSourceView

[edit]

For syntax highlighting there is GtkSourceView, "source code editing widget". GtkSourceView is maintained by GNOME separately from GTK as a library: gtksourceview. There are plans to rename to gsv.[citation needed]

GtkSpell

[edit]

GtkSpell is a library separate from GTK. GtkSpell depends on GTK and Enchant. Enchant is a wrapper for ispell, hunspell, etc., the actual spell checker engine/software. GtkSpell uses GTK's GtkTextView widget, to highlight misspelled words and offer replacement.

History

[edit]

GTK was originally designed and used in the GNU Image Manipulation Program (GIMP) as a replacement of the Motif toolkit; at some point Peter Mattis became disenchanted with Motif and began to write his own GUI toolkit named the GIMP toolkit and had successfully replaced Motif by the 0.60 release of GIMP.[42] Finally GTK was re-written to be object-oriented and was renamed GTK+.[43] This was first used in the 0.99 release of GIMP. GTK was subsequently adopted for maintenance by the GNOME Foundation, which uses it in the GNOME desktop environment.

GTK 2

[edit]

The GTK 2.0.0 release (2002[44]) series introduced new features which include improved text rendering using Pango, a new theme engine, improved accessibility using the Accessibility Toolkit, transition to Unicode using UTF-8 strings, and a more flexible API. Starting with version 2.8, released in 2005, GTK 2 depends on the Cairo graphics library for rendering vector graphics.[45]

GTK 3

[edit]

GTK version 3.0.0 (2011[46]) included revised input device handling, support for themes written with CSS-like syntax, and the ability to receive information about other opened GTK applications. All rendering was done using Cairo.[47]

The '+' was dropped returning to simply 'GTK' in February 2019 during a Hackathon.[48]

GTK 4

[edit]

Release of the first GTK 4 version was in December 2020. At the 2018 edition of DevConf.cz, Matthias Clasen gave an overview of the then-current state of GTK 4 development, including a high-level explanation of how rendering and input worked in GTK 3, what changes were being made to GTK 4, and the reasons for those changes. Examples of things that have become possible with GTK 4 were given as well.[49]

One of the main changes made during the GTK 4 development cycle (i.e. GTK 3.92, etc.) was the removal of user customization options (like individual keyboard shortcuts that could be set in GTK+ 2), and the delegation of functionality to ancillary objects instead of encoding it into the base classes provided by GTK. Other changes include:

  • Event handling from signal handlers described by GtkWidget is delegated to event controllers.
  • Rendering is delegated to GtkSnapshot objects.
  • The layout mechanism is delegated from GtkWidget to GtkLayoutManager.
  • Cairo was de-emphasized and Vulkan or GL were used instead to draw most graphical elements.[14]

Releases

[edit]
Release series Initial release Major enhancements Latest minor version
Unsupported: 1.0 1998-04-13[50] First stable version 1.0.
Unsupported: 1.2 1999-02-25[51] New widgets:
  • GtkFontSelector
  • GtkPacker
  • GtkItemFactory
  • GtkCTree
  • GtkInvisible
  • GtkCalendar
  • GtkLayout
  • GtkPlug
  • GtkSocket
 1.2.10
Unsupported: 2.0 2002-03-11[52] GObject

Overall support for UTF-8

2.0.9
Unsupported: 2.2 2002-12-22[53] Multihead support 2.2.4
Unsupported: 2.4 2004-03-16[54] New widgets:
  • GtkFileChooser
  • GtkComboBox
  • GtkComboBoxEntry
  • GtkExpander
  • GtkFontButton
  • GtkColorButton
 2.4.14
Unsupported: 2.6 2004-12-16[55] New widgets:
  • GtkIconView
  • GtkAboutDialog
  • GtkCellView

The last to support Windows 98/Me

2.6.10
Unsupported: 2.8 2005-08-13[56] Most widgets are rendered by Cairo 2.8.20
Unsupported: 2.10 2006-07-03[57] New widgets:
  • GtkStatusIcon
  • GtkAssistant
  • GtkLinkButton
  • GtkRecentChooser

Print support: GtkPrintOperation

2.10.14
Unsupported: 2.12 2007-09-14[58] GtkBuilder 2.12.12
Unsupported: 2.14 2008-09-04[59] JPEG 2000 load support 2.14.7
Unsupported: 2.16 2009-03-13[60] New widget: GtkOrientable

Caps Lock warning in password entry

Improvements on GtkScale, GtkStatusIcon, GtkFileChooser

2.16.6
Unsupported: 2.18 2009-09-23[61] New widget: GtkInfoBar

Improvement on file chooser, printing

To remove much of the necessary IPC between the X11 application and the X11 server, GDK is rewritten (mainly by Alexander Larsson) to use "client-side windows", i.e., the GdkWindow, which every widget must have, belongs now to the client

2.18.9
Unsupported: 2.20 2010-03-23[62] New widgets:
  • GtkSpinner
  • GtkToolPalette
  • GtkOffscreenWindow

Improvement on file chooser, keyboard handling, GDK

Introspection data is now included in GTK

2.20.1
Unsupported: 2.22 2010-09-23[63] GdkPixbuf moved to separate module

Most GDK drawing are based on Cairo

Many internal data are now private and can be sealed in preparation to GTK 3

2.22.1
Unsupported: 2.24 2011-01-30[64] New widget: GtkComboBoxText which had previously been a custom widget shipped with Gtkmm

The CUPS print backend can send print jobs as PDF

GtkBuilder has gained support for text tags and menu toolbuttons and many introspection annotation fixes were added

Migrating from GTK+ 2.x to GTK+ 3

2.24.33
(2020-12-21)[65]
Unsupported: 3.0 2011-02-10[66] Development and design of the GTK 3 release of the toolkit started in February 2009 during the GTK Theming Hackfest held in Dublin[67]
  • The first draft of the development roadmap was released on April 9, 2009[68]

Completed mostly Project Ridley

  • the attempt to consolidate several libraries that were external to GTK+
  • including libgnome, libgnomeui, libgnomeprint22, libgnomeprintui22, libglade, libgnomecanvas, libegg, libeel, gtkglext, and libsexy[69]

All the rendering is done using Cairo

GDK became more X11 agnostic

XInput2, theme API is based on Cascading Style Sheets (CSS), worsening the achievable performance for 60 Hz frame rates

3.0.12
Unsupported: 3.2 2011-09-25[70] New widgets:
  • GtkLockButton
  • GtkOverlay

New Font Chooser dialog

New experimental backends:

3.2.4
Unsupported: 3.4 2012-03-26[71] Menu support in GtkApplication

A new color chooser

Added support for touch devices

Added support for smooth scrolling

GtkScrolledWindow will do kinetic scrolling with touch devices

macOS support is improved

This is the first version of GTK 3 that works well on Windows

The Wayland backend is updated to the current Wayland version

Spin buttons have received a new look

Accessibility: the treeview accessible support is rewritten

More complete CSS theming support

3.4.4
Unsupported: 3.6 2012-09-24[72] New widgets:
  • GtkSearchEntry
  • GtkMenuButton
  • GtkLevelBar

Vertical spin buttons

CSS animations, blur shadows

Support for cross-fading and transitions in themes

3.6.5
Unsupported: 3.8 2013-03-25[73] Wayland 1.0 stable support

Support for the broadwayd server

Improved theming

Better geometry management

Touch improvements

Support with the window manager for the frame synchronization protocol

GdkFrameClock added[74]

3.8.9
Unsupported: 3.10 2013-09-23[75] New widgets:
  • GtkHeaderBar
  • GtkPlacesSidebar
  • GtkStack
  • GtkStackSwitcher
  • GtkRevealer
  • GtkSearchBar
  • GtkListBox

Support for Wayland 1.2

  • maximization
  • animated cursors
  • multiple monitors
  • settings
  • custom surfaces
  • frame synchronization

Added:

  • client-side decorations
  • scaled output support on high-dpi screens
  • fine-adjustment mode for scrolling

Removed:

  • support for the Motif DND protocol
  • support for multiple screens per display
  • gdk_window_get_display
  • gtk_widget_push_composite_child

Tear-off menu-items, plus many GTK settings

The modern GTK drawing model

3.10.9
Unsupported: 3.12 2014-03-25[76] Client-side decorations[77]

Support for Wayland 1.5

New widget: GtkPopover (an alternative to menus and dialogs)

3.12.2
Unsupported: 3.14 2014-09-22[78] GtkInspector (a copy of gtkparasite) introduced[79][80]

Improved support for gestures/multi-touch merged[81][82]

Deprecated:[83]

  • GtkMisc
  • GtkAlignment
  • GtkArrow
  • GdkColor
  • Style regions
  • support for .icon files
  • gdk_window_flush
  • drawing outside of begin/end paint

Most widgets converted to use gestures internally

Wayland supports GNOME Shell classic mode[84]

3.14.15
Unsupported: 3.16 2015-03-22[85] GDK supports rendering windows using OpenGL for X11 and Wayland using libepoxy

New widgets:

  • GtkGLArea
  • GtkStackSidebar
  • GtkModelButton
  • GtkPopoverMenu

Scrolling overhauled (scrollbar hidden by default[86])

Experimental Mir backend[87]

3.16.7
Unsupported: 3.18 2015-09-23[88] Add CSS node infrastructure

More filechooser design refresh and better filechooser search

Dropped Windows XP support

Model support for list and flow box

Kinetic touchpad scrolling

Touchpad gestures (Wayland)

gtk-builder-tool utility

Output-only windows

3.18.9
Unsupported: 3.20 2016-03-21[89] Further Integration of CSS nodes[90]

Move drag and drop down to GDK

New widget: GtkShortcutsWindow (shows keyboard shortcuts and gestures of an application)

3.20.10
Unsupported: 3.22 2016-09-21[91] Last 3.x release[92]

Wayland tablet support is merged,[93] support for graphics tablets is considered feature complete[94]

GTK 3.22 shall be as rock-stable (and hence "boring") as GTK 2[30][95][96]

for 3+ years
3.22.29
Supported: 3.24 2018-09-03[97] 3.22 was supposed to be the last version of GTK 3 series
  • 3.24 was mainly released to ease migrating from GTK+ 3.x to GTK+ 4

Dependency bumps – require:

  • libepoxy 1.4
  • pango 1.41

New font chooser features:

  • allow setting OpenType font features
  • show examples for OpenType font features
  • allow selecting OpenType font variations
  • support levels of details for selection

New Emoji features:

  • support a completion popup for Emoji
  • drop Ctrl-Shift-e shortcut

Other new APIs: gdk_window_move_to_rect

Wayland: use anonymous shared memory on FreeBSD

Backported event controllers from GTK 4:

  • GtkEventControllerScroll
  • GtkEventControllerMotion
  • GtkEventControllerKey
  • GtkGestureStylus

Deprecate a few APIs that are gone in GTK 4:

  • focus chains in GtkContainer
  • stepper sensitivity in GtkRange
 3.23.0
3.23.1
3.23.2
3.23.3
3.24.0
...3.24.5
3.24.14
...

3.24.51

Unsupported: 3.90 2017-03-31[98] GTK Scene Graph Kit (GSK) merged[7]

Remove any API marked as deprecated

Heavy development

A new Vulkan-renderer augments the old Cairo-renderer[99]

3.89.1

3.89.2
3.89.4
3.89.5
3.90

Unsupported: 3.92 2017-10-18[100][101] As GNOME 3.26 was released already on September 13, 2017,[102] it was not based on GTK 3.92.

GNU autotools was replaced with Meson.

3.91.0

3.91.1
3.91.2
3.92.1

Unsupported: 3.94 2018-06-26[103] 3.93
  • GdkScreen, GdkVisual removed
  • GdkDeviceManager replaced by GdkSeat
  • Clipboard handling is moved from GTK to GDK
  • GdkEvent is converted to an opaque GObject
  • the GL renderer in GSK is substantially completed, and is now on par with the Vulkan renderer
  • the use of GdkPixbuf in APIs is reduced
    • and the GskTexture object is moved to GDK as GdkTexture, to take its place
  • the Wayland backend now implements the KDE server-side decoration protocol
  • Broadway is ported to GSK.

GdkWindow renamed to GdkSurface

New abstraction for drawable content: GdkPaintable

There is support for displaying media with:

  • GtkVideo
  • GtkMediaFile
  • GtkMediaStream
  • GtkMediaControls
 3.93
3.94.0
Unsupported: 3.96 2019-05-07[104] The gtk4-builder-tool simplify command has gained a --3to4 option to convert GTK3 ui files to GTK4; though with AMTK menus, toolbars or other objects like GtkShortcutsWindow are created programmatically (not with a *.ui file), but with convenient APIs.[105]

GtkWidget can now use a GtkLayoutManager for size allocation

  • layout managers can optionally use layout children holding layout properties
  • GtkBinLayout, GtkBoxLayout, GtkGridLayout, GtkFixedLayout and GtkCustomLayout are currently available
  • more layout manager implementations will appear in the future

Focus handling has been rewritten, and focus-change event generation has been unified with crossing events

Events have been simplified and are just used for input:

  • expose events have been replaced by a GdkSurface::render signal
  • configure events have been replaced by a GdkSurface::size-changed signal
  • map events have been replaced by a GdkSurface::mapped property
  • gdk_event_handler_set has been replaced by a GdkSurface::event signal
  • key events no longer contain a string
  • events on unmapped widgets are ignored
 3.93
3.94.0
Unsupported: 3.98 2020-02-10[104]
  • Performance improvements
  • Drag and drop refactoring
  • Moving GDK towards Wayland
  • Removals
    • GtkMenu, GtkToolbar and similar classes have been replaced by GMenu.
  • Additions
    • Emoji chooser
    • Text widgets now have undo stacks
    • A new layout manager[106]
 3.96.0
Unsupported: 3.99.0 2020-07-31[107]
  • Introduced successor to Accessibility Toolkit (ATK).[108] The new approach will implement WAI-ARIA (World Wide Web Consortium (W3C) Accessibility Initiative – Accessible Rich Internet Applications).
  • Updated headers to use standard C types instead of GLib types
  • New widgets
  • Fixes and improvements[107]
 3.99.4
Unsupported: 4.0 2020-12-16[109] 4.0.3
Unsupported: 4.2 2021-03-30[110] 4.2.1
Unsupported: 4.4 2021-08-23[111] 4.4.1
Unsupported: 4.6 2021-12-30[112] 4.6.9
Unsupported: 4.8 2022-09-06[113] 4.8.3
Unsupported: 4.10 2023-03-04[114] GtkFileChooser deprecated (use GtkFileDialog)[115] 4.10.5
Unsupported: 4.12 2023-08-05[116] 4.12.5
Unsupported: 4.14 2024-03-12[117] 4.14.6
Unsupported: 4.16 2024-06-09[118] 4.16.12
Unsupported: 4.18 2025-03-14[119] 4.18.6
Unsupported: 4.19 2025-04-06[120] 4.19.4
Unsupported: 4.20 2025-08-29[121] 4.20.2
Unsupported: 4.21 2025-09-29[122] 4.21.0
Legend:
Unsupported
Supported
Latest version
Preview version
Future version

See also

[edit]

References

[edit]

Bibliography

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

GTK

View on Grokipedia
from Grokipedia
GTK is a free and open-source cross-platform for creating graphical user interfaces (GUIs). Originally developed in 1996 as the GIMP to support the program, it evolved into an independent project licensed under the GNU Lesser (LGPL). Written primarily in with an object-oriented architecture via the system, GTK provides a comprehensive set of UI elements—including buttons, windows, text views, and toolbars—enabling developers to build applications ranging from simple utilities to full-featured suites. It supports multiple programming languages through bindings for C++, Python, , , and others, and runs on , Windows, macOS, and other systems. The toolkit's history reflects its growth alongside ecosystems. GTK 1.0 was released in April 1998, providing basic widgets essential for GIMP and early adopters. Major advancements came with GTK 2.0 in March 2002, which introduced the text layout engine and a model-view architecture for complex data displays, expanding its codebase to over 460,000 lines. GTK 3.0, launched in February 2011, focused on themeability and CSS-based styling to modernize appearances. The current stable branch, GTK 4.0 (released December 16, 2020), emphasizes hardware-accelerated rendering via (for windowing abstractions) and GSK (a ), along with improved accessibility and performance for contemporary displays and input methods. As of November 2025, the latest stable release is 4.21.1, with ongoing development toward version 5. GTK's architecture relies on key dependencies for functionality: GLib for utility functions and data structures, for 2D rendering, for internationalized text handling, and for platform-specific drawing and event handling. It supports multiple backends, including X11, Wayland, and BroadWay for web-based interfaces, ensuring portability. As the core of the desktop environment, GTK powers essential applications like the GNOME Shell, file manager, and Gedit text editor, while also underpinning creative tools such as and , and even cross-toolkit integrations in browsers like . Maintained by the project and a global community of over 250 contributors, GTK continues to evolve with emphases on efficiency, modern APIs, and practices.

Introduction

Definition and purpose

GTK is a free and open-source multi-platform designed for creating graphical user interfaces (GUIs). Originally developed as the GIMP Toolkit for the (), it has evolved into a versatile framework used across various applications. The primary purpose of GTK is to supply developers with a comprehensive collection of widgets—such as buttons, windows, and containers—along with drawing primitives via tools like and event handling through an event-driven signal system. This enables the construction of responsive user interfaces for desktop applications, making it particularly suitable for environments like , where it serves as the core UI foundation. Key features of GTK include robust cross-platform compatibility across , Windows, and macOS, allowing applications to maintain a native via theme support, including CSS-based customization. It also integrates standards through the GtkAccessible interface, ensuring support for assistive technologies and diverse user needs. In distinction from many similar toolkits, GTK emphasizes a C-based augmented by the system for , facilitating efficient and extensible GUI development.

Licensing and development

GTK is licensed under the GNU Lesser General Public License (LGPL) version 2.1 or later, which permits its use in both free and proprietary software applications through dynamic linking without requiring the disclosure of for the linking application. This licensing choice facilitates widespread adoption by allowing developers to integrate GTK into closed-source projects while ensuring the toolkit itself remains freely modifiable and redistributable. Development of GTK is primarily led by the GNOME project, a community-driven initiative focused on creating free desktop environments and applications. Contributions come from a diverse group of volunteers, alongside significant input from companies such as and , whose engineers dedicate time to enhancing the toolkit's features and performance. For instance, has been a leading corporate contributor to GNOME-related projects, including GTK, by employing developers who commit code and participate in upstream improvements. Governance of GTK development is decentralized and community-oriented, with key decisions made by the GTK maintainers and the broader community through discussions and collaboration. Release cycles are coordinated via the project's repository, where merge requests, issue tracking, and versioning follow a structured process to ensure stable and timely updates. Community participation occurs primarily through public mailing lists, such as the GTK development list for discussions and feedback, and in-person or virtual hackfests that facilitate collaborative coding sessions and planning. Funding for GTK development is sustained by Foundation, a non-profit that receives sponsorships from entities committed to , including corporate memberships and donations without any single entity holding ownership. These resources support developer stipends, infrastructure, and events, enabling ongoing maintenance and innovation in the toolkit.

History

Origins and early versions

GTK originated in the mid-1990s as part of the development of the , an open-source image editing application created by university students Spencer Kimball and at the . Initially, GIMP relied on the Motif widget toolkit, but its restrictive licensing and limitations for plugin development prompted Mattis to develop a custom alternative. This new toolkit, initially named the GIMP Tool Kit (GTK) and comprising the GIMP Drawing Kit (GDK) for low-level graphics, was designed specifically for GIMP's needs and emphasized a approach compatible with project. Development began around 1996 during the GIMP 0.60 series, with the toolkit evolving significantly by early 1997. The first stable release of GTK 1.0 arrived on April 13, 1998, marking the toolkit's maturation after two years of iterative improvements driven by GIMP's requirements. Spanning from its initial versions in 1997 through to 2002, the GTK 1 era introduced a core set of widgets including buttons, menus, windows, and specialized elements like rulers and color selectors tailored for image manipulation. It adopted an model, where applications responded to user interactions via callbacks, and relied on an X11 backend through for rendering and window management on systems, ensuring inherited from X11. Licensed under the GNU Lesser General Public License (LGPL) from its inception, GTK enabled both open-source and proprietary applications to link against it without requiring full source disclosure. Key innovations in GTK 1 included a lightweight C-based object system that supported through macros, allowing developers to derive custom widgets from base classes, and a signals mechanism for event handling that functioned similarly to slots in other frameworks, enabling flexible connections between UI events and application logic. This signals system broadcasted notifications for actions like button clicks or window resizes, promoting modular and extensible code without deep dependencies on the underlying . These features provided a foundation for rapid GUI prototyping , prioritizing simplicity and performance on resource-constrained 1990s hardware. Early adoption of GTK centered on open-source projects, with GIMP serving as its primary user and ongoing driver for enhancements until the toolkit's separation into an independent project in 1997. desktop environment, founded on August 15, 1997, by and Federico Mena, quickly embraced GTK 1 as its foundational widget library, using it to build a complete alternative to proprietary desktops like . This integration propelled GTK's use in early Unix desktop applications, fostering a community around lightweight, customizable interfaces.

GTK 2 era

The GTK+ 2.0 release on March 11, 2002, marked a significant milestone as a major rewrite of the toolkit, introducing foundational improvements for modern graphical user interfaces. This version integrated for advanced text layout and rendering, enabling comprehensive support and enhanced internationalization across all widgets. Additionally, it featured new widgets such as GtkTextView for rich text , GtkTreeView for hierarchical display, and for handling, alongside simplified APIs for common UI elements like dialogs and progress bars. Theming capabilities were bolstered with support for themeable stock icons and images in toolbars and menus, allowing greater customization of visual appearance. Subsequent updates in the GTK+ 2 series further refined rendering and accessibility. Cairo was integrated starting with version 2.8 in August 2005, providing a vector graphics library that handled anti-aliased fonts, double buffering, and high-quality 2D rendering, replacing older GDK drawing primitives. Accessibility support was enabled through the ATK library, which allowed GTK+ widgets to implement interfaces for screen readers and other assistive technologies, ensuring compliance with GNOME's accessibility standards from the outset. Multi-head display handling was added in GTK+ 2.2 (December 2002), supporting multiple X servers, Xinerama configurations, and seamless window migration across screens. GTK+ 2 achieved widespread adoption as the core toolkit for 2.x desktop environment, released alongside it in 2002, and powered numerous applications including the Gedit and media player. Its stability and incremental enhancements sustained active development through multiple point releases, with the final version, 2.24.0, arriving in January 2011. This era emphasized reliability, making GTK+ 2 the dominant choice for Linux desktop applications until the shift toward GTK+ 3. To facilitate adoption, GTK+ 2 maintained with GTK+ 1.x through compatibility headers and wrappers, allowing much existing code to compile and run with minimal changes despite API evolutions. Projects like 's gtk1-compat provided additional shims for legacy applications, easing the transition for developers reliant on older versions.

GTK 3 transition

The GTK+ 3.0 release occurred on February 10, 2011, representing a major redesign from GTK 2 with the removal of numerous deprecated features, including the X11-specific drawing , graphics contexts (GCs), colormaps, and pixmaps, in favor of exclusive Cairo-based rendering for improved consistency and performance. This shift emphasized modern through Cairo's capabilities, which leverage and other backends where supported to enhance rendering efficiency on contemporary systems. Additionally, the release introduced a comprehensive theming overhaul using a CSS-like syntax, allowing developers to define styles, layouts, and animated state transitions more flexibly and expressively than the previous engine. Major architectural changes in GTK 3 included a complete rework of input handling to align with the X Input Extension version 2 (XI2), providing stricter and more precise management of events from multiple pointers, keyboards, and input devices, which replaced the looser GTK 2 model and required applications to adapt to new event propagation rules. For animations, the CSS theming system natively supported transitions, while integration with Clutter via the Clutter-GTK library enabled embedding advanced graphical effects and scene graphs in GTK applications, though Clutter itself entered deep maintenance mode and was deprecated by 2022. HiDPI support was further bolstered starting with GTK 3.10 in September 2013, introducing scaled output modes to handle high-resolution displays by applying device pixel ratios, ensuring crisp rendering without manual developer intervention in many cases. The transition to GTK 3 presented significant adoption challenges due to deliberate API and ABI breaks from GTK 2, necessitating code porting for features like drawing, event handling, and theming, which caused migration difficulties for legacy applications and led to prolonged dual-support periods in Linux distributions such as and , where both versions coexisted in repositories for several years to ease the shift. These breaks, while enabling cleaner , resulted in compatibility layers and shims being developed by some projects, slowing widespread uptake until around 2015-2017 as distributions prioritized GTK 3 for new software. GTK 3 remained stable and actively maintained through incremental releases up to version 3.24 in 2019, with maintenance releases continuing as of 2025 (latest 3.24.51), receiving security updates and minor enhancements, though GTK 4 is the primary development target.

GTK 4 and beyond

GTK 4.0 was released on December 16, 2020, marking a significant evolution in the toolkit's design with the introduction of the Graphene Scene Kit (GSK) for declarative rendering, which enables more efficient custom drawing through render nodes. This release also incorporated stable, non-deprecated media playback APIs via the GtkMediaControls widget, supporting formats like video and audio without reliance on external plugins. Additionally, GTK 4.0 emphasized explicit state management for widgets, utilizing event controllers to handle input and gestures in a more modular and predictable manner, reducing implicit behaviors from prior versions. Following the initial release, GTK 4 saw iterative enhancements, particularly in Wayland integration, with improvements to fractional scaling and monitor handling starting in version 4.14, released in March 2024 as part of 46. This version set the NGL (new ) renderer as the default, providing better support for high-DPI displays and zero-copy video playback through dmabuf textures. By GTK 4.18, released in early 2025, the legacy renderer was fully removed to streamline maintenance on modern hardware, alongside further Wayland optimizations like refined pointer scaling to eliminate oversized cursors on fractional displays. received a major boost in 4.18 with the addition of an AccessKit backend, enabling cross-platform support for screen readers on Windows and macOS for the first time, built with the -Daccesskit=enabled option and activated via the GTK_A11Y=accesskit environment variable. Subsequent releases include 4.20 in August 2025 with enhanced Wayland support and rendering improvements, and 4.21 in October 2025 introducing GtkSvg for animated support. GTK maintains a bi-annual cadence for stable minor releases, typically aligning with GNOME's cycle—such as 4.14 in spring 2024 and 4.18 in spring 2025—with odd-numbered minors (e.g., 4.13, 4.17) serving as development snapshots for testing upcoming features. As of November 2025, groundwork for GTK 5 focuses on backend unification, prioritizing Wayland as the primary display server while deprecating X11 and Broadway backends for removal in the next major version, alongside performance optimizations in rendering and media handling. No firm release date has been announced, emphasizing stability in the GTK 4 series before transitioning.

Software Architecture

Core libraries (GDK and GSK)

, standing for GIMP Drawing Kit, serves as the low-level windowing abstraction layer in GTK, providing a unified that shields applications from platform-specific details of window management, event handling, and input processing. It supports multiple backends, including X11 via GdkX11, Wayland via GdkWayland, Win32 for Windows, and for macOS, allowing seamless portability across systems, Windows, and Apple platforms. Core components encompass GdkSurface objects, which represent drawable areas for content rendering, and event mechanisms that capture user inputs such as keyboard presses, movements, and touch gestures, along with system events like window resizes or focus changes. This abstraction enables developers to write cross-platform code without direct interaction with underlying APIs like Xlib, Wayland protocols, or Win32 GDI. The pluggable backend architecture of has evolved to enhance flexibility, permitting runtime selection or switching of implementations based on the environment, which was refined in GTK 4 to better support modern compositors and high-DPI displays. For instance, 's input device model, through classes like GdkDevice, categorizes peripherals into logical seats for multi-user scenarios, ensuring accurate event routing in complex setups. Additionally, integrates with graphics contexts, such as GdkGLContext, to facilitate hardware-accelerated drawing while maintaining portability. GSK, or GTK Scene Graph Kit, forms the rendering abstraction introduced in GTK 4, designed to efficiently process and draw the widget hierarchy using a paradigm. It transforms GTK's widget tree into a graph of render nodes—such as containers, blends, and transforms—that can be optimized and rendered via GPU pipelines supporting or , thereby achieving hardware acceleration for complex UIs. This node-based structure allows for advanced operations like invisible elements and batching draw calls, significantly improving performance over CPU-based rendering in prior versions. GSK depends on libraries like for vector mathematics to handle 2D transformations and projections accurately. The interplay between GDK and GSK establishes a clear division: GDK delivers the foundational surfaces and event infrastructure, upon which GSK constructs and renders content, enabling capabilities such as offscreen rendering for print/export and fluid animations through synchronized frame timing. In GTK 4, GSK supplants the legacy renderer, deprecating direct GL areas for standard widget drawing in favor of a unified that integrates with GDK's paintables for extensible content like icons or textures. This evolution promotes scalability, with serving as the default renderer on Wayland since GTK 4.16 for reduced latency and better resource utilization.

UI construction tools (GtkBuilder)

GtkBuilder is a class in the GTK toolkit that serves as an XML parser for constructing widget hierarchies and other objects at runtime. It reads textual descriptions of user interfaces defined in XML format, instantiating GTK widgets, windows, and supporting GObject-based classes while managing their references until finalization. The XML structure typically begins with an <interface> root element, which can include a translation domain attribute, followed by <requires> tags specifying the GTK version and <object> elements defining widgets with unique IDs, properties, signals, and child relationships. GtkBuilder supports setting properties of various types, such as strings, enums, and colors, through <property> tags, and connects signals to handlers via <signal> elements that allow attributes like after, swapped, or object for flexible event handling; custom handlers are implemented in application code and linked by name. In usage, GtkBuilder loads UI description files, commonly with a .ui extension generated by , enabling developers to separate interface definitions from for and easier . It facilitates by marking translatable strings in properties with translatable="yes" and optional context or comments attributes, integrating with via dgettext() for domain-specific translations. Developers instantiate a GtkBuilder object using functions like gtk_builder_new_from_file() or gtk_builder_new_from_string(), retrieve objects by ID with gtk_builder_get_object(), and manually destroy top-level windows to release resources; multiple UI sources can be added dynamically with gtk_builder_add_from_file() or exposed objects via gtk_builder_expose_object(). One key advantage of GtkBuilder is its ability to reduce in applications by declaratively defining complex UIs, avoiding manual widget creation and setup in programming languages. It supports dynamic modifications, such as adding constraints or bindings post-construction, and integrates seamlessly with Introspection for automatic type resolution using get_type() heuristics or explicit type-func attributes in XML, enhancing portability across language bindings. Property bindings are also supported through <binding> elements that create GBinding instances between objects, allowing reactive UI updates without custom code. In older GTK versions, such as GTK 3, GtkBuilder was limited to traditional layout managers like boxes and grids, requiring nested structures for complex arrangements and lacking native support for relational positioning. GtkBuilder evolved significantly in GTK 4, incorporating support for constraint-based layouts via the GtkConstraintLayout class, which implements the GtkBuildable interface and uses custom <constraints> elements in XML to define widget relationships through GtkConstraint objects, including targets, sources, relations, and strengths; this enables more flexible, equation-based UI designs similar to Visual Format Language, reducing nesting and improving scalability for modern interfaces.

Language bindings and portability

GTK is primarily implemented in the C programming language, leveraging the type system to provide object-oriented features such as , signals, and properties, which facilitate structured application development. This native serves as the foundation for GTK's core functionality, including widget management and event handling. To extend GTK's usability beyond C, language bindings are generated using , a middleware layer that exposes the C through metadata in XML or binary formats, enabling dynamic access from higher-level languages without manual wrapping. This approach ensures that bindings remain closely aligned with the underlying C implementation, supporting features like and signal emission across languages. Prominent bindings include PyGObject for Python, which integrates GTK with Python's ecosystem for rapid prototyping and scripting, as seen in tools like GNOME's Software Center. GJS provides support, powering extensions and applications with asynchronous capabilities suited for dynamic UIs. The gtk-rs project offers safe, idiomatic bindings, emphasizing and performance for systems-level applications. Vala, a GNOME-specific , compiles to C and uses native bindings for efficient development of GTK-based apps like GNOME's core utilities. Legacy bindings such as GTK2-Perl enable integration for older GTK 2.x and 3.x projects but require updates for newer versions. GTK ensures portability across operating systems including , Windows, and macOS through abstract layers like for windowing and input handling, allowing applications to compile and run with minimal platform-specific adjustments. Compile-time configuration via build systems like adapts to target environments, while runtime detection handles variations in graphics drivers and themes. ABI stability is maintained within long-term stable series of major versions—for instance, GTK 3.22 and GTK 4.x releases promise no ABI breaks during their support lifecycle of at least three years, enabling reliable binary compatibility for bindings and applications. However, transitions between major versions, such as from GTK 3 to 4, introduce deliberate ABI breaks to remove deprecated elements and refactor internals, necessitating binding updates. Maintaining bindings poses challenges, particularly in synchronizing with GTK's evolving , where changes to opaque structures or event systems can disrupt data and require regeneration of wrappers. Ensuring signal compatibility remains critical, as signals underpin ; mismatches in parameter types or emission semantics across versions can lead to runtime errors in bound languages, demanding rigorous testing and version-specific forks. Emerging efforts, such as the ongoing and port of GTK 4, aim to extend portability to browser environments, with pre-alpha demos demonstrating widget rendering at over 200 frames per second, though full ecosystem integration is incomplete. Additionally, the Broadway backend supports HTML5-based rendering for web deployment, further broadening cross-platform reach.

Rendering backends

GTK's rendering backends are implemented within the GDK library, which provides a platform-agnostic for low-level graphics operations across various display systems. These backends adapt GTK applications to specific windowing systems, enabling cross-platform compatibility while handling native interactions. The primary active backends in GTK 4 include Wayland for modern compositors, X11 as a legacy option for systems, Broadway for HTML5-based remote rendering in web browsers, Win32 for Windows environments, and for macOS integration. An experimental Android backend was introduced in GTK 4.18 for mobile platform support. Legacy backends such as , designed for embedded systems without a full windowing stack, were supported up to GTK 2 but removed in GTK 3 due to lack of maintenance. Similarly, the Mir backend, introduced in GTK 3.16 for Ubuntu's Mir display server, was dropped in GTK 4 as Mir adoption declined. The evolution of GTK's rendering backends reflects a strategic shift from X11 dominance to prioritizing Wayland as the default protocol in GTK 4, aligning with broader desktop trends toward modern, secure compositing. In early versions, X11 was the sole focus, but multi-backend support emerged to accommodate diverse platforms; by GTK 4, Wayland became the preferred backend, with X11 and Broadway deprecated in 2025 to signal their planned removal in GTK 5. This deprecation means no new features, such as DMA-BUF support or integration, will be added to X11, emphasizing resource allocation to Wayland. The renderer, part of the GSK scene graph kit, provides hardware-accelerated rendering across compatible backends, including Wayland, and has been the default on Wayland since GTK 4.16. Functionally, these backends manage core interactions with the underlying display server, including the creation and configuration of surfaces for windows, allocation and submission of buffers for content updates, and coordination with compositors for efficient rendering and input handling. For instance, the Wayland backend uses wl_surface and related protocols to negotiate buffer formats and handle subsurface attachments, while Win32 leverages Windows GDI or DirectComposition APIs for similar tasks on that platform. This abstraction ensures GTK widgets render consistently regardless of the backend, with translating high-level requests into native calls. Backend selection occurs at runtime via the , allowing users or applications to specify preferences like "wayland,x11" to prioritize Wayland and fall back to X11 if needed; the "help" option lists compiled-in backends. Recent developments in GTK 4.18, released in early 2025, have significantly enhanced Wayland support, particularly resolving longstanding issues with fractional scaling by accurately computing pointer sizes and output scales in compositor interactions. These improvements enable smoother handling of non-integer scaling factors, such as 125% or 150%, improving on high-DPI displays without relying on integer approximations that previously caused visual artifacts. The update also includes better drag-and-drop surface management and clipboard stability on Wayland, reinforcing its role as the flagship backend.

Development Practices

Build systems and automation

GTK employs the Meson build system paired with the Ninja backend for compiling both the library itself and applications built upon it, a shift implemented starting with GTK 4 to replace the older Autotools system used in GTK 3. provides a fast, user-friendly configuration process via commands like meson setup, while enables rapid incremental builds, significantly improving development iteration times over Autotools' configure and make workflows. This combination supports multiple build types, including debug for validation during development and release for optimized production use. Key dependencies for building GTK include core libraries such as GLib for foundational utilities, Pango for text layout, for 2D rendering, and ATK for accessibility support, all integrated through to manage compilation flags and library paths via .pc files. Developers set environment variables like PKG_CONFIG_PATH to locate these dependencies, ensuring seamless linkage without manual flag specification; optional components like Wayland protocols or libepoxy for can be enabled during Meson configuration for specific backends. Automation in GTK development leverages pipelines to handle , testing across platforms including (), Windows (via MSYS2 and cross-compilation), macOS (arm64), and even Android. These pipelines execute stages such as preparation, building with and , analysis, and packaging for demo applications, utilizing tools like ccache for accelerated recompilation and for test reporting. For distribution packaging, GTK supports formats like Debian's .deb and Red Hat's .rpm, where Meson-generated builds are adapted into native installers, often via the plain build type to align with distro-specific flags. GTK 4 introduces stricter build requirements compared to prior versions, mandating without Autotools fallbacks and excluding legacy compatibility options like deprecated X11 behaviors, which streamlines the system but requires updated dependency versions and configuration. This ensures a more modern, efficient toolchain while supporting cross-platform portability through explicit backend selections in .

GUI design tools

Glade serves as a builder primarily for GTK 3 applications, enabling developers to create interfaces through a drag-and-drop interface that generates XML files compatible with the GtkBuilder format. This tool facilitates (RAD) by allowing users to visually arrange widgets, such as buttons, labels, and containers, while automatically producing structured XML output that can be loaded at runtime without manual coding of the layout. Glade supports multiple programming languages, including , C++, Python, and Vala, by exporting files that integrate seamlessly with GTK's object system. However, Glade has not been actively maintained since its last stable release, version 3.40.0 in August 2022, and does not officially support GTK 4. Key features of Glade include an intuitive property editor for configuring widget attributes like size, color, and alignment; tools for connecting signals to callbacks, with previews of event handling; and simulation of themes to visualize the interface under different styles before compilation. These capabilities streamline the design process, reducing errors in widget hierarchy and responsiveness. Glade 3.40.0 enhances support for advanced GTK 3 widgets and improves XML validation. Other tools extend functionality through IDE integrations. , the official IDE for applications, incorporates widget templates and a UI file editor that supports drag-and-drop elements alongside for GTK interfaces. Similarly, , a versatile C/C++ IDE, embeds Glade directly, allowing seamless switching between visual design and source code editing within the same environment. A legacy option, gtk-builder-tool, provides command-line utilities for validating and simplifying GtkBuilder XML files generated by these designers, though it lacks visual editing. For GTK 4 development, has emerged as the recommended declarative UI language, compiling to GtkBuilder XML and offering modern IDE features like code completion. Cambalache serves as a graphical RAD tool and successor to Glade, providing drag-and-drop support specifically for GTK 4 widgets and layouts. In terms of evolution, while Glade accommodated GTK 3's layout systems, GTK 4's constraint-based layouts are better handled by these newer tools, reflecting GTK's shift toward more flexible, declarative UIs.

Inspection and debugging

The GTK Inspector is a built-in interactive tool integrated into GTK applications, enabling developers to examine the runtime structure and behavior of user interfaces without interrupting execution. It provides a comprehensive view of the widget hierarchy through a live object tree, allowing users to navigate and inspect the relationships between widgets, their properties, and associated CSS nodes. Activation occurs via keyboard shortcuts such as Ctrl+Shift+I or Ctrl+Shift+D, or by setting the GTK_DEBUG=interactive before launching the application, which embeds within the application's process for real-time analysis. Key features include property inspection, where developers can view and modify widget attributes like visibility, text content, or margins directly in the Objects tab, facilitating and of layout issues. For CSS debugging, the CSS tab supports live of styles, such as changing background colors or node selectors, with immediate visual feedback to resolve theming problems. Signal tracing is available through a dedicated Signals tab, which logs and displays emitted signals for selected objects, aiding in the of event handling errors. Additionally, rendering overlays like the magnifier tool allow zooming into widgets for pixel-level examination of rendering artifacts. In GTK 4, is enhanced with support for the via the GSK (GTK Scene Graph Kit) renderer, including a Recorder tab that captures and serializes render node trees as .node files for replay and , useful for optimizing and verifying frame outputs across different backends. This functionality enables recording of frames and events using shortcuts like Super+R for start, Super+C for stop, and Super+F for replay, providing deeper insights into the drawing model without relying solely on external profilers. The tool proves essential for addressing theming inconsistencies and layout misalignments in complex applications, often used in tandem with gdb for low-level and execution tracing, as operates within the debugged . External alternatives complement the inspector for specialized debugging needs. For instance, Accerciser serves as an accessibility explorer, leveraging the AT-SPI interface to inspect and interact with GTK widgets' accessible roles, relations, and states, which is particularly valuable for verifying compliance with support. While older tools like GtkParasite offered similar widget inspection capabilities, the built-in GTK Inspector has largely superseded them for modern GTK versions due to its seamless integration and expanded features.

Applications and Ecosystem

Notable applications

GTK plays a central role in numerous open-source applications, particularly within ecosystem, where it powers core productivity tools. The application, formerly known as , serves as the default and relies on GTK 4 for its modern interface, enabling efficient file browsing and management with hardware-accelerated rendering. Similarly, provides a lightweight environment for editing plain text files, built on GTK 4 to support and seamless integration with the desktop. The , known as since GNOME 45, uses GTK 4 to deliver fast, GPU-accelerated rendering of images in various formats, including support for tiled . , the standard arithmetic tool, has been ported to GTK 4, offering scientific and financial computation modes with an intuitive, responsive UI. Beyond GNOME's core suite, GTK underpins several prominent multimedia and creative applications. GIMP, a powerful for photo retouching and image composition, employs GTK 3 for its extensive toolset and customizable workspace. , a focused on scalable illustrations and diagrams, utilizes GTK 3 with ongoing migration efforts to GTK 4 to enhance cross-platform compatibility. supports an optional GTK interface on , allowing users to leverage the toolkit for file dialogs and basic controls alongside its primary Qt-based UI. , the widely used , integrates a GTK backend on Linux distributions to ensure native look and feel, drawing from GTK 3 for widget rendering and theming. Cross-platform utilities also highlight GTK's versatility. Transmission, a lightweight BitTorrent client, offers a GTK-based graphical interface for managing downloads across Linux and other Unix-like systems. Pidgin, an instant messaging client supporting multiple protocols, is built with GTK to provide a unified chat experience with plugin extensibility. Recent developments show a clear trend toward GTK 4 adoption in major applications, driven by improved performance and modern rendering capabilities, though legacy projects like GIMP and Inkscape maintain GTK 3 support amid gradual transitions. This shift enhances accessibility and integration in open-source environments while preserving backward compatibility for established software.

Desktop environments

GNOME is the primary desktop environment built on , serving as its flagship implementation and driving much of the toolkit's evolution. Since 42, released in 2022, the environment has adopted 4 as its core toolkit for applications and shell components, enabling modern features like hardware-accelerated rendering and improved accessibility. This architectural reliance on ensures seamless integration between the Shell and GTK-based applications, with the shell leveraging widgets for elements. Cinnamon, the default desktop environment for , employs a hybrid approach with GTK 3 for its core components and emerging support for GTK 4 in newer applications. As a of , it maintains traditional desktop metaphors while utilizing GTK's widget set for panels, applets, and dialogs, allowing for customizable layouts without fully migrating to GTK 4 yet. MATE, a continuation of the GNOME 2 series, exclusively uses GTK 3 following its full transition in version 1.18 released in 2017, preserving a lightweight, classic interface through GTK's stable for menus, panels, and settings. Among legacy environments, Unity—Canonical's former default for —relied on GTK for its indicator panels, HUD menus, and application integration until its discontinuation in 2017, after which reverted to . Early versions of were purely GTK-based, drawing from the toolkit for its panel and components; the environment remains GTK-based. In these environments, GTK underpins key integrations such as top panels for system notifications, context menus for file operations, and settings dialogs for user preferences, ensuring consistent behavior across GTK applications. Theming alignment often centers on , GNOME's default theme, which provides a cohesive for GTK widgets in , , and MATE, with variants adapted for dark modes and accent colors to maintain environment-specific aesthetics.

Widget extensions and utilities

GtkSourceView is a library that extends the core GtkTextView widget to provide advanced text editing capabilities, including syntax highlighting for numerous programming languages, code folding, and search-and-replace functionality. It supports features like undo/redo operations, printing, and a completion system, making it suitable for integrated development environments (IDEs). This widget is prominently used in GNOME Builder, the official IDE for GNOME applications, where it enables syntax-aware editing for code development. GtkSourceView maintains version alignment with GTK releases, such as the 5.x series developed alongside GTK 4 to ensure compatibility with modern rendering and theming features. GtkSpell provides spell-checking integration for GTK applications by attaching to GtkEntry and GtkTextView buffers, offering inline highlighting of misspelled words and context menus for corrections. In its GtkSpell3 variant for GTK 3, it utilizes the library as its primary backend, with support for Aspell as an alternative, enabling robust multilingual spell checking without requiring application-specific implementations. This utility simplifies the addition of word-processor-like features to text inputs, such as underlining errors and suggesting replacements directly within the widget. Other notable utilities include libadwaita, which offers widgets for creating adaptive user interfaces that respond to device form factors like mobile screens (succeeding the deprecated Libhandy), and , a virtual terminal emulator widget that embeds shell access with support for , color schemes, and scrollback buffers. Libadwaita has been developed to enhance cross-device usability in GTK 4 applications. , meanwhile, handles terminal emulation protocols and is designed for embedding in applications requiring console interaction. These extensions are maintained by the GNOME community through collaborative repositories, with release cycles synchronized to GTK major versions to ensure stability and feature parity across the ecosystem. Development emphasizes modular contributions, allowing independent updates while adhering to GTK's API evolution.

Criticism and Evolution

Key criticisms

One of the primary criticisms of GTK concerns its API stability across major version transitions, particularly from GTK 2 to GTK 3, where numerous incompatibilities required significant code rewrites for applications. Changes included restrictions on header inclusions, removal of direct struct access in favor of accessor functions, shifts in key event constants, and a complete overhaul of the drawing API to rely on Cairo, all of which broke backward compatibility and complicated migrations for developers maintaining legacy software. Similar issues persisted in later transitions, such as from GTK 3 to 4, amplifying the effort needed to update applications. The default theme in GTK 3 and 4 has drawn criticism for its opinionated design, which prioritizes a specific aesthetic and actively discourages overrides to prevent application breakage, limiting user customization options. Libadwaita, which enforces styling, does not technically block theming but requires developers to implement it manually, and arbitrary style changes via GTK's CSS system are unsupported and can lead to visual inconsistencies or functional errors in apps. This approach has frustrated users seeking greater flexibility, as workarounds often involve hacky modifications that risk instability. GTK 4's removal of the legacy OpenGL (GL) renderer fallback in version 4.18 has been noted as problematic for users with outdated graphics hardware or drivers, potentially causing rendering failures or forcing reliance on slower software rendering paths. This change, intended to streamline modern rendering stacks like and NGL, leaves older GPUs unsupported without viable alternatives, impacting accessibility for legacy systems. Porting GTK applications to Windows and macOS often results in a less polished experience compared to native toolkits, with reports of visual glitches and UI inconsistencies. On Windows 11, particularly with AMD graphics cards like the RX 580, GTK 4.14 exhibits artifacts such as distorted toolbars and window buttons, attributed to the NGL renderer and absent in earlier versions or with other GPUs. Similarly, on macOS, GTK 3 applications suffer from UI update freezes during intensive operations, affecting cross-platform apps regardless of hardware generation from Intel to Apple Silicon, and requiring platform-specific debugging not needed on Linux or Windows. The Windows port's built-in theme support, stuck at a Windows 7 style, further contributes to an outdated appearance unless third-party themes are applied.

Ongoing developments and future directions

In recent releases, GTK has advanced its accessibility features significantly with the integration of the AccessKit backend in version 4.18, released in early 2025. This addition provides cross-platform accessibility support for Windows and macOS, marking the first time GTK offers robust a11y capabilities beyond without relying on platform-specific hacks. Additionally, media handling has improved through updates to the backend, which now better supports buffers (dmabufs) for efficient rendering of video and graphics content. These enhancements, including native support with animations in GTK 4.22, enable smoother integration of multimedia elements in applications. Looking toward future directions, groundwork for GTK 5 emphasizes streamlining the architecture by deprecating legacy backends such as X11 and Broadway, with plans for their removal to reduce maintenance overhead and legacy code. This shift aims to unify rendering and platform backends, potentially incorporating experimental support like the new Android backend introduced in GTK 4.18, while enhancing capabilities for web embedding through modern protocols. Such changes will focus on a more cohesive, Wayland-centric foundation on , alongside improved cross-platform consistency. The GTK community sustains momentum through regular hackfests, such as the one held at in early 2025, where developers prioritized performance optimizations—including advancements in the renderer for GPU-accelerated drawing—and enhancements to the developer experience, like better tooling for widget customization. These collaborative events foster iterative improvements without disrupting existing workflows. The overall roadmap post-GTK 4 prioritizes stability, committing to no major API or ABI breaks in minor releases to allow ecosystems to mature, with GTK 5 targeted for after 2025 as a deliberate major . This approach ensures reliable while addressing long-term goals like reduced complexity and broader platform adoption.

References

  1. https://www.gtk.org/
  2. https://people.redhat.com/mclasen/Usenix04/notes/x29.html
  3. https://gnome.pages.gitlab.gnome.org/gtk/gtk4/overview.html
  4. https://discourse.gnome.org/t/release-dates-of-gtk/17867
  5. https://blogs.gnome.org/gtk/2020/12/16/gtk-4-0/
  6. https://gitlab.gnome.org/GNOME/gtk/-/releases
  7. https://blogs.gnome.org/foundation/2020/11/24/gtk-at-the-heart-of-gnome/
  8. https://docs.gtk.org/gtk4/getting_started.html
  9. https://www.gtk.org/features/
  10. https://docs.gtk.org/gtk4/section-accessibility.html
  11. https://docs.gtk.org/gtk4/
  12. https://blogs.gnome.org/gtk/2020/12/17/who-wrote-gtk4/
  13. https://www.redhat.com/en/about/press-releases/gnome-desktop-project
  14. https://gitlab.gnome.org/GNOME/gtk
  15. https://mail.gnome.org/mailman/listinfo/gtk-devel-list
  16. https://wiki.gnome.org/Hackfests
  17. https://foundation.gnome.org/
  18. https://foundation.gnome.org/reports/
  19. https://www.gimp.org/about/ancient_history.html
  20. https://mail.gnome.org/archives/gtk-list/1998-April/msg00303.html
  21. https://www.bassi.io/articles/2018/11/29/history-of-gnome-episode-1-a/
  22. https://blogs.gnome.org/jrb/files/2017/07/A-Brief-History-of-GNOME-1.pdf
  23. https://mail.gnome.org/archives/gtk-devel-list/2002-March/msg00234.html
  24. https://www.osnews.com/story/9609/gtk-goes-cairo-owen-taylor-on-xcairogtk-integration/
  25. https://irtfweb.ifa.hawaii.edu/SoftwareDocs/gtk20/gtk/gtk-changes-2-0.html
  26. https://github.com/openSUSE/gtk1-compat
  27. https://blogs.gnome.org/gtk/2011/02/10/gtk-3-0-released/
  28. https://docs.gtk.org/gtk3/changes.html
  29. https://blogs.gnome.org/clutter/2022/02/16/retiring-clutter/
  30. https://mail.gnome.org/archives/gnome-announce-list/2013-September/msg00052.html
  31. https://docs.gtk.org/gtk3/migrating-2to3.html
  32. https://blogs.gnome.org/gtk/tag/stable/
  33. https://release.gnome.org/46/developers/
  34. https://gitlab.gnome.org/GNOME/gtk/-/blob/4.14.0/NEWS
  35. https://blogs.gnome.org/gtk/2025/02/01/whats-new-in-gtk-winter-2025-edition/
  36. https://blogs.gnome.org/gtk/2025/05/12/an-accessibility-update/
  37. https://www.phoronix.com/news/GTK-4.20-Released
  38. https://www.phoronix.com/news/GTK-4.16-Released
  39. https://docs.gtk.org/gtk4/building.html
  40. https://discourse.gnome.org/t/removing-the-autotools-build-for-gtk-3/12764
  41. https://mesonbuild.com/
  42. https://ninja-build.org/
  43. https://www.freedesktop.org/wiki/Software/pkg-config/
  44. https://gitlab.gnome.org/GNOME/gtk/-/blob/main/.gitlab-ci.yml
  45. https://glade.gnome.org/
  46. https://help.gnome.org/users/glade/stable/
  47. https://glade.gnome.org/news.html
  48. https://www.gtk.org/docs/dev-tools/gnome-builder
  49. https://man.archlinux.org/man/gtk-builder-tool.1.en
  50. https://gnome.pages.gitlab.gnome.org/blueprint-compiler
  51. https://flathub.org/apps/details/org.gnome.Cambalache
  52. https://docs.gtk.org/gtk4/running.html
  53. https://blogs.gnome.org/gtk/2017/04/05/the-gtk-inspector/
  54. https://stackoverflow.com/questions/37942323/gtk-track-signals-and-events
  55. https://blogs.gnome.org/mclasen/2016/11/02/goings-on/
  56. https://gitlab.gnome.org/GNOME/accerciser
  57. https://developer.gnome.org/documentation/tools/inspector.html
  58. https://gitlab.gnome.org/GNOME/nautilus/-/issues/276
  59. https://blogs.gnome.org/chergert/2021/03/06/a-gtk-4-based-text-editor/
  60. https://blogs.gnome.org/sophieh/2023/08/30/viewing-images-in-gnome-loupe-and-glycin/
  61. https://thisweek.gnome.org/posts/2021/11/twig-19
  62. https://www.gimp.org/news/2025/03/16/gimp-3-0-released/
  63. https://bugzilla.mozilla.org/show_bug.cgi?id=1701123
  64. https://github.com/transmission/transmission
  65. https://pidgin.im/install/
  66. https://release.gnome.org/42/
  67. https://www.osnews.com/story/142412/linux-mint-forks-gnomes-libadwaita-to-add-theme-support/
  68. https://mate-desktop.org/blog/2017-03-13-mate-1-18-released/
  69. https://arstechnica.com/information-technology/2017/04/ubuntu-unity-is-dead-desktop-will-switch-back-to-gnome-next-year/
  70. https://www.xfce.org/
  71. https://wiki.archlinux.org/title/GTK
  72. https://wiki.gnome.org/Projects/GtkSourceView
  73. https://gitlab.gnome.org/GNOME/gtksourceview
  74. https://blogs.gnome.org/chergert/2021/11/01/gtksourceview-is-getting-a-vim-emulator/
  75. https://gnome.pages.gitlab.gnome.org/gtksourceview/gtksourceview5/index.html
  76. https://lazka.github.io/pgi-docs/GtkSpell-3.0/index.html
  77. https://gtkspell.sourceforge.net/
  78. https://wiki.archlinux.org/title/Language_checking
  79. https://gitlab.gnome.org/GNOME/libadwaita
  80. https://discourse.gnome.org/t/why-is-not-libadwaita-merged-into-gtk4/9739
  81. https://wiki.gnome.org/Apps/Terminal/VTE
  82. https://gitlab.gnome.org/GNOME/vte
  83. https://developer.gnome.org/components/
  84. https://discourse.gnome.org/t/why-and-how-libadwaita-prevents-theming/17079
  85. https://discourse.gnome.org/t/visual-artifacts-on-windows-11-with-gtk-4-14-6-and-amd-graphics/23160
  86. https://discourse.gnome.org/t/gtk3-app-ui-updates-get-stuck-in-macos/25366
  87. https://www.gtk.org/docs/installations/windows
  88. https://blog.gtk.org/
  89. https://blogs.gnome.org/gtk/2025/10/23/svg-in-gtk/
  90. https://blogs.gnome.org/gtk/2025/
  91. https://docs.gtk.org/gtk4/migrating-4to5.html
  92. https://www.phoronix.com/news/GTK-X11-Now-Deprecated
Add your contribution
Related Hubs
User Avatar
No comments yet.