[Haskell-cafe] FPGA / Lava and haskell

John O'Donnell jtod at dcs.gla.ac.uk
Sat Jul 12 10:53:14 EDT 2008


Here are some more references relevant to ForSyDe, which looks very

The following paper describes the first version of Hydra, a functional
hardware description language which has gone through many versions,
using several different functional languages.  Hydra uses streams for
modelling synchronous circuits, and the paper contains references to the
first work on streams for hardware description, by Steve Johnson.  Note
that the syntax in this paper isn't Haskell; after all, Hydra was
initially implemented in 1982, and Haskell didn't exist then!


The mid 80s version of Hydra had multiple semantics, including both
behaviour and netlist generation, and it used observable sharing to
implement the netlists.  That's described in the following paper, which
also shows how Hydra can (optionally) use combinators to express layout
and wiring.  The geometric combinators are based on Mary Sheeran's Ruby
language, although the actual combinators in Hydra are a bit different.
The main difference between Hydra and Ruby is that Hydra is functional,
it's based on streams, and the geometric combinators are optional: you
can just use connect the streams together if all you want is a
simulation and netlist but not a layout.


The netlists are represented as a data structure, and can be converted
to a particular netlist notation with a suitable "show" function.  The
paper doesn't use the term "observable sharing" -- that name for the
technique was introduced in Lava -- but the technique was already
implemented and published in 1988.  Lava is essentially a clone of Hydra
the way it was from around 1985 to about 1992.

However, there are a number of drawbacks to using observable sharing for
generating netlists, and some of these are discussed in the following
paper, which also proposes an alternative approach based on program


The program transformation approach to netlist generation has been
implemented using Template Haskell to perform the transformations
automatically, as described in the next paper.  Currently, Hydra uses
this, and it avoids observable sharing.


Here are a few more papers that give an overview of Hydra with some




John O'Donnell

-----Original Message-----
From: haskell-cafe-bounces at haskell.org
[mailto:haskell-cafe-bounces at haskell.org] On Behalf Of Alfonso Acosta
Sent: 09 July 2008 03:27
To: Marc Weber; haskell-cafe at haskell.org
Subject: Re: [Haskell-cafe] FPGA / Lava and haskell

We'll soon (before september, hopefully) relase a deep-embedded
version of ForSyDe[1] which, among other things, has a VHDL backend
(with specific support for Altera's Modelsim and Quartus).

ForSyDe's new implementation is internally based upon the same concept
as Lava (Observable Sharing). However, it has quite a few differences:

* ForSyDe is behavioural (computations are expressed in plain haskell)
* It has support for components
* Is not barely targeted at synchrounous hardware systems (although
the VHDL backend is obviously aimed at them). It has suport for other
MoCs (Models of Computation).

[1] http://www.imit.kth.se/info/FOFU/ForSyDe/

On Tue, Jul 8, 2008 at 7:43 PM, Marc Weber <marco-oweber at gmx.de> wrote:
> Is Haskell still used (in industry as well ?) to write (V)HDL code to
> program FPGAs and create circuits on chips?
> The Chalmers Lava homepage tells abouta Xilinx version which should be
> merged in soon. But on the xilinx homepage there was no reference to
> neither Lava nor haskell..
> I'm thinking about designing a similar tool to www.combimouse.com.
> Sincerly
> Marc
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
Haskell-Cafe mailing list
Haskell-Cafe at haskell.org

More information about the Haskell-Cafe mailing list