Nimf, Clair, and Guiyom Development Status — July 2026

Development of Nimf, Clair, and Guiyom has recently taken longer than expected. This is because more work has gone into reorganizing the foundations of the projects than into adding immediately visible features.

The three projects are independent, but their development directions are closely connected. Clair provides shared infrastructure for multiple operating systems, Guiyom is a cross-platform GUI toolkit built on Clair, and Nimf is planned to use both Clair and Guiyom.

The current development status is summarized below.

Nimf

The long-term plan for Nimf is to port its major components to Ada and improve it so that text input works reliably across a wide range of desktop and application environments.

Some parts of the current Nimf architecture tightly couple the GUI toolkit to the input method server’s main loop. Because of this, when switching from a graphical environment to a console, stalled GUI-related processing can also affect communication with the Nimf server and prevent the console input method from working normally.

I also tested an approach that moved GTK processing to a separate thread and used event queues to communicate with Nimf’s main loop. Although it initially appeared to work, it eventually stalled during prolonged operation and did not provide a fundamental solution.

The plan is to solve this problem by applying Guiyom to Nimf. The goal is to improve the architecture so that the state of the GUI layer cannot block the core operation of the input method server.

There are also environments such as Wayland, Flatpak, Snap, SDL, and Wine where input may not be delivered correctly through the existing input method interfaces. These compatibility problems will also be addressed. If necessary, an IBus-compatible interface may be implemented to support such environments.

As a first step, work is underway to move nimf-settings to an architecture that uses Ada and Guiyom. The patterns established in the settings application will then be used to gradually move Nimf’s core state management, IPC, service management, and common input-engine layer to Ada.

However, full-scale modernization of Nimf requires foundational capabilities from Guiyom and Clair, so its overall schedule is affected by the development status of those two projects.

Guiyom

Guiyom is a cross-platform GUI toolkit being developed in Ada.

It adopts an architecture that differs from conventional GUI toolkits, but its overall and detailed design will not be disclosed before the P3 patent application is filed.

Guiyom is designed and implemented with performance, safety, reliability, and maintainability under large-scale or extreme conditions as primary goals. The design aims to keep state and resources predictable not only during normal execution, but also under various failure conditions.

Current work focuses on refining the core foundation and platform-specific implementations, as well as completing the technical implementation and validation required before filing the P3 patent application.

Guiyom depends on Clair’s event loop and other platform-neutral facilities. Consequently, the Microsoft Windows support and platform-neutralization work currently underway in Clair also affects Guiyom’s overall schedule.

Clair

Clair is a library being developed in Ada to provide system-level facilities needed for cross-platform application development.

It aims to provide event loops, asynchronous I/O, signal handling, process execution, time and timer management, file and dynamic-library facilities, logging, internationalization, regular expressions, and testing infrastructure.

The public repository is available at:

https://github.com/hodong-kim/clair

The current focus of Clair development is Microsoft Windows support and platform neutralization.

Some Clair features and interfaces were originally written with assumptions specific to Unix-like operating systems. Adding Windows support showed that it would not be sufficient simply to add Windows-specific code. The common platform contracts and operating-system-specific implementations also need to be separated clearly.

Accordingly, Windows event-loop and system facilities are being implemented while Unix-specific functionality is separated from common platform functionality. Major areas such as files, processes, and logging are also being reviewed so that they can be used consistently across operating systems. The build environment is being improved as well so that Windows dependencies and binaries can be produced and validated reproducibly.

Clair.Test is also being expanded into a language-neutral testing framework that can integrate tests for Ada code, C code, and external programs.

Clair is therefore not stopped or merely delayed. Rather, support for Windows has expanded the scope of the foundational work that must be completed.

In the short term, this work is a bottleneck for the projects as a whole. In the long term, however, it is necessary to provide the same high-level APIs and consistent failure-handling behavior across Linux, FreeBSD, macOS, Windows, and other supported environments.

Overall Development Status

The relationship among the three projects can be summarized as follows.

Clair
  ↓
Guiyom
  ↓
Nimf modernization

Clair’s Microsoft Windows support and platform-neutralization work must progress before Guiyom’s cross-platform foundation can be expanded reliably. Guiyom must then reach a sufficient level of maturity before the GUI architecture and input method server architecture of Nimf can be improved in earnest.

This can make Nimf and Guiyom appear to be progressing slowly, but shared foundational work centered on Clair is continuing.

Rather than adding visible features as quickly as possible, the current work is intended to ensure that future development is not again constrained by a particular operating system or GUI toolkit.

It is still difficult to give an exact completion schedule. Once the current bottlenecks are resolved, however, development of the three projects should be able to proceed more independently and in parallel.