The helm package

[Tags: library, mit]

A functionally reactive game engine, with headgear to protect you from the headache of game development provided.

[Skip to ReadMe]


Versions0.1.0, 0.2.0, 0.3.0, 0.3.1, 0.4, 0.5.0, 0.6.0, 0.6.1, 0.7.0, 0.7.1 (info)
Change logNone available
Dependenciesbase (==4.*), cairo (>=0.12.4 && <1), containers (>= && <1), elerea (>= && <3), filepath (>= && <2), SDL (>=0.6.4 && <1) [details]
Copyright(c) 2013, Zack Corr
AuthorZack Corr
MaintainerZack Corr <>
CategoryGame Engine, FRP
Home page
Bug tracker
Source repositoryhead: git clone git://
UploadedSat Jul 13 13:43:11 UTC 2013 by ZackCorr
Downloads2405 total (58 in last 30 days)
1 []
StatusDocs uploaded by user
Build status unknown [no reports yet]




Maintainers' corner

For package maintainers and hackage trustees

Readme for helm-0.3.0



Helm is a functionally reactive game engine written in Haskell and built around the Elerea FRP framework. Helm is heavily inspired by the Elm programming language (especially the API). All rendering is done through a vector-graphics based API. At the core, Helm is built on SDL and the Cairo vector graphics library. The plan is to change to a more robust setup in the future, such as a lightweight homebrewed renderer built on OpenGL. But for now, Cairo performs pretty well.

In Helm, every piece of input that can be gathered from a user (or the operating system) is hidden behind a signal. For those unfamiliar with FRP, signals are essentially a value that changes over time. This sort of architecture used for a game allows for pretty simplistic (and in my opinion, artistic) code.



The simplest example of a Helm game that doesn't require any input from the user is the following:

import FRP.Helm
import qualified FRP.Helm.Window as Window

render :: (Int, Int) -> Element
render (w, h) = collage w h [move (100, 100) $ filled red $ square 64]

main :: IO ()
main = run $ do
  dims <- Window.dimensions

  return $ fmap render dims

It renders a red square at the position (100, 100) with a side length of 64px.

The next example is the barebones of a game that depends on input. It shows how to create an accumulated state that depends on the values sampled from signals (e.g. mouse input). You should see a white square on the screen and pressing the arrow keys allows you to move it.

{-# LANGUAGE RecordWildCards #-}

import Control.Applicative
import FRP.Elerea.Simple
import FRP.Helm
import qualified FRP.Helm.Keyboard as Keyboard
import qualified FRP.Helm.Window as Window

data State = State { mx :: Double, my :: Double }

step :: (Int, Int) -> State -> State
step (dx, dy) state = state { mx = (realToFrac dx) + mx state,
                              my = (realToFrac dy) + my state }

render :: (Int, Int) -> State -> Element
render (w, h) (State { .. }) = collage w h [move (mx, my) $ filled white $ square 100]

main :: IO ()
main = run $ do
  dims <- Window.dimensions
  arrows <- Keyboard.arrows
  stepper <- transfer (State { mx = 0, my = 100 }) step arrows

  return $ render <$> dims <*> stepper

Installing and Building

Helm requires GHC 7.6 (Elerea doesn't work with older versions due to a compiler bug). To install the latest (stable) version from the Hackage repository, use:

cabal install helm

Alternatively to get the latest development version, you can clone this repository and then run:

cabal install

You may need to jump a few hoops to install the Cairo bindings (which are a dependency), which unfortunately is out of my hands.


Helm is licensed under the MIT license. See the LICENSE file for more details.


Helm would benefit from either of the following contributions:

  1. Try out the engine, reporting any issues or suggestions you have.

  2. Look through the source, get a feel for the code and then contribute some features or fixes. If you plan on contributing code please submit a pull request and follow the formatting styles set out in the current code: 2 space indents, documentation on every top-level function, favouring monad operators over do blocks, etc.

The following is a list of areas I want to tackle in the future, and possible targets that others could try for: