We build tools and libraries, typically written in Haskell, to explore and validate our ideas. The main research challenge we are addressing is improving the high-assurance and high-performance narrative for functional languages. We release our tools open source, under a BSD license, use git for version control, and GitHub for external contributions.

This page is a software-centric view of our research. Please email us if you are interested in contributing, or want more details about a specific tool. We also maintain a Research Projects webpage, which gives the research-centric view of the FPG lab.

Resource Aware DSL Toolkit


Wakarusa is a toolkit for connecting DSLs. It provides support for synthesis to CUDA for execution of GPGPUs, synthesis to VHDL to execution on FPGAS, and synthesis to C for execution on embedded controllers, including the popular Arduino microcontroller. The capabilities are provided via a plugin interface, and Wakarusa provides a resource-aware infrastructure for allowing staged development of remotely executable artifacts.

Rewriting and Refactoring Tools


The Haskell Equational Reasoning Model-to-Implementation Tunnel (HERMIT) is a GHC plugin that allows post-hoc transformations to be applied to Haskell programs, after compilation has started. HERMIT can be used for program-specific optimizations, domain-specific optimizations, or for constructing semi-formal assurance arguments.


The Kansas University Rewrite Engine (KURE) is a Haskell-hosted Domain-Specific Language (DSL) for writing transformation systems based on rewrite strategies. When writing transformation systems, a significant amount of engineering effort goes into setting up the infrastructure to direct queries and rewrites to the desired points in the structure. Strategic programming languages provide most of this infrastructure, allowing the user to focus on the rewrites rules. KURE is a strongly typed strategy control language in the tradition of Stratego and StrategyLib. Its aim is to provide a simple interface for writing reasonably efficient rewrite systems while supporting complex traversal strategies.

Hardware and Software Synthesis

Kansas Lava

Kansas Lava is a Domain Specific Language (DSL) for expressing hardware-oriented descriptions of computations, and is hosted inside the language Haskell. Kansas Lava programs are descriptions of specific hardware entities, the connections between them, and other computational abstractions that can compile down to these entities. Large circuits have be successfully expressed using Kansas Lava, and Haskell’s powerful abstraction mechanisms, as well as generic generative techniques, can be applied to good effect to provide descriptions of highly efficient circuits.

Blank Canvas

Blank Canvas is a Haskell port of the HTML5 Canvas API. Tutorials and examples for the HTML5 Canvas should be trivial to port to this library. blank-canvas works by providing a web service that displays the users’ Haskell commands inside a browser.


Sunroof is a Domain Specific Language (DSL) for dynamically generating JavaScript. Sunroof is build on top of the JS-monad, which, like the IO-monad, allows read and write access to external resources, but specifically JavaScript resources. As such, Sunroof is primarily a feature-rich foreign function API to the browser’s JavaScript engine, and all the browser-specific functionality, like HTML-based rendering, event handling, and even drawing to the HTML5 canvas.

IO-based Observable Sharing and Reification

IO-based reification, as implemented by data-reify, provided the ability to turn recursive structures into explicit graphs. Many (implicitly or explicitly) recursive data structure can be given this ability, via a type class instance. It is a key piece of technolgy used in many reification and sythesis libraries.

Presentation Tools

Story Board is a Haskell replacement for Keynode, PowerPoint or beamer, in the spirit of Racket’s slideshow. The key idea is using JavaScript HTML5 Canvas to render all the text and images. Diagrams can be drawn using Haskell’s diagrams package, The Active Applicative Functor can be used to key animation, and there is good support for laying out both narrative, and highlighted code. There is support for building stand-alone JavaScript, as well as movies of slides.

Debugging and Profiling Tools

Haskell Program Coverage

Haskell Program Coverage (hpc) is a high-fidelity code coverage tool for Haskell, now in widespread use throughout the Haskell community. Hpc includes tools that instrument Haskell programs to record program coverage, run instrumented programs, and display the coverage information obtained. It is included with the standard GHC distribution.

Haskell Object Observation Debugger

Haskell Object Observation Debugger (HOOD) is a small post-mortem debugger for the lazy functional language Haskell. It is based on the concept of observation of intermediate data structures, rather than the more traditional stepping and variable examination paradigm used by imperative language debuggers.

Other Libraries

All these libraries are on hackage.

dotgen A simple interface for building .dot graph files, for input into the dot and graphviz tools. It includes a monadic interface for building graphs.

httpd-shed A trivial web server that can be used to build Ajax and other interactive applications in Haskell. Use scotty instead.

io-reactive An API for generating reactive objects that mimic the reactive model used used in the TIMBER programming language.

marked-pretty A compatible extension to pretty that allows marking and scoping of the output document. A typical application is outputting pretty HTML with style attributes like bold and color.

scotty A Haskell web framework inspired by Ruby’s Sinatra, using WAI and Warp.

sized-types Providing indices, matrixes, sparse matrixes, and signed and unsigned bit vectors.

Retired Projects

These are FPG projects which are, for one reason or another, are no longer under active development.


ChalkBoard is a Haskell-hosted Domain Specific Language (DSL) for image generation and processing. The basic structure was a chalk “Board”, a two-dimensional canvas of values, typically colors, and use a OpenGL backend.