2018-2019 Projects

For more details about the projects, see the LSE week pages (2018, 2019), and this poster.


Bits was an educational kernel project which was designed to take a different approach to traditional kernel programming teaching by being highly modular. this enables students to work independantly on different subsystems and therefore increase productivity.

Project is now superseded by STOS


C! (“C-bang”) is a programming language designed with system programming in mind and more specifically kernel programming.

C! is greatly inspired by C, but its syntax differs in a few key points in order to suppress a few ambiguities. Moreover it extends C with constructs which aims at simplifying system programming, such as syntactic sugar for often used constructs. C! also adds object-oriented features.

C! use a compiler-to-compiler model. It does not generate machine code directly. Instead it produces C99 code using a few GNU extensions (eg. for inline assembly) which should be easily compiled using GCC or clang. It enables us to focus on the frontend, and leaves machine code optimisation to tools that are proven reliable.

C! is a few key points:

  • Rationalised syntax
  • Simplified interactions with C
  • Integer size is explicit
  • Usage of integers as bit tables
  • Basic namespace support
  • Classes and objects
  • Macro classes: Add operations on types using an object syntax
  • Many more ideas not yet implemented

A simple C! syntax example:

// A simple fibonacci function in C!

// int<+32> indicates unsigned 32bits integer
fibo(n : int<+32>) : int<+32>
  if (n < 2)
    return n;
  return fibo(n-1) + fibo(n-2);

And now with objects:

// Import some external module "lib"
import lib;

class Point
  x : float<64>; // size also for float
  y : float<64>;

  getX(): float<64> { return x; }
  getY(): float<64> { return y; }

  setX(z : float<64>) { x = z; }
  setY(z : float<64>) { y = z; }
} // no ';' required !

addPoint(a: Point, b: Point) : Point
  // allocation is left to the programmer
  p : Point = Point(lib::alloc(sizeof(Point)));
  // lib::alloc designates the symbol alloc in the lib namespace
  p.setX(a.getX() + b.getX());
  p.setY(a.getX() + b.getX());
  return p;


CNORM is a research C frontend developped in codeworker. Its features include analysing and extending C code. It is used by both the Rathaxes project and the KOOC course.

CNORM is available on Google Code.

KOPUL : Kind Of Pack Unpack Language

KOPUL is an alternate solution to DSL such as ASN1, XDR, IDL, Datascript, Protobuf, and to the pack/unpack functions of Perl. It enables one to describe the layout of all binary data in memory or in a file. It uses LLVM as a backend to be able to either generate an encoding/decoding library for the described file, or interpret KOPUL expressions at runtime thanks to LLVM’s Just In Time capabilities.

KOPUL is available on Google Code.



Rathaxes is a language for “code once, compile everywhere” device drivers development. Basically, it means that the developper writes the behavior of the hardware once. It will then be turned into calls to the kernel API targeted by the compiler.

A majority of currently used OS are developped using C, and so are their kernel APIs, therefore it is the ouput language for Rathaxes. The abstraction layer is done at the language level, and not in the generated C. Output code might look as if it was hand-written by a developper.

Using an internal template library, the compiler is able to translate its generic representation into a OS specific code. The ability to extend this template library enables Rathaxes to provide a driver environment for any OS which has been implemented.

Rathaxes is available on Google Code. It is developped as part of an EPITECH Innovative Project by LSE students.

A proof of concept was presented at the RMLL 2008 and at the T-DOSE 2008. The current goal is to provide a fully working prototype.


STOS is a highly modular monolithic kernel inspired by bits. As such, each feature is not directly integrated into the kernel, but dynamically loaded during execution. The kernel in itself knows how to do one thing and one thing only: load a module and its dependencies.

One of the project objective, besides being completely modular, is to be portable on different architectures. Currently, STOS boots on PowerPC, Sparc64, ARM and x86.

This project is now used as a student project for the GISTRE and SRS specialisation.

STOS public git repository: repository. Course and materials around it: materials


mikro is an experimental Micro Kernel written in C++. This micro kernel intends to be very lightweight and flexible.

The default compiler for mikro is clang.


  • Paging
  • Symmetric Multi Processor
  • Inter Process Communication
  • VM86 (on x86)

Supported architectures:

Currently only i386 is supported but we aim to support x86_64 and armv7.


mikro can be booted using any multiboot compliant bootloader. By default, it comes with a lightweight bootloader called mikrob.



  • libmikro: communication with the kernel
  • minimal libc
  • ultra minimal libc++


Julien Freche, Victor Apercé

Git repositories: