• Senior systems engineer. Available for remote freelance work.
• I ship production‑safe low‑level systems and developer tooling. I can thus measurably improve performance and developer velocity.
• Rust, WebAssembly, open-source, compiler and language runtime, SDKs, CI, fuzzing, performance, Matrix.
• Email: hello@bouvier.cc. Matrix: @bnjbvr:delire.party.

I am a system software engineer with 14 years of experience, interested in solving hard problems, from low-level performance (notably compiler/language runtime engineering), SDK design, to developer tooling. I deliver measurable impact by improving performance, implementing features with the highest end-user value, and raising developer productivity through pragmatic architecture, robust testing, and automation.

I am keen on working with companies that promote decentralization, fight for the users’ privacy on the Web, defend democracy, take a stand for social justice and/or try to actively fight global climate change.

Open to freelance contracting in remote teams. I have French citizenship, I live in France (Europe/Paris timezone). I am used to working with international teams, spread across the entire world.

Last updated: April 2026.

🔗Core skills

• Rust: I’ve been using the language since 2017, followed his evolution, and worked with it in many different contexts: low-level platform code, video games engine as well as SDK code. Preferred language.
• WebAssembly: I’ve been involved in the initial standardization process, and I’ve been following evolution of the standard since then. I’ve also implemented the core proposal in Firefox’s Spidermonkey, and I’ve used wasmtime in live production environments (100+ users).
• Matrix: During my time at Element I’ve learned many low-level details about the Matrix protocol, namely the Client/Server API, event definitions, semantic behaviors, etc.
• Compilers / language runtime: I’ve worked on optimizing compilers in SSA form, implementing new features and improving the performance of both the compiler itself, and the code it generates.
• Open-source: CI testing (Github Actions / Gitlab pipelines), code review, performance testing (codspeed, perf), correctness testing (fuzzing, valgrind, misc LLVM sanitizers).

🔗Experiences

🔗Element (May 2023 — present)

I’ve been working on adding lots of new features in the Matrix Rust SDK, that has been used in the rewrite of the ElementX mobile applications, at the heart of the company’s strategy to propose modern, blazingly fast messaging applications replacing the previous generation of apps. Small team of 3 core Rust engineers, 1M+ observable monthly active users on the Matrix federation.

• Proposed major architectural changes in the SDK by adding a device-local, persisted on disk event cache, which enabled the implementation of new customer-requested, user-facing features, including but not limited to: offline access, thread support, full-text search, precise accounting of read receipts and notifications, etc. This helped bring feature parity with the previous generation of apps.
• Implemented a send queue with retries, persisted request storage, dependency ordering, cancellation, improving the UX for every user.
• Improved the team’s productivity by bringing best practices and improving development velocity: strong testing culture (unit/integration, helping move from ~70 to 90% test coverage), deep code review, improvements to the testing frameworks, Sentry telemetry for error tracking, and implementation of a TUI Matrix client (multiverse) to quickly test SDK features.
• Sped up some specific bottlenecks, using perf, manual and telemetry wallclock measurements, benchmarking (locally and on codpseed), thus removing the specific performance bottlenecks.
• Participated in a few open-source conferences (FOSDEM, Matrix conference) where I presented and talked about our work to a broad technical audience.

🔗cargo-machete (2022 — present)

I am the creator and core maintainer of cargo-machete, a quick cargo tool to reduce the number of unused dependencies in Rust projects, with a dedicated Github Action, used on many Rust projects’ CI, and presented in multiple Rust docs as recommended tooling.

• blog post
• ~1.3K stars on Github
• used in (est.) 2400+ Github repositories.

🔗Embark Studios (March 2021 — April 2023)

Worked on a new experimental game engine that made use of WebAssembly modules, as part of a 10 people engine team. This game engine was used by ~20 in-house developers, and the game was available to several hundreds of players in private beta-test sessions.

• Designed and implemented new host APIs and core capabilities in the game engine.
• Added Apple CPU support (M1) to Wasmtime.
• Implemented an incremental compilation cache in Wasmtime, that sped up cold compile times up to 20% for a large single game-dev module, and up to a factor of 10x for hot caches.
• Implemented in-game admin features and majorly contributed to a full redesign of the multiplayer architecture.
• Maintained and implemented various tools to increase team productivity: Github bot, Rust analysis tool, proc-macros for WebAssembly bindings generation, misc command-line and script helpers.

🔗Mozilla (April 2013 — January 2021)

After the end of my training, I’ve worked as a Software engineer and then a Senior Software Engineer, in the Spidermonkey JavaScript and WebAssembly interpreter and optimizing compiler team (~20 people). This engine has been used in the Firefox Web browser (MAU: ~200M clients).

🔗Cranelift & Wasmtime (Rust)

Cranelift is a low-level code generator written in Rust, and designed to quickly generate fast code. Wasmtime is a fully-fledged WebAssembly runtime making use of Cranelift for ahead-of-time code generation.

• Implementation of the new backend targeting aarch64. Wrote the new backend variant for x86_64, capable to correctly run the whole WebAssembly core test suite.
• Set up fuzzing for our new register allocators, using a toy language (parser, execution semantics) and libfuzzer.
• Implemented an experimental fast linear scan register allocator in Rust.
• Ported Cranelift’s “meta” domain-specific language from Python to Rust, simplifying it, eliminating classes of potential footguns.
• Implemented and maintained the associated Cranelift WebAssembly backend in Spidermonkey (Firefox’s JavaScript engine) for years (glue code, compile-time improvements, features implementation, etc.).

🔗Firefox (C++)

• Added Float32 support to asm.js, resulting in up to 60% faster code in some focused benchmarks. Results presented in my related blog post about it.
• Added SIMD.js support to asm.js (resulting in near native runtime speed) and the JavaScript optimizing compiler (improved throughput by 66%), with results presented in a technical blog post.
• Implemented support for WebAssembly in Firefox: decoding, translating to internal intermediate representations, adding support for new features, generating machine code (x86_64/x86 32 bits/arm32/arm64).
• Parallelized WebAssembly function compilation: first one at a time, then batched in bundles with sizes experimentally determined to lower the parallelization overhead. Speedup close to the number of CPU cores.
• Sped function calls from WebAssembly to regular JavaScript up to 50%. Then sped up function calls from JavaScript to WebAssembly, nearly as fast as JS to JS function calls. See blog post.
• Implemented a domain-specific WebAssembly fuzzing harness, trying to cause runtime assertions or crashes in debug builds, as well as comparing results of a same program across different platforms or architectures (“differential fuzzing”).
• Added support for the Linux tool perf to OdinMonkey (ahead-of-time compiler for asm.js/WebAssembly code).

🔗Misc:

• Added Rust build support to the Spidermonkey build system, enabling use of Rust to all developers of this project.
• Maintenance and feature development of AreWeFastYet, a cluster of machines running performance benchmarks of web browsers, as well as a website rendering results, as a company-internal side-project.
• Gave several talks about asm.js and WebAssembly, presenting the project to broad technical audiences.

🔗kresus (2014 — present)

Kresus is an open-source personal finance management project I’ve created, able to automatically fetch bank information from banking websites, gather this into a consolidated view of all accounts, and create charts/graphs based on this data. Around 1000+ downloads on npmjs.org per week.

🔗Thales Research and Technology (May 2012 — August 2012)

• Intern in the research and development team (3 people), working on systems sold to French government actors.
• Designed and implemented generic, flexible parallelization tools for the Evolving Objects open-source meta-heuristics framework (C++, OpenMPI).
• Parallelized evaluation of genetic algorithms, providing high-level convenient tooling for configuring it and for running the same algorithm concurrently with different initial parameters.
• Included support for the parallelization framework in the open-source Descarwin DAE temporal constraint planner, and ran it on a heterogeneous cluster of 250 cores, statistically proving a near-linear speedup.

🔗Atos Worldline (May 2011 — August 2011)

• Intern in a Web development team (5 people) for online bank systems.
• Designed and implemented a Web frontend for a CRM’s secured webmail (Java, GWT, HTML, CSS, JUnit).
• Added basic roles management system to another secured webmail (same tech stack).

🔗Other skills

• JavaScript / TypeScript (Spidermonkey work, side-projects).
• C/C++ (internships, advanced training, Spidermonkey work).
• Python (advanced training).
• Java / Go (lightweight experience).
• HTML / CSS / React (side-project).
• System administration / Docker / docker-compose (maintenance of a server with self-hosted services for friends and family).

🔗Formal training

• Computer science master’s degree @ INSA de Lyon.
  • Including a semester-long exchange at the New Jersey Institute of Technology (NJIT).
  • Valedictorian.
• Bachelor in computer sciences and maths @ Université Lyon 1.
  • Valedictorian.