I build AI products. This site is one.

What I built

• Created the project and put it online
• The chatbot's brain: how it searches, and how it answers
• Reworked the chatbot's page

• Created the project and deployed it on Cloudflare Pages
• The chat function and most of the RAG: Astra DB, the similarity threshold, the system prompts
• Contextual actions and quick suggestions in the API, and a reworked AI page

How to play

1. Move over the screen to fly the white ship.
2. Player 2, in orange, covers you.
3. Draw enemies in the grid: they arrive in that shape.

What I built

• The level editor, and loading its levels in the game
• Automatic checks every time the team changed the code
• The written guide to how players talk to the server

• The map editor in Python, with JSON export
• JSON level loading on the game and on the server
• The CI pipeline on GitHub Actions
• Protocol and editor documentation, and the server-side speed boost

The grid is a browser version of the editor I wrote. The real one is a desktop tool.

How to play

1. Click a look: Smooth, Pixel or Text. The game doesn't stop.
2. Player 2 is playing. Press an arrow key to take over.
3. On a phone, swipe on the screen.

What I built

• The Snake game
• The first version of its three looks
• The pictures, and the guide for other developers

• Snake: keyboard control, wrapping edges, score
• The first version of all three renderers: SFML, SDL2, ncurses
• Sprites for SFML and SDL2, and the interface documentation

The dotted line is the route Player 2 has planned to the apple.Redrawn for the browser: one game state, three renderers. Player 2 plans its route with a breadth-first search.

How to play

1. Hold the mouse button on the screen, or the space bar, to fly up.
2. Let go to drop.
3. Grab the coins, avoid the lasers.

What I built

• The server and its connections to the players
• Reading the level file
• Coins, obstacles and collisions
• Deciding who wins and who loses

• The server: connections and players, with poll()
• Loading the ASCII map and scaling it to 1920 by 1080
• Coins, obstacles, collisions and scrolling
• Win and lose conditions

The box under the game shows the referee's numbers, live.The panels under the game are the server's side. Message names are the real ones; the values are computed here.

How to play

1. Press an arrow key or a button: your command joins the blue queue.
2. The server runs it when its time is up. Walk to the gold food and take it.
3. Send more than 10 commands at once and the server answers ko.

What I built

• The server that every AI player and the 3D view connect to.
• The waiting line of commands for each player, with its timing.
• Walking forward, and sending a message to all the other players.

• Server structures, the socket and poll() loop, client connection and team checks, argument parsing.
• Graphical protocol commands: msz, tna, bct, mct, ppo, pnw.
• The deferred command queue of each client: 10 places, run time from the frequency.
• Forward, Broadcast and Connect_nbr, memory leak fixes, and a network class in the 3D client.

Rebuilt for the browser: a simplified copy of the server rules runs in this page. The real server is a C program that talks to its clients over TCP.

How to play

1. Pick a champion. Player 2 picks the other one.
2. Watch both write into the shared memory. A program that stops saying live is removed.
3. Pause, then Step, to read the instruction your program runs next.

What I built

• Loading each champion from its file and placing it in the shared memory.
• Reading each instruction from the bytes, then running it after its delay.
• Keeping track of who said live, to know who is still in the game.

• Reading the .cor champions and converting between decimal and hexadecimal.
• Creating the arena and placing the champions in it.
• Decoding instructions, saving each live, and the and, or, xor and aff instructions.
• Instruction delays and error handling.

Rebuilt for the browser with a smaller instruction set and three champions written for this page. The real machine is in C and runs compiled .cor files.

How to play

1. Pick a language card, or tick the files of your repository.
2. Push a commit and watch each step, with the Jenkins log.
3. Try two languages at once, no language file, or the same commit twice.

What I built

• The ten Docker images: one base and one standalone image for each of the five languages
• The Befunge image, which builds its own interpreter from source
• The guide that explains how to build and use the images

• Ten Dockerfiles, Dockerfile.base and Dockerfile.standalone, for C, Java, JavaScript, Python and Befunge
• Multi-stage builds: compile in one image, run in a smaller one; cfunge built with cmake for Befunge
• docs/docker_image.md: build commands, rules for each image, repository layout

Replayed in your browser: nothing is really built. The detection rules, the build choice and the Dockerfile steps come from the project. The Kubernetes deployment step is not shown because it was not finished.

How to play

1. Change a number in the scene file. The picture redraws, rough first, then sharp.
2. Break the file on purpose: the error shows the line and what is wrong.
3. Player 2 moves the light, a sphere and the camera until you start typing.

What I built

• The part that reads the scene file: camera, spheres, planes and lights
• The Scene class that holds the camera, the shapes and the lights

• Scene parsing with libconfig++: camera (resolution, position, rotation, field of view), spheres, planes, ambient and directional lights
• The Scene class: one container for the camera, the primitives and the lights
• Shapes created through the team's PrimitiveBuilder

Rebuilt in the browser. The scene format follows the project's parser. The extra checks and the small renderer drawing the picture were written for this page, with shadows the original did not have.

How to play

1. Click the terminal, type a command and press Enter.
2. Send output to a file with > or >>, or into another command with |.
3. Type cat << END, a few lines, then END: the shell reads them as input.

What I built

• The prompt loop: read a line, run it, show the prompt again.
• Finding programs in the folders of PATH and running them.
• The built-in commands: cd, env, setenv, unsetenv, exit.
• Sending output to files, reading text typed after <<, and passing one command's output to the next.

• Prompt "$> " read with getline; fork, execve and waitpid; a message when the program crashes (Segmentation fault, Floating exception).
• cd with a path, no argument (HOME) and cd -, updating PWD and OLDPWD; setenv with name checks, unsetenv, env, exit.
• Redirections > and >> and the << heredoc with dup2 and pipe; the ; separator.
• A pipe between two commands, and my own printf library.

Rebuilt for the browser: a small copy of the shell rules runs in this page, with a pretend file system and a few programs. The real shells are C programs that run real ones.

How to play

1. Move the slider or pick a rule: 30 looks random, 90 draws triangles, 110 grows structures.
2. Click the small boxes to flip one part of the rule.
3. Or type the command yourself, with the same options as the real program.

What I built

• Reading the options typed after the program name, and refusing wrong ones.
• Computing each new line of cells from the line above.
• Printing the lines centred in the window, with stars.

• Argument parsing: --rule (required), --start, --lines, --window (80 by default), --move; exit code 84 on a bad argument.
• The next generation for rules 30, 90 and 110.
• The display loop, and the Stack project setup.

Rebuilt for the browser. The original Haskell program accepts rules 30, 90 and 110; this page runs any rule from 0 to 255.

How to play

1. Draw on the board: Player 2 steps aside.
2. Change colour, size or take the eraser in the toolbar.
3. Save as PNG to keep your drawing.

What I built

• The window and the toolbar buttons
• The colour and pencil size choices, and the eraser
• The help screen and saving the drawing as an image

• CSFML window and toolbar: one sprite per button, hit test on click
• Eight colours, three pencil radii (5, 18, 35 px), an eraser that paints rgb(22, 22, 22)
• Help overlay shown or hidden, board copied from the window to an image file

Rebuilt for the browser in TypeScript from the C version: same colours, sizes and eraser. Here the pencil fills the gaps between circles, and the file is a dated PNG instead of test.jpg.

How to play

1. Type a message and a key.
2. Switch between block and stream mode, and watch each byte change.
3. Decrypt it back: XOR with the same key gives the message again.

What I built

• XOR encryption, in block mode and in stream mode
• Turning text into hexadecimal and back
• The entry point that sends each command to the right algorithm

• xor_block and xor_stream: bytes reversed per block (little endian), then XOR with the key
• Stream mode pads the last block with zeros and strips them when decrypting
• hex_to_bytes and print_hex, a dynamic stdin reader, main routing xor, aes and rsa

Rebuilt for the browser from the C version, XOR only. XOR with a short repeated key is a classroom cipher: it does not protect real secrets.

How to play

1. Hold the key: short for a dot, longer for a dash.
2. Hold it one second or more to end the letter.
3. Read your name in the field, then log in (it is a toy).

What I built

• The Morse-code input on the login screen
• Short press for a dot, long press for a dash, very long for the next letter
• The live translation into letters, and Backspace to fix a mistake

• keydown and keyup on Space measure the press: under 200 ms a dot, under 800 ms a dash, 1 s or more a letter gap
• A Morse table reversed into a lookup, decoding letter by letter on every press
• The component template and style, and the route, later moved to provideRouter

Rebuilt for the browser from the Angular version, with the same timings. The Dot, Dash and Next letter buttons are extra on this page. There is no account and no password.