FunGEn: Haskell's oldest 2D game engine, still alive but barely maintained

What FunGEn solves and who it is for

FunGEn is a small, cross-platform 2D game engine written in Haskell. It targets programmers who want to write games without dealing directly with OpenGL and GLUT boilerplate. The README positions it as one of the easiest ways to start Haskell game development because it has very few dependencies and ships with two example games. It is not a general-purpose engine. It handles object initialization, updating, rendering, and grouping, plus keyboard and mouse input, collision detection, and bitmap loading. The intended audience is hobbyists and learners, not teams building large commercial titles. The engine's age shows in its design: it was created in 2002, and its philosophy is to let the programmer specify when game events happen, rather than how they are implemented. That is a reasonable fit for small, deterministic games like Pong or simple platformers.

The core mechanism: objects, maps, and time

The engine's architecture, as visible in the README, centers on game objects. You initialize, update, remove, render, and group objects through provided routines. The background is defined as a map, with support for texture-based maps and tile maps. Input handling reads the keyboard and mouse, and collision detection is built in. Time-based functions and pre-defined game actions are included, which suggests a loop where you update object states based on elapsed time and then render them. The README does not explain the internal data flow beyond this, but the mention of a tutorial and Haddock API docs points to a specific API. One notable design choice is that the engine is built on HOpenGL, the Haskell binding to OpenGL and GLUT. That means every game window and input event goes through GLUT's callback model. For a Haskell programmer, this creates a tension: the engine tries to offer a functional specification style, but the underlying GLUT is imperative. The 2002 status note admits that early versions were not as functional as desired, and the project moved toward a specification-based approach inspired by the Clean Game Library. How well that transition succeeded is not documented in the README, so you would need to inspect the source to judge.

Getting it running: commands and dependencies

Installation requires OpenGL C libraries first. On Ubuntu or Debian, the README gives this command: sudo apt install freeglut3-dev. If you are unsure whether they are installed, you can try the next step and watch for missing C library errors. The latest released version is installed with stack install FunGEn or cabal install. After installation, make sure ~/.local/bin (for stack) or ~/.cabal/bin (for cabal) is in your shell PATH. Then you can run three example games: fungen-hello, fungen-pong, and fungen-worms. For the latest unreleased code, you clone the repository, run stack build or cabal build, and then use stack exec fungen-hello, stack exec fungen-pong, or stack exec fungen-worms. The release history shows version 1.1.1 from October 2020, with earlier releases from 2016. The changelog is available on Hackage. This is a straightforward build process, but the dependency on system OpenGL libraries is a real barrier on some platforms, especially Windows, where the README mentions a Windows equivalent for the PATH but does not detail the library installation.

Limitations: no sound, no issue tracker, thin maintenance

The most obvious limitation is the lack of sound support. The README explicitly lists it and suggests adding OpenAL, elerea, or sdl2-mixer separately. That means any game you build with FunGEn must handle audio through a second library, which complicates the engine's simplicity. Another limitation is the maintenance model. Simon Michael provides infrequent maintenance, and there is no issue tracker and no email support. Support happens through the #haskell-game chat on Matrix or Libera IRC, where the maintainer's nick is sm. This is a fragile setup for a production project. If you hit a bug, you cannot file a report; you must ask in a chat room and hope someone responds. The README also states that the maintainer does not have time to do more with it and is looking for maintainers or co-maintainers. That is a clear signal that the project is not actively developed. The last push was in October 2020, and the most recent release is from that date. For a game engine, this means you are on your own for any fixes or features.

A real alternative: SDL2 bindings

A practical alternative to FunGEn is the SDL2 binding family for Haskell, such as sdl2 and sdl2-mixer. The difference in approach is fundamental. FunGEn is built on OpenGL and GLUT, which gives you a fixed set of facilities for 2D rendering but leaves audio out. SDL2 is a multimedia library that handles windowing, input, audio, and 2D rendering in one API. With sdl2, you get sound support out of the box, and you do not need to install freeglut3-dev. The cost is that SDL2 is more low-level: you manage the main loop yourself, and you do not get the object grouping or collision detection that FunGEn provides. So the trade-off is between a high-level engine with gaps and a lower-level library that is more complete and actively maintained. If you want to avoid the imperative feel of GLUT, you might also consider a purely functional FRP library like elerea, but that is a different paradigm entirely. For most new projects, SDL2 is the safer choice because it has a larger user base and regular updates, whereas FunGEn's last release is from 2020 and its maintainer is openly seeking a successor.

Maintenance and upgrade cost

The maintenance cost is low in terms of dependencies, but high in terms of your own responsibility. The engine has very few dependencies, which makes it easy to build and to inspect. However, the lack of an issue tracker and the infrequent maintenance mean you must be prepared to read the source code and patch it yourself. The changelog on Hackage shows changes between versions, but the most recent release is 1.1.1 from October 2020. There is no indication of future releases. The README's call for maintainers suggests that the project could stall completely. Upgrading to a newer version, if one ever appears, would require checking the changelog and possibly adapting to API changes. The license is BSD-3-Clause, which is permissive and allows you to fork and modify the code without many restrictions. That is a positive for long-term use: you can take the code and maintain it internally if needed. But you should verify that the Haddock API docs are complete and up to date before relying on them. The README links to a tutorial and to Andre's old site, which may contain outdated information from 2002.

Editorial conclusion

Adopt FunGEn if you want a minimal, dependency-light Haskell engine for learning or for small 2D projects with bitmap graphics and simple input. Do not use it for sound, complex maps, or production games. Before adopting, verify that the OpenGL C libraries are present on your system and that you can run the example games. Check the Hackage page for the latest version and the changelog for unresolved issues. Since there is no issue tracker, you must rely on the #haskell-game chat for support, and be prepared to maintain the code yourself.

Frequently asked questions

Official sources

1. Official README
2. Project repository
3. Release notes