Personal tools

Applications and libraries/GUI libraries

From HaskellWiki

< Applications and libraries(Difference between revisions)
Jump to: navigation, search
m (Graphical User Interface Libraries)
(Medium-level: Add HsQML.)
(45 intermediate revisions by 18 users not shown)
Line 1: Line 1:
  +
[[Category:User interfaces]]
 
{{unknown copyright}}
 
{{unknown copyright}}
 
{{LibrariesPage}}
 
{{LibrariesPage}}
   
== Graphical User Interface Libraries ==
+
There is a large number of GUI libraries for Haskell. Unfortunately there is no standard one and all are more or less incomplete. In general, low-level veneers are going well, but they are low level. High-level abstractions are pretty experimental. There is a need for a supported medium-level GUI library.
   
There is a large number of GUI libraries for Haskell. Unfortunately there is no standard one and all are more or less incomplete. The following list gives an overview. In general, low-level veneers are going well, but they are low level.
+
== High-level ==
High-level abstractions are pretty experimental. There is a need for a supported medium-level GUI library.
 
   
{| class="wikitable"
+
=== FG ===
!High-level:
 
|[http://haskell.org/FranTk FranTk]
 
|[http://www.cs.chalmers.se/ComputingScience/Research/Functional/Fudgets/ Fudgets]
 
|[http://haskell.org/fruit/ Fruit] and [http://zoo.cs.yale.edu/classes/cs490/03-04b/bartholomew.robinson/ wxFruit]
 
|([http://www.dcs.gla.ac.uk/fp/software/haggis/ Haggis])
 
|[[Phooey]]
 
|[[GuiTV]]
 
|-
 
!Medium-level:
 
|[[WxHaskell|wxHaskell]]
 
|[http://haskell.org/gtk2hs/ Gtk2HS]
 
|[http://haskell.org/graphics/ HGL] (graphics only)
 
|[http://haskell.org/ObjectIO Object I/O]
 
|
 
|
 
|-
 
!Low-level veneers:
 
|[http://haskell.org/HOpenGL/ GLUT]
 
|[http://www.dcs.gla.ac.uk/~meurig/TclHaskell/ TclHaskell]
 
|Win32
 
|X11
 
|
 
|
 
|}
 
   
;[http://www.cse.unsw.edu.au/~dons/code/hmp3/Curses.hsc Curses.hsc]
+
FG is an arrow-based high-level functional approach to composable GUIs, built on top of Gtk2Hs. It is inspired by Fruit but uses discrete events instead of continuous signals.
:A minimal binding to curses (as well as ncurses). Smaller and less featured than hscurses, it also provides fast packed string support.
 
   
;[http://haskell.org/FranTk FranTk]
+
See the [http://kevin.atkinson.dhs.org/fg/doc/FG.html FG homepage].
:is a library for building GUIs in Haskell. FranTk uses behaviours and events, concepts from Conal Elliot's Functional Reactive Animation. FranTk provides good support for developing complex dynamic systems, and is built on top of Tcl-Tk. This makes it platform independent. FranTk was developed by [http://www.dcs.gla.ac.uk/~meurig Meurig Sage]. For Unix and Windows.
 
   
;[http://www.haskell.org/fruit/ Fruit]
+
=== FranTk ===
:Another high-level approach to GUI's in Haskell. It is based on the concepts of Functional Reactive Programming and arrows. There is also another implementation of this approach, called [http://zoo.cs.yale.edu/classes/cs490/03-04b/bartholomew.robinson/ wxFruit]. It is implemented on top of wxHaskell.
 
   
;[http://www.cs.chalmers.se/ComputingScience/Research/Functional/Fudgets/ Fudgets]
+
FranTk is a library (that seems to have disappeared from Internet) for building GUIs in Haskell. FranTk uses behaviours and events, concepts from Conal Elliott’s Functional Reactive Animation. FranTk provides good support for developing complex dynamic systems, and is built on top of Tcl/Tk. This makes it platform independent. FranTk was developed by [http://www.dcs.gla.ac.uk/~meurig/ Meurig Sage]. It runs on Unix and Windows.
:Fudgets is primarily a Graphical User Interface Toolkit for the functional programming language Haskell and the X Windows system. Fudgets also makes it easy to create client/server applications that communicate via the Internet. [http://www.cs.chalmers.se/ComputingScience/Research/Functional/Fudgets/springschool95-intro.html Programming with Fudgets: A short presentation of the Fudget Library and the ideas underlying it]. For Unix, not Windows.
 
   
;[[GuiTV]]
+
A short description can be found at the
:GuiTV is a small library for GUI-style visualizing functional values. It can also be viewed as an approach to functional GUIs. It is implemented very simply by using [[Phooey]] in the [[TV]] framework.
+
[http://src.gnu-darwin.org/ports/x11-toolkits/hs-frantk/work/FranTk1.1/FranTk.html GNU-Darwin site]. For more information, see the PDF document [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.25.8446&rep=rep1&type=pdf FranTk A declarative GUI language for Haskell].
   
;[http://haskell.org/gtk2hs/ Gtk2Hs]
+
=== Fruit ===
:Gtk2Hs is a GUI library for Haskell based on [http://www.gtk.org Gtk+]. Gtk+ is an extensive and mature multi-platform toolkit for creating graphical user interfaces. Gtk2Hs is actively developed, supporting the latest version of the Gtk+ 2.x series. It provides automatic memory management, Unicode support and also bindings for various Gnome modules. It runs on Windows, Linux, MacOS X, FreeBSD and Solaris.
 
   
;[http://www.informatik.uni-freiburg.de/~wehr/haskell/ hscurses]
+
Fruit is another high-level approach to GUIs in Haskell. It is based on the concepts of Functional Reactive Programming and arrows. There is also another implementation of this approach, called wxFruit (see below).
:A Haskell binding to the NCurses library, a library of functions that manage an application's display on character-cell terminals. hscurses also provides some basic widgets implemented on top of the ncurses binding, such as a text input widget and a table widget.
 
   
;[http://www.informatik.uni-bremen.de/htk HTk]
+
See the [http://www.haskell.org/fruit/ Fruit homepage].
:Htk is a typed, portable encapsulation of Tcl/Tk into Haskell. Its distinctive features are the use of Haskell types and type classes for structuring the interface, an abstract notion of event for describing user interaction, and portability across Windows, Unix and Linux.
 
   
;[http://htoolkit.sourceforge.net/ HToolkit]
+
=== Fudgets ===
:HToolkit is a portable Haskell library for writing graphical user interfaces (GUI's). The library is built upon a low-level interface that will be implemented for each different target platform. The low-level library is called Port and is currently implemented for GTK and Windows. The middle-level library is named GIO (the Graphical IO library) and is built upon the low-level Port library.
+
Fudgets is primarily a Graphical User Interface Toolkit for Haskell and the X Windows system. Fudgets also makes it easy to create client-server applications that communicate via the Internet. It runs on Unix but not on Windows.
   
;[http://haskell.org/ObjectIO Object I/O for Haskell]
+
See the [http://www.altocumulus.org/Fudgets/ homepage] and [http://www.altocumulus.org/Fudgets/springschool95-intro.html Programming with Fudgets] which is a short presentation of the Fudget Library and the ideas underlying it.
:A port of Clean Object I/O library for Haskell
 
   
;[[Phooey]]
+
=== Grapefruit ===
:A simple, functional, arrow-based library. Currently implemented atop [[wxHaskell]]. Phooey supports dynamic input bounds, flexible layout, and mutually-referential widgets.
 
   
;[http://www.dcs.gla.ac.uk/~meurig/TclHaskell/ TclHaskell]
+
Grapefruit is an arrow-based declarative library. Widgets, windows and control components communicate via discrete and continuous signals. The use of signals is explicit in the interface to avoid certain inefficiencies. Internally, Grapefruit uses the event handling mechanisms of the underlying GUI toolkit.
:TclHaskell is a library of functions for writing platform independent, graphical user interfaces in Haskell. The library provides a convenient, abstract and high-level way to write window-oriented applications. It also provides a more low level interface to write primitive Tcl code where helpful. For Unix and Windows (and Macintosh?).
 
   
;<span anchor="wxhaskell">[[wxHaskell]]</span>
+
Currently, Grapefruit is build on top of Gtk2Hs but implementations based on other toolkits are planned for the future.
:[[wxHaskell]] is a portable and native GUI library built on top of wxWindows - a comprehensive C++ library that is portable across all major GUI platforms; including GTK, Windows, X11, and MacOS X. wxWindows is a mature library (in development since 1992) that supports a wide range of widgets with the native look-and-feel, and it has a very active community.
 
   
:An addition to wxHaskell, [http://www.sandr.dds.nl/FunctionalForms Functional Forms] is a combinator library/domain specific language which enables a very concise programming style for forms: dialogs which only show and edit a set of values. Forms are used in many applications as Options or Settings dialogs.
+
See [[Grapefruit]].
   
;[http://kevin.atkinson.dhs.org/fg/doc/FG.html FG]
+
=== GuiTV ===
:An arrow-based high-level functional approach to composable GUIs, built on top of Gtk2Hs. It is inspired by Fruit but uses discrete events instead of continuous signals.
 
   
  +
GuiTV is a small library for GUI-style visualizing functional values. It can also be viewed as an approach to functional GUIs. It is implemented very simply by using [[Phooey]] in the [[TV]] framework.
   
==== Unsupported GUI-libraries ====
+
See [[GuiTV]].
   
The following libraries seem to be no longer maintained. However, someone might pick up one of them or at least profit from some design ideas.
+
=== Phooey ===
;[http://www.reid-consulting-uk.ltd.uk/alastair/publications/gfpw93/ Budgets]
 
:A library of Fudget-like combinators based on the Openlook widget library was developed by [http://www.reid-consulting-uk.ltd.uk/alastair/ Alastair Reid] and Satnam Singh. The code has suffered tremendous bit-rot (does anyone have a copy of ghc-0.16?) but all the reusable ideas are described in the [http://www.reid-consulting-uk.ltd.uk/alastair/publications/gfpw93/ paper].
 
   
;[http://citeseer.ist.psu.edu/taylor96embracing.html Embracing Windows]
+
Phooey is simple, functional, arrow-based library. Currently it is implemented atop [[wxHaskell]]. Phooey supports dynamic input bounds, flexible layout, and mutually-referential widgets.
:is a framework for developing graphical user interfaces. It runs under Windows 95 using a modified version of Hugs 1.3.
 
   
;Gadgets
+
See [[Phooey]].
:Lazy functional components for graphical user interfaces, developed by Rob Noble under the supervision of [http://www.cs.york.ac.uk/~colin/ Colin Runciman] (LNCS 982, pages 321-340).
 
   
;[http://www.cse.unsw.edu.au/~chak/haskell/gtk/ Gtk+HS] a Haskell binding for GTK+
+
=== wxFruit ===
:This library provides a transcription of the original GTK+ API into Haskell. GTK+ is a modern, portable GUI library and forms the basis of the Gnome desktop project. The binding, while not complete, covers most of GTK+'s core functionality and is ready for use in applications that require a GUI of medium complexity. Developed under Unix, but should also be usable with the Windows port of GTK+.
 
   
;[http://www.dcs.gla.ac.uk/fp/software/haggis/ Haggis]
+
[[wxFruit]] is a GUI library based on the ideas of Fruit but built on top of wxHaskell.
:Haggis is a graphical user interface framework for the functional language Haskell, running under the X Window system. It is being developed using the Glasgow Haskell Compiler with its concurrent extensions to achieve more comfortable interaction with the outside world.
 
   
;[http://www.cse.unsw.edu.au/~chak/haskell/gtk/#iHaskell iHaskell]
+
== Data Binding ==
:A functional wrapper on top of GTK+HS that provides convenience functions for frequently used programming patterns and eliminates the need for explicit mutable variables.
 
   
;Pidgets
+
[http://hackage.haskell.org/package/binding-core binding-core] is a framework for binding mutable data to IO objects. [http://hackage.haskell.org/package/binding-gtk binding-gtk] and [http://hackage.haskell.org/package/binding-wx binding-wx] provide convenient wrappers for [[Gtk2Hs]] and [[WxHaskell]] respectively.
:developed by [http://www.informatik.uni-trier.de/~ley/db/indices/a-tree/s/Scholz:Enno.html Enno Scholz] unifies pictures and widgets in a constraint-based framework for concurrent functional GUI programming.
+
  +
== Medium-level ==
  +
  +
=== Functional Forms ===
  +
  +
An addition to wxHaskell, Functional Forms is a combinator library/domain specific language which enables a very concise programming style for forms: dialogs which only show and edit a set of values. Forms are used in many applications as Options or Settings dialogs.
  +
  +
See the [http://www.sandr.dds.nl/FunctionalForms Functional Forms homepage].
  +
  +
=== Gtk2Hs ===
  +
  +
Gtk2Hs is a GUI library for Haskell based on [http://www.gtk.org Gtk+]. Gtk+ is an extensive and mature multi-platform toolkit for creating graphical user interfaces. Gtk2Hs is actively developed, supporting the latest version of the Gtk+ 2.x series. It provides automatic memory management, Unicode support and also bindings for various Gnome modules. It runs on Windows, Linux, MacOS X, FreeBSD and Solaris.
  +
  +
See [[Gtk2Hs]].
  +
  +
=== HGL ===
  +
  +
HGL is actually only a grapics library.
  +
  +
See the [http://haskell.org/graphics/ HGL homepage].
  +
  +
=== HQK ===
  +
  +
HQK is an effort to provide Haskell bindings to large parts of the Qt and KDE libraries. The goal is to auto-generate most of the binding code from C++ header files. We plan to develop a HQK GUI backend for the Functional Reactive Programming library [[Grapefruit]], thereby making Grapefruit multi-platform.
  +
  +
See [[HQK]].
  +
  +
=== HTk ===
  +
  +
Htk is a typed, portable encapsulation of Tcl/Tk into Haskell. Its distinctive features are the use of Haskell types and type classes for structuring the interface, an abstract notion of event for describing user interaction, and portability across Windows, Unix and Linux.
  +
  +
See the [http://www.informatik.uni-bremen.de/htk HTk homepage].
  +
  +
=== HToolkit ===
  +
  +
HToolkit is a portable Haskell library for writing graphical user interfaces (GUI's). The library is built upon a low-level interface that will be implemented for each different target platform. The low-level library is called Port and is currently implemented for GTK and Windows. The middle-level library is named GIO (the Graphical IO library) and is built upon the low-level Port library.
  +
  +
See the [http://htoolkit.sourceforge.net/ HToolkit homepage].
  +
  +
=== Object I/O for Haskell ===
  +
  +
This is a port of Clean Object I/O library for Haskell.
  +
  +
See the [http://haskell.org/ObjectIO Object I/O for Haskell homepage].
  +
  +
=== qtHaskell ===
  +
  +
qtHaskell is a set of bindings for the Qt Widget library from Trolltech. Haskell
  +
programmers can now access the Qt "signals and slots" based interface methodolgy
  +
(no Qt precompilation necessary), runtime loading of xml based interfaces
  +
designed with Qt Designer, ECMA/Javascript based apps (signal/slot calls can be passed through from javascript to Haskell and vice/versa) and so on.
  +
  +
Second preview version is downloadable from [http://qthaskell.berlios.de qtHaskell at Berlios].
  +
  +
=== wxHaskell ===
  +
  +
wxHaskell is a portable and native GUI library built on top of wxWidgets (formerly wxWindows)—a comprehensive C++ library that is portable across all major GUI platforms; including GTK, Windows, X11, and MacOS X. wxWidgets is a mature library (in development since 1992) that supports a wide range of widgets with the native look-and-feel, and it has a very active community.
  +
  +
See [[wxHaskell]].
  +
  +
=== HsQML ===
  +
  +
HsQML provides a Haskell binding to the Qt Quick framework. It allows you to write graphical applications where the front-end is written in Qt Quick's QML language (incorporating JavaScript) and the back-end is written in Haskell.
  +
  +
See the [http://www.gekkou.co.uk/software/hsqml/ HsQML homepage].
  +
  +
== Low-level ==
  +
  +
=== allegro-raw ===
  +
  +
A binding to [http://alleg.sourceforge.net/readme.html Allegro].
  +
Mahogny has a partial implementation but not formally released. Mail mahogny AT areta.org if interested.
  +
  +
Some partial bindings to allegro5 are at http://github.com/chrra/allegro-raw
  +
  +
=== GLFW ===
  +
  +
This is a binding to the [http://glfw.sourceforge.net GLFW OpenGL framework]. It provides an alternative to GLUT for OpenGL based Haskell programs.
  +
  +
See [[GLFW]].
  +
  +
=== GLUT ===
  +
  +
This is a binding to the OpenGL GLUT library.
  +
  +
=== TclHaskell ===
  +
  +
TclHaskell is a library of functions for writing platform independent, graphical user interfaces in Haskell. The library provides a convenient, abstract and high-level way to write window-oriented applications. It also provides a more low level interface to write primitive Tcl code where helpful. For Unix and Windows and maybe Macintosh.
  +
  +
See the [http://www.dcs.gla.ac.uk/~meurig/TclHaskell/ TclHaskell homepage].
  +
  +
=== Win32 ===
  +
  +
A binding to parts of the Win32 API.
  +
  +
=== X11 ===
  +
  +
A binding to parts of the X11 libraries.
  +
  +
== Uncategorized ==
  +
  +
=== Nanocurses ===
  +
  +
Nanocurses is a minimal binding to curses and ncurses. It is smaller than hscurses and has less features. It also provides fast packed string support. It provides a Curses.hsc derived from Hmp3.
  +
  +
See the [http://hackage.haskell.org/cgi-bin/hackage-scripts/package/nanocurses Hackage page].
  +
  +
=== hscurses ===
  +
  +
This is a Haskell binding to the NCurses library, a library of functions that manage an application’s display on character-cell terminals. hscurses also provides some basic widgets implemented on top of the ncurses binding, such as a text input widget and a table widget.
  +
  +
See the [http://www.stefanwehr.de/software/#hscurses hscurses homepage].
  +
  +
=== vty ===
  +
  +
Another text-based UI library; attempts to be easy to use.
  +
  +
See the [http://hackage.haskell.org/cgi-bin/hackage-scripts/package/vty Hackage page].
  +
  +
=== vty-ui ===
  +
  +
[http://jtdaugherty.github.com/vty-ui/ vty-ui] is a
  +
high-level user interface library for applications running in terminal emulators. It provides similar functionality to what you might expect from graphical toolkits like GTK and QT. vty-ui is written in the Haskell programming language.
  +
  +
== Unsupported ==
  +
  +
The following libraries seem to be no longer maintained. However, someone might pick up one of them or at least profit from some design ideas.
  +
  +
=== AutoForms ===
  +
  +
[[AutoForms]] is a library to ease the creation of Graphical User Interfaces (GUI). It does this by using generic programming to construct GUI components.
  +
  +
=== Budgets ===
  +
  +
Budgets is a library of Fudget-like combinators based on the Openlook widget library was developed by Alastair Reid and Satnam Singh. The code has suffered tremendous bit-rot (Does anyone have a copy of ghc-0.16?) but all the reusable ideas are described in the [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.19.3342&rep=rep1&type=pdf respective paper].
  +
  +
  +
=== Embracing Windows ===
  +
  +
This is a framework for developing graphical user interfaces. It runs under Windows 95 using a modified version of Hugs 1.3.
  +
  +
See the [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.55.2958&rep=rep1&type=pdf Embracing Windows paper] (PDF).
  +
  +
=== Gadgets ===
  +
  +
Gadgets are lazy functional components for graphical user interfaces, developed by Rob Noble under the supervision of [http://www.cs.york.ac.uk/~colin/ Colin Runciman].
  +
  +
See LNCS 982, pages 321-340.
  +
  +
=== Gtk+HS ===
  +
  +
Gtk+HS is a Haskell binding for GTK+. It provides a transcription of the original GTK+ API into Haskell. GTK+ is a modern, portable GUI library and forms the basis of the Gnome desktop project. The binding, while not complete, covers most of GTK+'s core functionality and is ready for use in applications that require a GUI of medium complexity. It was developed under Unix, but should also be usable with the Windows port of GTK+.
  +
  +
See the [http://www.cse.unsw.edu.au/~chak/haskell/gtk/ Gtk+HS homepage].
  +
  +
=== Haggis ===
  +
  +
Haggis is a graphical user interface framework for Haskell, running under the X Window system. It is being developed using the Glasgow Haskell Compiler with its concurrent extensions to achieve more comfortable interaction with the outside world.
  +
  +
See the [http://www.dcs.gla.ac.uk/fp/software/haggis/ Haggis homepage].
  +
  +
=== iHaskell ===
  +
  +
iHaskell is a functional wrapper on top of GTK+HS that provides convenience functions for frequently used programming patterns, and eliminates the need for explicit mutable variables.
  +
  +
See the [http://www.cse.unsw.edu.au/~chak/haskell/gtk/#iHaskell iHaskell homepage].
  +
  +
=== Pidgets ===
  +
  +
Pidgets, developed by [http://www.informatik.uni-trier.de/~ley/db/indices/a-tree/s/Scholz:Enno.html Enno Scholz], unifies pictures and widgets in a constraint-based framework for concurrent functional GUI programming.
  +
  +
== Hackage ==
  +
  +
* [http://hackage.haskell.org/packages/archive/pkg-list.html#cat:interfaces User interface libraries on Hackage]
  +
* [http://hackage.haskell.org/packages/archive/pkg-list.html#cat:graphics Graphics libraries on Hackage]

Revision as of 22:14, 19 June 2013

The copyright status of this work is not known. Please help resolve this on the talk page.

This page contains a list of libraries and tools in a certain category. For a comprehensive list of such pages, see Libraries and tools.

There is a large number of GUI libraries for Haskell. Unfortunately there is no standard one and all are more or less incomplete. In general, low-level veneers are going well, but they are low level. High-level abstractions are pretty experimental. There is a need for a supported medium-level GUI library.

Contents

1 High-level

1.1 FG

FG is an arrow-based high-level functional approach to composable GUIs, built on top of Gtk2Hs. It is inspired by Fruit but uses discrete events instead of continuous signals.

See the FG homepage.

1.2 FranTk

FranTk is a library (that seems to have disappeared from Internet) for building GUIs in Haskell. FranTk uses behaviours and events, concepts from Conal Elliott’s Functional Reactive Animation. FranTk provides good support for developing complex dynamic systems, and is built on top of Tcl/Tk. This makes it platform independent. FranTk was developed by Meurig Sage. It runs on Unix and Windows.

A short description can be found at the GNU-Darwin site. For more information, see the PDF document FranTk – A declarative GUI language for Haskell.

1.3 Fruit

Fruit is another high-level approach to GUIs in Haskell. It is based on the concepts of Functional Reactive Programming and arrows. There is also another implementation of this approach, called wxFruit (see below).

See the Fruit homepage.

1.4 Fudgets

Fudgets is primarily a Graphical User Interface Toolkit for Haskell and the X Windows system. Fudgets also makes it easy to create client-server applications that communicate via the Internet. It runs on Unix but not on Windows.

See the homepage and Programming with Fudgets which is a short presentation of the Fudget Library and the ideas underlying it.

1.5 Grapefruit

Grapefruit is an arrow-based declarative library. Widgets, windows and control components communicate via discrete and continuous signals. The use of signals is explicit in the interface to avoid certain inefficiencies. Internally, Grapefruit uses the event handling mechanisms of the underlying GUI toolkit.

Currently, Grapefruit is build on top of Gtk2Hs but implementations based on other toolkits are planned for the future.

See Grapefruit.

1.6 GuiTV

GuiTV is a small library for GUI-style visualizing functional values. It can also be viewed as an approach to functional GUIs. It is implemented very simply by using Phooey in the TV framework.

See GuiTV.

1.7 Phooey

Phooey is simple, functional, arrow-based library. Currently it is implemented atop wxHaskell. Phooey supports dynamic input bounds, flexible layout, and mutually-referential widgets.

See Phooey.

1.8 wxFruit

wxFruit is a GUI library based on the ideas of Fruit but built on top of wxHaskell.

2 Data Binding

binding-core is a framework for binding mutable data to IO objects. binding-gtk and binding-wx provide convenient wrappers for Gtk2Hs and WxHaskell respectively.

3 Medium-level

3.1 Functional Forms

An addition to wxHaskell, Functional Forms is a combinator library/domain specific language which enables a very concise programming style for forms: dialogs which only show and edit a set of values. Forms are used in many applications as Options or Settings dialogs.

See the Functional Forms homepage.

3.2 Gtk2Hs

Gtk2Hs is a GUI library for Haskell based on Gtk+. Gtk+ is an extensive and mature multi-platform toolkit for creating graphical user interfaces. Gtk2Hs is actively developed, supporting the latest version of the Gtk+ 2.x series. It provides automatic memory management, Unicode support and also bindings for various Gnome modules. It runs on Windows, Linux, MacOS X, FreeBSD and Solaris.

See Gtk2Hs.

3.3 HGL

HGL is actually only a grapics library.

See the HGL homepage.

3.4 HQK

HQK is an effort to provide Haskell bindings to large parts of the Qt and KDE libraries. The goal is to auto-generate most of the binding code from C++ header files. We plan to develop a HQK GUI backend for the Functional Reactive Programming library Grapefruit, thereby making Grapefruit multi-platform.

See HQK.

3.5 HTk

Htk is a typed, portable encapsulation of Tcl/Tk into Haskell. Its distinctive features are the use of Haskell types and type classes for structuring the interface, an abstract notion of event for describing user interaction, and portability across Windows, Unix and Linux.

See the HTk homepage.

3.6 HToolkit

HToolkit is a portable Haskell library for writing graphical user interfaces (GUI's). The library is built upon a low-level interface that will be implemented for each different target platform. The low-level library is called Port and is currently implemented for GTK and Windows. The middle-level library is named GIO (the Graphical IO library) and is built upon the low-level Port library.

See the HToolkit homepage.

3.7 Object I/O for Haskell

This is a port of Clean Object I/O library for Haskell.

See the Object I/O for Haskell homepage.

3.8 qtHaskell

qtHaskell is a set of bindings for the Qt Widget library from Trolltech. Haskell programmers can now access the Qt "signals and slots" based interface methodolgy (no Qt precompilation necessary), runtime loading of xml based interfaces designed with Qt Designer, ECMA/Javascript based apps (signal/slot calls can be passed through from javascript to Haskell and vice/versa) and so on.

Second preview version is downloadable from qtHaskell at Berlios.

3.9 wxHaskell

wxHaskell is a portable and native GUI library built on top of wxWidgets (formerly wxWindows)—a comprehensive C++ library that is portable across all major GUI platforms; including GTK, Windows, X11, and MacOS X. wxWidgets is a mature library (in development since 1992) that supports a wide range of widgets with the native look-and-feel, and it has a very active community.

See wxHaskell.

3.10 HsQML

HsQML provides a Haskell binding to the Qt Quick framework. It allows you to write graphical applications where the front-end is written in Qt Quick's QML language (incorporating JavaScript) and the back-end is written in Haskell.

See the HsQML homepage.

4 Low-level

4.1 allegro-raw

A binding to Allegro. Mahogny has a partial implementation but not formally released. Mail mahogny AT areta.org if interested.

Some partial bindings to allegro5 are at http://github.com/chrra/allegro-raw

4.2 GLFW

This is a binding to the GLFW OpenGL framework. It provides an alternative to GLUT for OpenGL based Haskell programs.

See GLFW.

4.3 GLUT

This is a binding to the OpenGL GLUT library.

4.4 TclHaskell

TclHaskell is a library of functions for writing platform independent, graphical user interfaces in Haskell. The library provides a convenient, abstract and high-level way to write window-oriented applications. It also provides a more low level interface to write primitive Tcl code where helpful. For Unix and Windows and maybe Macintosh.

See the TclHaskell homepage.

4.5 Win32

A binding to parts of the Win32 API.

4.6 X11

A binding to parts of the X11 libraries.

5 Uncategorized

5.1 Nanocurses

Nanocurses is a minimal binding to curses and ncurses. It is smaller than hscurses and has less features. It also provides fast packed string support. It provides a Curses.hsc derived from Hmp3.

See the Hackage page.

5.2 hscurses

This is a Haskell binding to the NCurses library, a library of functions that manage an application’s display on character-cell terminals. hscurses also provides some basic widgets implemented on top of the ncurses binding, such as a text input widget and a table widget.

See the hscurses homepage.

5.3 vty

Another text-based UI library; attempts to be easy to use.

See the Hackage page.

5.4 vty-ui

vty-ui is a high-level user interface library for applications running in terminal emulators. It provides similar functionality to what you might expect from graphical toolkits like GTK and QT. vty-ui is written in the Haskell programming language.

6 Unsupported

The following libraries seem to be no longer maintained. However, someone might pick up one of them or at least profit from some design ideas.

6.1 AutoForms

AutoForms is a library to ease the creation of Graphical User Interfaces (GUI). It does this by using generic programming to construct GUI components.

6.2 Budgets

Budgets is a library of Fudget-like combinators based on the Openlook widget library was developed by Alastair Reid and Satnam Singh. The code has suffered tremendous bit-rot (Does anyone have a copy of ghc-0.16?) but all the reusable ideas are described in the respective paper.


6.3 Embracing Windows

This is a framework for developing graphical user interfaces. It runs under Windows 95 using a modified version of Hugs 1.3.

See the Embracing Windows paper (PDF).

6.4 Gadgets

Gadgets are lazy functional components for graphical user interfaces, developed by Rob Noble under the supervision of Colin Runciman.

See LNCS 982, pages 321-340.

6.5 Gtk+HS

Gtk+HS is a Haskell binding for GTK+. It provides a transcription of the original GTK+ API into Haskell. GTK+ is a modern, portable GUI library and forms the basis of the Gnome desktop project. The binding, while not complete, covers most of GTK+'s core functionality and is ready for use in applications that require a GUI of medium complexity. It was developed under Unix, but should also be usable with the Windows port of GTK+.

See the Gtk+HS homepage.

6.6 Haggis

Haggis is a graphical user interface framework for Haskell, running under the X Window system. It is being developed using the Glasgow Haskell Compiler with its concurrent extensions to achieve more comfortable interaction with the outside world.

See the Haggis homepage.

6.7 iHaskell

iHaskell is a functional wrapper on top of GTK+HS that provides convenience functions for frequently used programming patterns, and eliminates the need for explicit mutable variables.

See the iHaskell homepage.

6.8 Pidgets

Pidgets, developed by Enno Scholz, unifies pictures and widgets in a constraint-based framework for concurrent functional GUI programming.

7 Hackage