Roberto Turrado Camblor

libQASM is the open-source C++ library, developed at QuTech, that parses and analyzes cQASM quantum programs — the gate-based quantum assembly language used across QuTech's software stack.

It performs lexical, syntactic, and semantic analysis of an input program and produces a syntactic or semantic AST, a list of well-formed errors, or a JSON representation of either.

It is consumed by projects such as the QX simulator (C++) and the OpenSquirrel compiler (Python).

As owner of libQASM, I implemented support for the cQASM 3.0 language, drove refactorings towards modern C++ standards and best practices, and added an Emscripten build target enabling the parser to run in the browser via WebAssembly.

I set up and maintained a continuous-integration matrix covering x86-64 and ARM64, across Linux, macOS, and Windows, and GCC, Clang, and MSVC, using GitHub Actions.

The library is distributed through both Conan Center (C++) and PyPI (Python), and I coordinated its releases.

Zorita is a personal project that involved implementing a RISC machine in modern C++. It models a reduced instruction-set architecture, with a documented machine model, instruction set, and code design, and is built as a library exercised through a comprehensive unit-test suite.

The main focus of the project was engineering quality and a fully modern C++ toolchain: the code targets C++20 and builds across GCC, Clang, Apple Clang, and MSVC on Linux, macOS, and Windows. Dependency management and builds are handled entirely through Conan, with a matrix of predefined profiles per compiler, operating system, and architecture.

The project integrates clang-format and clang-tidy for style and static analysis, ships with a Dockerfile for reproducible, dependency-free builds, and runs a continuous integration pipeline via GitHub Actions. I designed, implemented, documented, and tested the whole project on my own.

A personal project in which I solved the 100 programming problems from Marius Bancila's book The Modern C++ Challenge, using it as a vehicle to deepen my command of modern C++ and its ecosystem.

Rather than treating the problems as throwaway exercises, I implemented each solution within a proper software-engineering setup.

The code spans standards from C++11 through C++23 and covers a broad range of topics — math, algorithms, data structures, text and date handling, streams and file systems, concurrency, networking, and cryptography.

The project is engineered end to end: unit tests with Google Test, benchmarks with Google Benchmark, static analysis via CLion's Inspect Code, memory-error detection with AddressSanitizer, and code coverage with gcov. The build is based on CMake, accelerated with sccache compiler caching, and runs on a continuous-integration pipeline via GitHub Actions.

It reflects the way I like to work: clean, well-tested, maintainable code with a fully automated build and verification workflow.