All projects

MCP server letting any agent act on what it sees across browser and real desktop (navigate/click/type/scroll/drag); returns text diffs of what changed instead of raw screenshots. GUI grounding fuses VLM detection + the AT-SPI accessibility tree; LiteLLM multi-provider router with cost-aware auto model-selection ranked from public benchmarks (MMMU, ScreenSpot-Pro, Video-MME); isolated software-GL sandbox so GPU/Flutter/Electron apps render. Installs into the major agent clients; files GitHub issues automatically. MIT.

My from-scratch deep-learning framework — where I rebuild things from first principles to actually understand them. Its spine is one generic data interface: classification, detection and reinforcement learning all flow through a single Dataset abstraction, pushed so far that a Gym RL environment is itself wrapped as a Dataset — the same dataloader and training loop then drive supervised and RL runs alike. Built on myconf, a hand-written type-driven config system (metaclass coercion, lazy computed fields, no Pydantic), with tensor-subclass modalities (image/text/bbox) and hand-reimplemented ResNet · VGG · ViT · DETR (Hungarian matching) plus the DQN family. Ships a small scalar autograd with graph visualization, written to relearn backprop. ~11k LOC — openly a learning project. Below: an Atari Breakout rollout — the Gym RL environment wrapped as a Dataset — plus the 84×84 grayscale observation the pipeline feeds the agent.

The project I'm most attached to. A custom compiler turns 32 declarative "paradigms" (~1,400 lines of engineering principles) + a manifest into conditionally-loaded skills, invocable subagents and per-tool system prompts (Claude Code, Codex, Cursor, Copilot). Encodes a real multi-agent workflow (independent visual-critic gate, skeptical tester, frustration-analyzer, librarian-as-sole-editor). Prompt engineering as compiled, versioned software.

Framework-agnostic compute/visualization engine: SIMD/CUDA/ROCm/MKL/Metal kernels, WGSL/GLSL/SPIR-V shaders, virtualized rendering, C-ABI FFI to Python/JS/WASM. Built almost entirely with my AI agents.

Flutter + Rust (flutter_rust_bridge) learning app with an LLM content pipeline — local-embedding semantic dedup (fastembed + usearch), batched/cached inference, macro CRUD codegen. Actively maintained.

Parses CV/cover-letter PDFs (docling), classifies candidates with an LLM, files them to Google Drive and notifies the team on Slack — scheduled (cron, keyring creds). The kind of agent that may well be reading this CV.

Rebuilding the website of the Club Francophone des Cellules Dendritiques (a francophone dendritic-cell / immunology society) largely with my own AI agents — modernising a dated, hand-built static site. A small way I put the agents to work on something real. In progress.

A small open-source PyTorch utility that taps any nn.Module with forward hooks to pull out intermediate activations and feature maps — point it at a layer, run an input, get that layer's response back to inspect or visualise. Below: a ResNet's shallow-layer feature maps (the dog still legible per filter) beside a deep layer's abstract activations.

An MCP server that captures X11 windows and runs vision analysis over them, exposing desktop screen-grounding to any agent — a focused companion to interact for seeing what's on screen.

My published open-source Linux alias framework (since 2022) — self-documenting per-tool modules (git/apt/npm/django/nvidia/tensorboard/disk-mem/stats), incl. an interactive gum-driven multi-branch auto-rebase with conflict-guard + auto force-push; keyring-backed secret handling.

A minimalist real-time strategy game built in Unity and C#: command a single node, let your units proliferate, and conquer a galaxy of enemy nodes until the map is yours. Clean, readable UI over a moody starfield.

A 48-hour game-jam entry that placed 3rd of 19 — built and led as a first-year managing a six-person team against students years his senior. The follow-up edition added a full Blender-modeled 3D asset pipeline.

An Android strategy game with a signature twist — switch the whole battlefield between 2D and 3D on the fly. Build barracks, spawn units, manage resources, and outmaneuver an AI opponent across a tile-based map.

A Pokémon-style RPG written from scratch in Python and Pygame for a high-school CS final — shipped alongside a custom tile-based map editor that lets you author new worlds. An early proof of building tools, not just games. The title shot here was captured live by one of my own AI agents (interact) launching and driving the game autonomously — no human input.

A full e-commerce store built on a hand-rolled PHP MVC framework — custom router, session/auth and security layers, and user/product/order models — showing the fundamentals beneath the frameworks.

A student web-development project: a fictional computer hardware and software marketplace built as a multi-page static site in plain HTML, CSS and JavaScript (no framework). It spans a home page with a hero slider and an interactive SVG map of 15 stores, filterable product catalogues, plus recruitment, FAQ, contact, team and press pages with a responsive burger menu. Its defining feature is a colour-theming system driven entirely by CSS custom properties: seven swappable palettes (red, pink, blue, cyan, green, yellow, orange) and a Multi variant that cycles through all of them via a CSS keyframe animation.

A multiplayer pirate treasure-hunt game built with Team Code-19 for the 2020-2021 Code Game Jam (Unity 2019.4, C#, Mirror networking). Players harvest wood and stone, trade them at a market for a boat and a treasure map, then sail and fire cannons while racing rivals to dig up the buried chest. A formative student game-jam project with networked play and player-vs-player sword combat.

An early formative Unity (2019.3, C#) prototype for a survival/base-building game. The most developed piece is a procedural ground generator that builds a flat grid mesh from scratch (vertices, triangles, recalculated normals) with a LineRenderer grid overlay, plus a click-and-drag camera controller and a Game/Edit mode toggle. Buildings, resources and costs are modeled with a clean OOP hierarchy (abstract Building, Core, PlayerResources, Cost); placement and resource logic remain stubbed — it is an exploratory sandbox rather than a finished game.

University web project (IUT Montpellier, 2020): a React app that browses the archives of a French detective radio drama. A bash scraper harvests roughly 774 episodes (audio, titles, broadcast dates) from a fan site; episodes are plotted on a Google Map and filtered by broadcast or in-story date through a hand-built interactive timeline with scroll-to-zoom, draggable range cursors and custom date-to-pixel math, backed by a PHP/axios API. Despite the internal name airbnb-like, the team built a geo-temporal episode browser with an integrated audio player. Below: the app running locally, driven by one of my AI agents, over a few sample episodes — the original ~774-episode dataset and the Google-Maps key have both lapsed, so the map falls back to open (OpenStreetMap) tiles here, while the hand-built timeline (scroll-zoom, draggable range cursors, custom date-to-pixel math) is untouched.

A formative IUT project: a from-scratch Model/View/Controller/Router skeleton written in plain PHP, with no framework, to learn web architecture from first principles. It pairs a generic PDO data layer (select/selectAll/update/delete with prepared statements) with a path-by-convention autoloader, a front-controller entry point, and a base HTML layout — the e-commerce "store" being an early scaffold rather than a finished shop.

An early Unity prototype of a slot-based, two-player territory strategy game — the formative precursor to a later project sharing the same mechanics. Its core is a procedural map generator that grows an organic hex grid one tile at a time, wiring up six-neighbour adjacency and a noise parameter that biases growth direction, previewed live in a custom Unity Editor inspector. Players claim coloured slots and place buildings (house, barrack, tower) over a touch-friendly long-press-and-drag control scheme.

A formative Unity (C#) game built to learn engine architecture: a top-down action-RPG with click-to-move NavMesh pathfinding, point-and-click combat, enemy spawn packs with auto-targeting AI, and a level/mission selection menu. Its main interest is a clean object-oriented design — an abstract Entity hierarchy (Character/Warrior, ILivable interface) feeding an inventory with probabilistic loot drops and a crafting system driven by schematics.

A small Unity 5.6 game built as a formative student project: a low-poly, blue-clad warrior (hat, sword and heraldic shield) in a single room scene. The notable piece is its in-game options system — pause and main menus with fade transitions, audio settings, and a key-rebinding screen (remappable movement and jump keys) driven by a custom KeyBindManager and camera/movement controllers in C#.