Here’s a non-comprehensive list of all personal or school projects I worked or I’m working on. I chose to show you those projects because I believe they’re the most representative part of my work on my spare time. Feel free to test and give me your feedback!

The portfolio is organized by:

If you want a more comprehensive list of what I do, feel free to visit my github page


Artsy, size-limited, mathematical, underground


Outline 2017 Invitation

Revision 2017

PC Demo

Ranked 19th/26

Two weeks before Revision 2017, I was offered the opportunity to write the Outline 2017 official invitation. I teamed up with some DESiRE members (graphics, music and direction, mostly) and I was the sole programmer, writing the demo in Rust with my spectra demoscene framework.

The overall demo is not impressive and doesn’t look that good, but I’m really proud of it, because it was made in only two weeks and I tested a lot of spectra’s features in the time of writing the production.



Rust demoscene framework

spectra is my Rust demoscene framework. It features a lot of cool features, among:

  • resource hot reloading
  • splines, for animation or anything that requires interpolation
  • timelines
  • EDSL for shading language
  • mesh, models, materials, camera, lights, etc.
  • easy setup
  • and a lot of other cools features

Currently, the project is a massive work in progress.


Céleri Rémoulade

Evoke 2016

PC Demo

Ranked 14th/18

My third demoscene production – and first PC demo release. Released at Evoke 2016 (Köln, Germany), and ranked 14th / 18.

It is a one-man production that I wrote entirely in Rust using my luminance graphics framwork, OpenAL and libvorbis



Rust graphics framework

I learned Rust by March, 2016. Fallen in love with that language, which is very similar to Haskell with the control over the memory and predictive performance as an extra argument, I decided to jump in and migrate as fast as the very next day my Haskell luminance framework. The migration took me some time, because Rust doesn’t directly match to Haskell. For instance, Haskell has more powerful abstraction tools, forcing me to adapt the abstractions and hack around for several hours with Rust’s constructs. As an example, Haskell’s existential quantification, which doesn’t exist in Rust – I mapped it by trait object, btw.

The project starts to be mature, thanks to all the code I wrote in Haskell (36 releases), and that I’m writing a demoscene production with it. So I’m testing luminance in real conditions, changing the interface on the fly to make it more comfortable and benchmarking.



Haskell graphics framework

luminance is born from the ashes of quaazar. The aims of luminance are simple: it’s a wrapper over graphics technologies (OpenGL) designed to be stateless, type-safe and simple.

I think that project was the most followed of mine. I got feedback from people, a lot of talks on reddit and IRC; I was asked for help by people wanting to hear from the experience of “making something unsafe and stateful safe and stateless”, because that’s exactly what luminance is all about.

After more than 36 releases, I decided to migrate the framework into its Rust version.




Haskell demoscene framework

quaazar was my first attempt at serious graphics programming in Haskell for demoscene purposes. After coming to the realization that I was building something way too much generic, I decided to discontinue the project and extract a sub part of it (luminance).


Outline 2014

Newschool / Streaming Music

Ranked 15th/18

Ionosphere is my very first attempt at music making. Back from VIP2014, I decided to go wild, buy Renoise 3.0 and make a tiny but lovely song in 4 hours.


Heat Station

Evoke 2013

PC Intro 64k (Windows / Linux)

Ranked 4th/4

Heat Station is my second 64k intro, released at Evoke 2013. I wrote it in C++ with skyoralis, my demoscene 3D realtime engine at that time. It was a test-release for my engine, and I had to rush the Windows port, so take it as-is!

It ranked 4th/4, behind Farbrausch, Inque and Stroboholics.


Lightning Road To Liquid Radiator

Outline 2013

PC Intro 64k (Linux)

Ranked 4th/9

Lightning Road To Liquid Radiator is my very first release as a demoscener. It’s a Linux 64k intro I released at Outline 2013 in the PC combined demo/intro compo (demo, 4k, 64k); May 9th-12th. It ranked 4th/9. I’m pretty proud of it. The binary file weighs 42k and has no data at all.

If you plan to test it on your own Linux machine, you’ll find some hints in the README file if you issue any trouble.




C++ demoscene framework

My very own demoscene engine. It’s designed to help me write my demoscene releases, especially 64k intro. Written in C++11, OpenGL and GLSL.

Up to now, no public version is available. The first intro using skyoralis was Heat Station, but it actually used less than 10% of its features.

I decided to close that project because I moved it into Haskell.


Personal projects, contributions, Open Source

hid & msi-kb-backlit


R.E. of hardware (HID MSI laptop keyboard LEDs)

Those two projects originate from my actual laptop, a MSI GS60 Ghost Pro, with backlit keyboard. The colors are customizable and MSI has provided the users with a tool – SteelEngine – to customize them. However, that tool doesn’t work at all under Linux nor Mac OSX. I decided to understand how the protocol is used, and write my own tool. I also wrote the hid Haskell library to help me write that tool, and both the packages are available as BSD-3 softwares.



N-ary spline interpolation

A Haskell package to make it easy to build splines. The project has received an interest from Haskellers. The name comes from the verb “to smooth”, which we can assimilate to smoothed curves.



OpenAL Haskell binding

I maintain an OpenAL Haskell binding.



This very website

This website is a great example of fun I have on my spare time. Written in pure Haskell.

IRC bot


Rust & Haskell IRC bot

A bot over IRC. It’s used to leave message to someone who’s off, to administrate a channel, to parse and give the title behind URLs and it features a stupid yet funny Markov chain feature that learns from people talking in a given channel.



A Haskell pure logger

A logger solution in Haskell. It exports a typeclass and a monad transformer for ease.

Because ghc-mod uses it, monad-journal gets a lot of downloads, and I’m pretty proud of it then!



Haskell FModEx binding

The official Haskell FModEx binding. Up to now I maintain the raw binding. It’s intended to be wraped up again (like OpenGLRaw). Up to now, the binding works but not all functions are exported.

2017 note: abandonned project.



A Haskell portfolio generator

leaf is a portfolio generator that aims to be really simple to use. My first porfolio was written thanks to that tool! It enables you to write your portfolio in Markdown, so it’s really convenient to use. You can find all directions to get started on Github.



A Haskell fractal viewer!

phraskell is a fractal viewer. For now, it only supports Mandelbrot set, but is planned to support more and more fractal types. It aims to be user-friendly, and includes these features:

  • fractal colorschemes (not yet)
  • different kinds of fractal representations (standard, buddhabrot, etc.)
  • (not yet)
  • zoom with a zoom-frame in order to see what you zoomin
  • specify the fractal progression at runtime (not yet)
  • change the colors at runtime (not yet)
  • screenshot (not yet)
  • and others! (obviously not yet at all)

It’s written in Haskell, and is my first real Haskell program.

01/07/13 update: I’ve saved that project for later since I’m very busy right now.



Home-made D builder

sdb stands for Simple D Builder. It’s a D builder you can use the same way as you do with rdmd.

Actually, you don’t want to use sdb. Why, would you say? Well, first, even if it’s quite okay for a simple builder, rdmd is likely far away better. Furthermore, I haven’t updated nor even read any D lines from sdb for a while. Finally, I don’t plan to do so in the future. You can consider sdb* v0.9.5 the latest version. Forever (woah that’s so sad :( ).


University, homework, fun, pizza


Battle Robot


School Java AI game

This is a Java project I had to complete the semester before the last one at ”IUT”. Our teacher wrote a basic labyrinth and an interface for a player, and we have to present an implementation that solves the labyrinth in local view (the player only knows what rooms are next to him). Then all implementations were put against each other like in a competition, and the best algorithm was found regarding some traits like number of moves and so on.

The first part of the project was to write a correct implementation of the player movements. The less moves the player does to find the exit point the more points he’s given.

The second part of the project was to alter the implementation of our algorithm. Indeed, since the teacher had added health points to players and traps that decrease life, we had to implement a brand new way to run the labyrinth. The less moves and more health points left at the exit point the more points he’s given.

I won both the two parts. It was meant to because all folks used random strategies like “the right handed way” or “I have no idea where I’m going to”, while I implemented connected and oriented graphs, with local pseudo-deconnections (isolation of known areas of the labyrinth to make it less dense) and path finding based on complexe heuristics. It was a really nice project!

The archive contains the java code you can execute, some labyrinths to test (as .txt files), and two papers I have to write to explain all my choices.


Rewrite of “Game Of Life”


C++ cellular automaton

Game of Life is a cellular automaton invented by Jon Conway in 1970. At the “IUT”, we had to write our very own version, for the second semester. We had to implement brand new features, such as being able to change the life rules through a graphic interface.

We also had to write that project in imperative C++, with the SFML library and use a MV (MVC without C) software architecture.

Note: I tried – for the fun – compiling it again. Turns out that the latest version of SFML breaks retrocompatibility, then it’s not sure you are able to compile it as well. Sorry then. If you really want to use it, it’s open source, so write a patch on github, and I’ll accept the pull request! :)


Rewrite of “Bejeweled”


C++ game

Bejeweled is a game with a 8x8 wired diamonds grid of different colors, randomly set. Written in *imperative C++*, with a Top10 ranking system, multiplayer, and so on…


Rewrite of “Pong”


C++ game

We don’t introduce this game anymore. Written in imperative C++. With fancy effects. No just kidding. Written in one hour :D.