Tangible products, deliberate architectures.

Synchronised multi-POV viewing product for Discord sessions and events: several YouTube, Twitch and Kick POVs in one control room, aligned in VOD through audio sync and maintained by clock/offset logic. The web product is live at watchmultipov.app with Solid, TypeScript, Vite, PWA and hls.js. The current media core is a shared Rust engine exposed as WASM on the web and compiled natively in the app. The Android app uses Tauri 2, embeds the real web control room, shares the Rust core, uses native Media3/ExoPlayer players and has live sync validated on device.

• 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
• Three platforms in one view — YouTube, Twitch and Kick — behind a unified provider layer so web/native UI never special-cases a platform
• 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 validated on device
• Method: specified, implemented, reviewed with Claude/Codex, verified 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

Remote desktop solution dedicated to voice-driven development from an Android terminal, allowing users to operate a Linux machine as if sitting in front of it. Key differentiator: native Nintendo Switch Joy-Con integration as a companion peripheral — the phone stays free for voice dictation while the Joy-Con (held in the other hand) drives the mouse via its analog stick and triggers keyboard shortcuts through configurable button-combo profiles (Claude code, Open code, codex...), covering most actions of these CLIs without ever putting down the phone. The ecosystem combines a Linux daemon that automatically orchestrates display, audio and transcription as soon as a mobile client connects via RustDesk, a patched RustDesk fork (Joy-Con gamepad mapping, voice call, rebranding), a standalone Axum + SQLite + Ed25519 license server with offline and expiry grace handling, and a bilingual EN/FR distribution website. A complete product concept, designed and implemented end-to-end, from initial proposal to production release on nomadrust.dev.

• Concept design: use an Android as a voice terminal to drive a remote Linux machine through RustDesk
• Nintendo Switch Joy-Con integration: optimal 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
• Owned product decisions: simple pricing (€5/month or €50 lifetime), no trial, scoped V1.0 to Linux only

Modern portfolio website developed with Angular 21 and optimized for organic search (SEO). SSG (Static Site Generation) architecture for maximum performance and search engine visibility. Bilingual FR/EN interface with a cosmic background updated daily, layered animation and a static fallback when device capabilities or preferences require it. Responsive design using Tailwind CSS 4 with a dynamic PDF CV generator.

• Angular 21 SSG (Static Site Generation) architecture for optimal SEO indexing
• 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
• Dynamic PDF CV generator: on-the-fly creation of stylized CV from JSON data with jsPDF
• Tailwind CSS 4 integration with mobile-first responsive design and smooth animations
• WebP image optimization + lazy loading for minimal loading times
• Dynamic meta tags, Open Graph, Twitter Cards and JSON-LD for optimized SEO and social sharing
• GitHub Actions CI/CD: automatic static prerender build and SFTP deployment on each push
• Modern architecture: Angular Signals, standalone components, static prerendering and HTTP cache

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