My personal projects

MultiPOV brings together YouTube, Twitch and Kick viewpoints for Discord sessions and events. In VOD, audio synchronisation measures delays; a clock and offsets then maintain alignment. The web app is live at watchmultipov.app (Solid, TypeScript, Vite, PWA and hls.js). The shared Rust engine runs as WASM on the web and natively in the Tauri 2 Android app. The Android app embeds the web viewer, Media3/ExoPlayer players and instrumented live synchronisation for on-device testing.

• Web VOD sync: GCC-PHAT measures audio offsets, then a master clock and offsets keep POVs aligned after pause, seek or layout changes
• Shared Rust core: common media engine exposed as WASM on the web and compiled natively on Android to centralise timing, offsets, provider capabilities, errors and fallbacks
• YouTube, Twitch and Kick in one view, with a shared provider layer that handles platform differences
• Account-free shareable sessions encoded in the URL path (/s/), portable in a comment or a DM
• Configurable layout engine: auto grid, spotlight, theater and stacks; drag, resize and saved layouts (localStorage)
• Immersive fullscreen mode: Fullscreen API on the whole stage, with landscape orientation lock and Wake Lock to keep the screen on during playback
• Unified chat overlay (Twitch/YouTube/Kick): repositionable per-POV ephemeral overlay or side dock, messages merged with a per-platform colour dot and aligned to the timeline in VOD
• Android native app: Tauri 2, embedded web control room, shared Rust core, native Media3/ExoPlayer players and live sync instrumented for on-device checks
• Claude/Codex-assisted development: specifications, implementation, review and checks in production and on device, with scoped commits

Multiplayer text-based TTRPG web platform where a generative AI acts as the game master. Original game system (2d6+stat, GM Moves, Trait Cards, Vows & Clocks, 5 pacing modes) secured by a 19-invariant 'drift gate' that validates every LLM output before applying state. Designed with Claude (Anthropic) as primary provider, the application also supports Gemini, OpenAI or a local model (Ollama, llama.cpp, vLLM via OpenAI-compatible API) through an adapter architecture. The community creates its own universes via an 11-step wizard in 4 phases (Fandom import, AI-assisted generation, voice profiles, lore by season/episode, translation) and publishes after moderation. Python 3.12 / FastAPI + WebSocket backend, asynchronous SQLite, Vite frontend, multi-container Qwen TTS pool and a free tier with virtual Flares currency.

• Dice-first game system: the 2d6+stat roll is resolved by the engine BEFORE the LLM call (frozen roll handed over as established fact), deterministic Position & Effect, 5 pacing modes, Bold Move, HP/Momentum managed 100% by the engine (never by the LLM)
• Objectives & clocks driven by the LLM: the Architect agent defines Vows (objectives from 0 to 10) and Clocks of 4, 6 or 8 segments — at setup or created dynamically mid-game — which the engine advances and aggregates deterministically
• 19-invariant drift gate: each AI response validated before state patch (automatic clamp if drift detected on HP, momentum, pacing, position, effects)
• Multi-provider via adapters: optimised for Claude (Sonnet for turns, Haiku for validation and extraction, Opus for moral dilemmas), also compatible with Gemini, OpenAI and local models (Ollama, llama.cpp, vLLM) via OpenAI-compatible API
• Community universe creation: 11-step wizard in 4 phases with Fandom import (scraping → Haiku extraction → Sonnet builder), AI Generate buttons per step, WAV voice profiles per character/language, lore enrichment by season/episode and EN ↔ FR translation
• Lifecycle & moderation: draft → pending → published → flagged → removed, user reports, DMCA/LCEN/DSA takedown procedure, email notifications to creators
• Public landing + authenticated SPA: universe gallery served with HTTP 60s cache, auth redirect on /app, user accounts (JWT, bcrypt, OAuth, magic-link)
• Free tier with virtual Flares currency: inscription credit, daily claim, rewarded ads (dynamic CSP per user, service worker exclusion)
• Immersive audio with cloned voices: multi-container Docker Qwen TTS pool synthesising a cloned voice per character and per language (from a reference sample), with least-connections dispatch, per-user semaphore, LRU cache for voice profiles, intro music per universe and mood-categorised track catalog
• Observability tools: JSONL traces, 0-API replay, narrative/mechanical audit, per-session cost tracker, HMAC-auth admin panel

Nomad lets you develop from an Android phone connected to a Linux workstation over RustDesk. The phone displays the remote desktop and captures dictation; a Nintendo Switch Joy-Con in the other hand controls the mouse and shortcuts through configurable profiles for Claude Code, OpenCode or Codex. A Linux daemon orchestrates display, audio and transcription when the mobile client connects. The project includes an adapted RustDesk fork (gamepad, voice call, branding), an Axum + SQLite + Ed25519 licence server with offline and expiry grace periods, and the bilingual nomadrust.dev website. Access is available on request through the website form.

• Concept design: use an Android as a voice terminal to drive a remote Linux machine through RustDesk
• Nintendo Switch Joy-Con integration: companion peripheral that frees the phone for dictation — mouse movement via analog stick and keyboard shortcuts triggered by button combinations
• Configurable button profiles (Claude code, Open code, codex...) providing enough actions to operate these CLIs without a physical keyboard
• Voice dictation to talk to the LLM: the Android app opens a voice call (RustDesk) to the daemon, which transcribes speech locally (Voxtype / Whisper large-v3-turbo) and injects the text as keystrokes (wtype on Wayland, xdotool on X11) straight into the target CLI (Claude Code, Codex…) — you speak, the text types itself into the terminal
• Linux daemon automatically orchestrating screen, audio and transcription as soon as a mobile client connects
• Custom RustDesk fork with dedicated patches (Joy-Con gamepad mapping, voice call, rebrand)
• Standalone license server (Axum + SQLite + Ed25519) with offline and expiry grace periods
• Bilingual EN/FR website (Astro 5 + Tailwind CSS 4) for distribution
• Planned pricing: €5/month or €50 for a lifetime licence, without a free trial; V1.0 limited to Linux

French/English portfolio built with Angular 21 and pre-rendered as static HTML. It combines canonical routes per language, SEO and social-sharing metadata, a responsive Tailwind CSS 4 layout and PDF CV generation. An astronomical background is selected daily; its layered animation has a static fallback based on device capabilities and preferences.

• Angular 21 static generation: pre-rendered HTML for public routes
• Core Web Vitals: LCP < 2.5s, INP < 200ms, CLS < 0.1
• Lighthouse score 100/100 on performance, accessibility, best practices and SEO
• Bilingual FR/EN switch through canonical routes: FR on /, EN on /en/*
• Daily multi-source cosmic background: a script (images:fetch via GitHub Actions) selects a real image each day from NASA APOD, ESA Hubble, ESA Webb or ESO Picture of the Week; brightness and entropy filters, an OCR guard, host allowlist, denylist and anti-stagnation guard reject flat, annotated or repeated images, with a local-cache fallback
• Layered background animation: around 300 Voronoi fragments modulated by an energy field, sparkles detected on bright zones and occasional shooting stars
• Performance by design: the energy loop is capped at 30 FPS, fragment computation runs in a Web Worker, loading is deferred and animation is disabled for mobile or low-capability profiles
• Glassmorphism design: translucent backdrop-filter surfaces (blur + saturate), per-card hue rotation and background sampling (photo-tint) for coherent highlights
• Progressive CSS animations between pages and on scroll, with reduced-motion support
• PDF CV generator: on-demand creation from portfolio data with jsPDF
• Tailwind CSS 4 for responsive layouts and animations
• WebP images and lazy loading to reduce load times
• Dynamic metadata: Open Graph, Twitter Cards and JSON-LD
• GitHub Actions CI/CD: automatic static prerender build and SFTP deployment on each push
• Angular Signals, standalone components, static pre-rendering and HTTP caching

Autonomous Minecraft bot driven by an LLM through the Model Context Protocol (MCP). A deliberately strict "atomic" architecture: the Mineflayer bot is only an executing arm (unit actions, no decisions), while the LLM reasons over raw data surfaced by sensors (discovered blocks, hazards, inventory, Y-levels) to decide what to mine, build or flee. Three MCP servers separate actions, Minecraft knowledge (recipes, Y-levels, tools) and a persistent spatial memory in SQLite. A learning project that taught me, through play, how to frame explicit rules and provide the right context to an LLM — a skill directly reused in the Aidventures drift gate and in the way I scope Claude Code-assisted development.

• Atomic architecture: the bot runs unit actions (dig, place, equip) and makes no decisions — all reasoning is delegated to the LLM
• Sensors returning raw data (surrounding blocks, water/void, hazards, optimal Y-levels, inventory) instead of orders, so the LLM reasons over the real context
• Three separate MCP servers: actions, Minecraft knowledge (recipes, Y-levels, tools) and persistent spatial memory in SQLite (known staircases, houses and veins)
• Explicit gameplay rules (vein mining order, scaffolding technique to avoid trapping yourself) showing that output quality depends on the quality of the rules given
• Parallel agents (perception, safety, reasoning) that collect and analyse world state before each action