Making A GTK Application In Haskell, Part 1

TL;DR

Prime Big Deal Days · Oct 6–7Offer from Amazon

Get the latest gadgets delivered free — and shop member deals

• Fast, free delivery on millions of items
• Access to Prime Big Deal Days deals on October 6–7
• Prime Video, Amazon Music and more included

Start your free Prime trial →Free trial for eligible customers · Cancel anytime

As an affiliate, we earn on qualifying purchases.Hide

Floréal Technologies has published the first part of a tutorial series on building a todo-list application with Haskell, GTK 4 and Adwaita. The installment creates a basic application window and models task changes with data types and an update function that produces save effects.

Floréal Technologies has published the first part of a tutorial series on building a todo-list application with Haskell, GTK 4 and Adwaita. The installment shows how to create an application window and represent todo items, user actions and save operations as data, giving intermediate Haskell developers a starting point for a desktop app built with GNOME’s interface toolkit.

The tutorial begins with a small GTK 4 and Adwaita program. It creates an Adwaita application, connects its activate signal to a handler, and runs the Gio application loop. The handler builds a header bar and toolbar, then places them in an application window titled “Todos,” with a default width of 480 pixels and a height of 640 pixels. The article describes the result as an empty window; it does not yet show a task list on screen.

For Haskell bindings, the author uses haskell-gi, a toolkit that generates bindings from GTK libraries. The article says this gives Haskell code an interface that remains relatable to GTK’s C API. It also notes that examples in the post are incomplete for readability and points readers to the full project, adwaita-todo, on GitHub.

The tutorial then introduces the Elm Architecture, or TEA, through four ideas: a model for application state, a view that turns state into an interface, messages for user interactions and effects for side actions. Its initial model stores todos in a map and tracks the next identifier. The messages shown are Add and SetDoneStatus. The update function strips whitespace from new titles, ignores blank entries and requests a save when todo data changes. The article’s GHCi examples show that marking an already completed item as done again produces no save effect.

A Data Model for GTK Actions

The installment’s main contribution is an example of how to organize state changes around explicit messages and effects while building an interface with GTK. GTK applications respond to events, and the tutorial presents TEA as a way to make those interactions visible in Haskell data structures. In the example, adding a task or changing its completion status can be represented as a message, while saving is represented separately as an effect.

That separation can help readers reason about the app’s domain logic without tying every rule to a widget callback. The tutorial demonstrates one concrete rule: a save is requested when the todo collection changes, but not when an update leaves it unchanged. The source does not present benchmarks or claim that this pattern is superior to other GTK architectures; its value here is instructional, for readers learning how the pieces fit together.

The choice of Adwaita also connects the example to GNOME application design. The article says the library provides GTK components associated with GNOME’s design language and supports responsive design and runtime recoloring when the desktop switches between light and dark themes. Those capabilities provide context for the toolkit choice, though this first installment does not demonstrate a completed, styled todo interface.

The Tools Behind the Tutorial

The series is aimed at intermediate Haskell developers who already have experience with the language. Its stated goal is to build a todo-list application using Haskell, GTK 4 and Adwaita. Part one moves from a minimal window to the shape of the app’s state and update logic; the source ends as it begins to introduce the view.

GTK is a toolkit for graphical applications, while Adwaita supplies components and styles used in GNOME-oriented interfaces. The article describes haskell-gi as the bridge used in the series: it generates Haskell bindings from the GTK libraries. The project repository is linked in the source, but the article excerpt does not describe its build instructions, dependencies or supported platforms.

“The series’ intended audience is intermediate Haskellers, with development experience with the language.”

— Floréal Technologies tutorial

The Interface Is Still Ahead

The supplied article text stops just as the author begins the section on the view. It therefore does not establish how the todo list will be rendered, how messages will be connected to GTK controls, or how save effects will write data to disk. The source defines a Save effect and describes it as representing disk saves, but the shown code and GHCi session do not demonstrate actual file storage.

The source also does not state the post’s exact publication day, the series schedule, or when later installments will appear. It gives a link to the full project, but no details here confirm its current release status, operating-system coverage or completeness.

From State to Visible Tasks

The author says the next step in this installment is to design the interface, but the supplied material does not include that section or announce a follow-up date. Readers can consult the linked adwaita-todo repository for the full project referenced by the tutorial. The next development described in the article is the view: how the model and messages will be connected to the GTK interface.

Key Questions

What does part one of the series cover?

It creates a basic GTK 4 and Adwaita application window, then introduces data types for todo items, app state, messages and save effects.

Who is the tutorial for?

Floréal Technologies says it is aimed at intermediate Haskell developers with prior experience using the language.

Does the example save tasks to disk?

The code models saving as a Save effect and shows when the update function requests one. The supplied text does not demonstrate writing the todo list to a file.

What is used to connect Haskell and GTK?

The tutorial uses haskell-gi, which it describes as generating Haskell bindings from GTK libraries.

Where can readers find the full project?

The article links to the adwaita-todo repository on GitHub. The supplied material does not give further details about the project’s current status or platform support.

Source: hn