Skip to content
Higher level programming in C
C Lua C++ Java Python JavaScript Other
Branch: master
Clone or download

Latest commit

orangeduck Merge pull request #127 from theosotr/fix
Fix fault in incremental build
Latest commit c0ba62c Jan 1, 2020


Type Name Latest commit message Commit time
Failed to load latest commit information.
benchmarks Linux merge Jun 15, 2015
examples update example. return EXIT_SUCCESS Nov 7, 2018
include renamed lock_try to trylock Jan 27, 2017
src fixed warning in cast Oct 14, 2018
tests Cello should now work on environments without threads. Sep 10, 2015
.gitattributes added gitattributes Dec 9, 2013
.gitignore Windows merge WIP Lists debugging Feb 5, 2015 Started hacking out autotools Jul 22, 2013
Makefile Fix fault in incremental build Jan 1, 2020 Fix "Fat Pointer" link Apr 16, 2019 Moved exception mechanics to own location Jun 15, 2015


Cello is a library that brings higher level programming to C.

By acting as a modern, powerful runtime system Cello makes many things easy that were previously impractical or awkward in C such as:

  • Generic Data Structures
  • Polymorphic Functions
  • Interfaces / Type Classes
  • Constructors / Destructors
  • Optional Garbage Collection
  • Exceptions
  • Reflection

And because Cello works seamlessly alongside standard C you get all the other benefits such as great performance, powerful tooling, and extensive libraries.


#include "Cello.h"

int main(int argc, char** argv) {

  /* Stack objects are created using "$" */
  var i0 = $(Int, 5);
  var i1 = $(Int, 3);
  var i2 = $(Int, 4);

  /* Heap objects are created using "new" */
  var items = new(Array, Int, i0, i1, i2);
  /* Collections can be looped over */
  foreach (item in items) {
    print("Object %$ is of type %$\n",
      item, type_of(item));
  /* Heap objects destructed via Garbage Collection */
  return 0;
#include "Cello.h"

int main(int argc, char** argv) {
  /* Shorthand $ can be used for basic types */
  var prices = new(Table, String, Int);
  set(prices, $S("Apple"),  $I(12)); 
  set(prices, $S("Banana"), $I( 6)); 
  set(prices, $S("Pear"),   $I(55)); 

  /* Tables also support iteration */
  foreach (key in prices) {
    var val = get(prices, key);
    print("Price of %$ is %$\n", key, val);
  return 0;


Learning Resources.

Articles about its creation and internal workings.

More Examples

#include "Cello.h"

int main(int argc, char** argv) {

  var items = new(Array, Int, 
    $I( 8), $I( 5), $I(20), 
    $I(15), $I(16), $I(98));

  /* Iterate over indices using "range" */
  foreach (i in range($I(len(items)))) {
    print("Item Range %i is %i\n", i, get(items, i));

  /* Iterate over every other item with "slice" */ 
  foreach (item in slice(items, _, _, $I(2))) {
    print("Item Slice %i\n", item);
  return 0;
#include "Cello.h"

/* Define a normal C structure */
struct Point {
  float x, y;

/* Make it compatible with Cello */
var Point = Cello(Point);

int main(int argc, char** argv) {
  /* Create on Stack or Heap */
  var p0 = $(Point, 0.0, 1.0);
  var p1 = new(Point, $(Point, 0.0, 2.0));
  /* It can be shown, compared, hashed, etc...
  ** p0: <'Point' At 0x000000000022FC58>
  ** p1: <'Point' At 0x00000000004C7CC8>
  ** cmp: 1
  ** hash: 2849275892l
  print("p0: %$\np1: %$\ncmp: %i\nhash: %ul\n",
    p0, p1, $I(cmp(p0, p1)), $I(hash(p0)));
  /* And collected by the GC when out of scope */
  return 0;


  • Why does this exist?

I made Cello as a fun experiment to see what C looks like hacked to its limits. As well as being a powerful library and toolkit, it should be interesting to those who want to explore what is possible in C.

  • How does it work?

I recommend reading A Fat Pointer Library to get an overview of how Cello works.You can also peek at the source code, which I'm told is fairly readable, or ask me any questions you like via e-mail.

  • Can it be used in Production?

It might be better to try Cello out on a hobby project first. Cello does aim to be production ready, but because it is a hack it has its fair share of oddities and pitfalls, and if you are working in a team, or to a deadline, there is much better tooling, support and community for languages such as C++.

  • Is anyone using Cello?

People have experimented with it, but there is no high profile project I know of that uses it. Cello is too big and scary a dependency for new C projects if they want to be portable and easy to maintain.

  • Can I get involved?

Yes! That would be great. If you do anything with Cello I'd love to know, you can e-mail me at, or help with the development at the Cello github repo. Contributions are very welcome.

  • Who are you?

Hello! I'm Daniel Holden. You many know me from a book I wrote or my personal website. I also have a rarely updated twitter account.

You can’t perform that action at this time.