Skip to content


Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fancy is a dynamic, object-oriented programming language inspired by Smalltalk, Ruby, Io and Erlang that runs on the Rubinius VM.
Fancy Ruby JavaScript Other

This branch is 19 commits ahead, 1907 commits behind master

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.


The Fancy Programming Language
(C) 2010 Christopher Bertels <>


Fancy is a dynamic, object-oriented programming language heavily
inspired by Smalltalk, Ruby and Erlang. It will support dynamic code
evaluation (as in Ruby & Smalltalk), concurrency via the actor-model
and many more features yet to be implemented.


It’s still in development, the implementation consisting of an
interpreter written in C++ and an unfinished bytecode compiler for the
Rubinius VM (

For some example code (that can be successfully executed), have a look
at the examples/ directory.

There's also lots of test coverage code. Have a look at the tests/
directory for these. The tests are written in FancySpec, a simple
testing library (somewhat similar to Ruby's RSpec). FancySpec's
implementation can be viewed in lib/fancy_spec.fnc.


Compiling / Installing from source:


- libgc ( Fancy uses BoehmGC for garbage collection ).
- GNU Autotools: autoconf, automake and libtool.
- GNU Make.
- GNU Bison ( version 2.4 and higher otherwise you will get a Segmentation fault ).
- GNU Flex.

NOTE: BoehmGC - It's included in the vendor/gc directory
           but you can also get it here:

Given the tools & libraries mentioned above, Fancy _should_ build without problems
on most *nix systems. We successfully have built Fancy on Debian & Ubuntu, OpenSuSE
and Mac OS X 10.5 and 10.6.

Standard building procedure:

Building Fancy is just that easy:

  $ cd <fancy_source_path>
  $ ./configure
  $ make && make test

NOTE: if you have problems with ./configure script or make utility just try:

  $ autoreconf --install --force

and try again.

Some technical information:

What's already working?

  - Class definitions
    (including nested classes that work like modules / namespaces)
  - Instance & class method definitions
  - String, Integer, Float, Array, Hash (HashMap) & Block literals
  - Method & Operator calls
  - Instance & class variable access
  - Dynamic getter and setter method definitions (similar to Ruby's attr_acessor)
  - Loops
  - Support for closures via Blocks (it works but there's definately
    room for performance improvements)
  - Local & non-local returns from Blocks & Methods
  - File reading and writing
  - Class-Mixins (including methods of one class into another)
  - Exception handling (try, catch, finally & retry)
  - There's also an experimental bytecode compiler for the Rubinius VM
    (see rbx_bytecode branch). It's still in development and not
    finished yet.

What's still missing?

  - Pattern matching
  - Concurrency stuff (Actor-model based concurrency, Futures etc)
  - Some more advanced stuff, e.g. runtime inspection of method calls
    via MethodContext etc. (saved for later)

How is it implemented?

  - Currently, theres a quite simple interpreter written in
    non-idiomatic C++.
    Sorry, I'm not a big C++ programmer. It should be fairly easy to
    read though.

  - It uses the BoehmGC for garbage collection.

  - The lexer & parser are built with GNU Flex & GNU Bison.

  - We're currently working on a bytecode compiler for the Rubinius
    VM. See the rbx_bytecode branch for our current progress on that.



vendor/gc: GC Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
           For more information see the vendor/gc directory.

Fancy is licensed under the terms of the GNU LGPL v3. For more
information on licensing issues have a look at the LICENSE file.
Something went wrong with that request. Please try again.