Implementations of Curry

Since the development of Curry is an international initiative by various research groups, several implementations are available and/or under development. Some of them are listed below.


The Portland Aachen Kiel Curry System (PAKCS) is an implementation of Curry jointly developed by the Portland State University, the Aachen University of Technology, and the University of Kiel. PAKCS is an interactive system to develop Curry programs. It has a simple user interface, some interactive debugging features and various useful tools. Moreover, it also contains constraint solvers for arithmetic, Boolean, and finite domain constraints, an implementation of ports for concurrent and distributed applications (which is described here), libraries for implementing graphical user interfaces (described here or here), libraries for programming dynamic web pages in a high-level manner (described here or here), among other libraries for application programming (e.g., XML processing, meta-programming, sets, system access). PAKCS compiles Curry programs into Prolog programs (it has also other back ends, like a compiler from Curry into Java or a simple interpreter implemented in Prolog , but these are no longer maintained).

PAKCS (release 2.0.1) is also available as an Ubuntu 18.04 package. If you run this OS, PAKCS can be installed with the command

  > sudo apt install pakcs

Contact: Michael Hanus


The KiCS2 is an implementation that translates Curry into Haskell. KiCS2 supports several search strategies to encapsulate search (e.g., depth-first, breadth-first) and various extensions of Curry like encapsulated search via set functions and functional patterns. It also supports the same libraries and packages as PAKCS so that it has been used for various applications.

Contact: Michael Hanus


The Münster Curry Compiler (MCC) is a mature native code compiler for Curry which conforms to the Curry report except for committed choice which is not supported. Since release 0.9.5 there are no longer any restrictions to the encapsulated search. Supported extension to the Curry language include disequality constraints, recursive pattern bindings, and IO exceptions. A distinctive feature of the Münster Curry compiler is the integration of a declarative debugger of wrong answers. An interactive Curry environment and a make-like build tool for Curry are included in the distribution. Besides the Gnu C compiler no other software is needed to compile and run Curry programs with the Münster Curry compiler. Papers describing this implementation can be found here .

Contact: Wolfgang Lux


Sprite is a compiler and runtime for Curry programs. It is based on the Fair Scheme, a compilation strategy for transforming declarative, non-deterministic source programs into imperative, deterministic code. As the Fair Scheme emphasizes operational completeness, Sprite aims to produce all values of Curry programs, subject only to practical limits such as the amount of memory available.

Relevant papers:

Compiling a Functional Logic Language: The Fair Scheme

A New Functional-Logic Compiler for Curry: Sprite

Contact: Sergio Antoy and Andy Jost


The FLVM is a virtual machine for functional logic computations. Curry programs are compiled into FLVM instructions that are executed by the FLVM interpreter that is implemented in Java. A feature of the FLVM is the implementation of a fair (i.e., operationally complete) execution of nondeterministic computations and sharing of deterministic computations over nondeterministic branches.

Contact: Sergio Antoy


The Sloth system is a compiler which translates Curry programs into Prolog programs. It is under development at the Technical University of Madrid . The Sloth system has an interactive interface to load programs, evaluate expressions etc.

Contact: Julio Marino


The Zinc Compiler is an experimental compiler for an extended version of Curry and based on the Münster Curry Compiler (MCC). Type classes are the most notably extension at the moment. The Zinc project is being developed at the University of Oviedo by Diego Berrueta.

Contact: Diego Berrueta (diego AT berrueta DOT net)

Older Implementations

Below are some older implementations of Curry that are no longer actively maintained.


The Kiel Curry System (KiCS) is a compiler that translates Curry into Haskell. KiCS provides several strategies to encapsulate search (e.g., depth-first, breadth-first). It also contains an advanced debugging system based on representing the execution of a Curry program in a programmer-friendly call-by-value manner.

Contact: Bernd Braßel


Curry2Java is another back-end for PAKCS which translates Curry programs into Java programs. It uses Java threads to implement the concurrent and non-deterministic features of Curry. A paper describing this implementation can be found here.

Contact: Michael Hanus


Narrowminder is an implementation environment (back end) for functional logic programming and related languages. It can compile Curry programs into Java code and implements a complete and efficient implementation of needed narrowing (breadth-first search). It can be also used as a back end for related languages since it is based on a language-independent intermediate XML representation of FlatCurry programs.

Contact: Sergio Antoy


The TasteCurry interpreter is a slow but fairly complete implementation of Curry. It is an interpreter written in Prolog and does not implement sharing. Thus, it is only intended to test smaller Curry programs.

Contact: Michael Hanus


UPV-Curry is a Curry interpreter developed by the ELP group at the Technical University of Valencia ( UPV ). It is implemented in Prolog and has an interactive interface to load programs, evaluate expressions etc. There exists also a larger application implemented with this interpreter which simulates the ecological behavior of the Segura river's basin.

Contact: Maria Alpuente


CIDER is a graphical programming and development environment for Curry. CIDER is intended as a platform to integrate various tools for analyzing and debugging Curry programs. CIDER is completely implemented in Curry. Although the graphical debugger contains an interpreter for executing Curry programs, it is only intended for visualizing the execution of smaller programs and not for executing large programs.

Contact: Michael Hanus

/srv/dokuwiki/currywiki/data/pages/implementations/overview.txt · Last modified: 2020-11-30 10:51 by mh
Back to top
CC Attribution-Noncommercial-Share Alike 4.0 International
Driven by DokuWiki Recent changes RSS feed Valid CSS Valid XHTML 1.0