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.
I’m a demomaker. Here’s my pouët page.
I joined the demoscene world a few times ago, but my first release was Lightning Road To Liquid Radiator, at Outline 2013 in the combined PC intro/demo compo.
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 framework, OpenAL and libvorbis.
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.
By the time of writing, it’s been 10 releases. I don’t blog a lot about it because I’m intensively writing my demoscene release. But be sure, I will blog about it and write several articles on how to dig in and how to use luminance.
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 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.
quaazar was my first attempt at graphics programming serious stuff 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).
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.
This is what came out.
Heat Station is my second 64k intro, released at Evoke 2013. I wrote it in C++ with skyoralis, my demoscene 3D realtime engine. I released it in Germany, at Evoke 2013. 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 is my very first release as a demoscener. It’s a GNU/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.
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 need to make a bigger production before releasing skyoralis in public.
I decided to close that project because I moved it into Haskell.
In that part of my portfolio, you’ll find personal project I made on my spare time to solve people’s problems or to simply have fun.
You can find all the projects I made for a community on my github.
An effort to bring Haskell a type-safe, strongly-typed and stateless graphics framework. It’s built over OpenGL.
Currently, no public release is available, but it will eventually land in hackage sooner or later. A lot of people are interested in the effort I make with luminance – around 50 stargazers and 12 watchers on github. I also often write articles about luminance on my blog to keep people informed.
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.
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.
I maintain an OpenAL Haskell binding.
This website is a great example of fun I have on my spare time. Written in pure Haskell, nothing else – yeah, a bit of CSS.
A tellbot over IRC. It’s used to leave a message to someone who’s off.
The latest version also integrates a remote control over IRC using a password.
reactant is my very first attempt to FRP in Haskell. I designed the library to be simple and not limited to
IO. I learned FRP with reactive-banana.
Up to now, I’m still working on it.
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!
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.
You can contribute by forking the Github repository, editing the
Sound.FModEx.Raw.Core.Functions file (you can follow the syntax I use for the first functions in that file), then push pull requests! I’ll accept them for sure!
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.
For those who’d like to contribute, you can push pull requests on the github page.
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:
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.
sdb stands for Simple D Builder. It’s a D builder you can use as well 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 :( ).
OpenGLRawgen is a nice C OpenGL Specification to Haskell generator. It reads from XML and outputs regular and convenient Haskell modules.
I submitted some patches, but nothing important though. I just help to fix issues.
Derelict3 is a collection of D binders over C dynamic librairies. I especially contributed to port some librairies for Mac OSX and Windows to make things more portable.
You can find aldacron’s Derelict3 here.
DerelictBASS is not part of the Derelict3 library, though it depends on its link system. It’s a nice D binder written by p0nce over the C sound library called *BASS.
You can find DerelictBASS here, and C BASS here.
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.
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! :)
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…
We don’t introduce this game anymore. Written in imperative C++. With fancy effects. No just kidding. Written in one hour :D.