doylet // doy-lee

Low-level programmer since 2016. Uses C/C++ often. Passion for tools, privacy & game technology. Curious & learning every day.

Visit https://doylet.dev for comfortable viewing of this resume with videos and more projects. Thanks!

About

G'day!

I'm a software developer who started programming professionally in 2018 and have slowly learnt the fundamentals of low-level programming. I have an interest in building bespoke software using my own libraries, developing a "tech garden" so to speak. That is a collection of foundational libraries[1] where I've written and/or understood every line of code in them. Any bug is a bug in my source code that I can go understand and fix.

Doing this is a nice forcing function that in turn provides an opportunity to learn about different domains, especially those involved in game technology. I am fond of real-time interactive media and constraints. In particular, game development involves the marrying of many programming disciplines where the consumer has a high standard that is expected by default. Locked frame-rates, low-latency, interactive, a coherent design, a stable world simulation and much more!

I've made it a habit to constantly learn, rewrite, improve (reinventing the wheel is good for understanding! [2]) my foundational libraries as a form of training and practice[3]. It is my experience that each iteration has unlocked new insights whether it be API design, an alternate perspective, learning new domains and so forth.

I take inspiration from the design philosophies of:

What I use (often)

And I've dabbled with

A "Me" Primer

Find me at

My Homepage https://doylet.dev
Email cv.doylet.2380i@simplelogin.com
Gitea (Personal Projects) https://git.doylet.dev
Github (Open Source Work) https://github.com/doy-lee

Work

Session (Private Messaging/Blockchain) [2024-2026] getsession.org

  • Non-Profit[1]
  • Startup
  • Open Source
  • Cryptography
  • Distributed Systems
  • C++20
  • Python (Flask/UWSGI)
  • CMake
  • Solidity (Smart Contracts)
  • 2024 - 2026: C++ Senior Software Engineer

Session is a decentralised private messaging application run by a non-profit foundation with +1m MAU that onion routes messages using the Session Node network. This network is powered by the Oxen blockchain consisting of community operated nodes that can trustlessly escrow stake to join the network and execute the Session messaging protocol. Operator stakes are escrowed by smart contracts, penalised for bad quality-of-service and are rewarded for routing messages.

I rejoined Session (formerly Oxen) in the blockchain team of 3 engineers to assist the network migrate its nodes from Oxen to Arbitrum, an Ethereum layer 2 chain. This involved porting the trustless functionality for operators to escrow their funds from Oxen's C++ implementation into Solidity smart contracts.

In June 2025, Oxen successfully migrated a live network of ~1200 Session Nodes to Arbitrum atomically converting over ~$2m USD (1.2k nodes × 25k stake × 0.7c/token) of liquidity whilst preserving the quality-of-service of the Session messenger as the network transitioned into the new paradigm.

Post-migration, I additionally designed and worked on the privacy preserving paid membership to Session Pro which unlocked additional messaging capabilities such as larger file attachments and larger message limits. This involved designing a protocol for anonymised Session Pro certificates and privacy-preserving payment systems that interfaced with the iOS and Google storefronts.

  • Built smart contracts[2] to allow operators to escrow a stake to join a decentralised network, receive rewards.
  • Designed a certificate/token[3] based system to endow Session accounts with Pro features in a privacy preserving manner.
  • Wired up payment hooks from Apple and Google into the certificate based system for Pro membership.
  • Worked on a plugin system[4] for extensions such as bots and moderation in public group-chats.

Agent Orientated Software (AI/Robotics) [2020-2024] aosgrp.com

  • Small Business
  • C++17
  • CMake
  • Docker
  • Data Fusion/Distribution (RTI DDS)
  • Distributed Systems
  • 2D Discrete Event Simulator (ImGui, GLFW)
  • 2022 - 2024: C++ Senior Software Engineer
  • 2020 - 2022: C++ Software Engineer

AOS aims to build trustable and explainable AI using multi-agent systems with the cognitive framework, Beliefs, Desires and Intentions (BDI). My role involved improving the AI toolchain such as improving cross-agent collaboration, forward planning, scheduling and de-conflicting of agent intentionality, its execution and distributed agent communication to improve resilience in adversarial situations.

I worked on the in-house C++ kernel for BDI agents which was a real-time scheduler that time-sliced, allocated goals, resources and processed percepts to the agents (now open-sourced in Github; see below) to execute their goals. I was also primarily responsible for the 2D discrete event simulator using GLFW and Dear ImGui. This simulator tested the C++ kernel in various scenarios such as solving games (like Tower of Hanoi) or agriculture use-cases for AOS's in-house hardware branch working on autonomous off-road driving tech. The agent kernel was designed with explainability in its core exposing an interface that allowed GUIs and event simulators to hook into to use the kernel and explain the reasoning of agents and/or build autonomous logic.

  • Coordinated multiple toolchain upgrades of our in-house AI frameworks, end-to-end.
  • Added virtual-memory backed allocators for cache locality, reduced sys-calls and memory profiling.
  • Co-implemented protocol to distribute agents onto different routing technologies (DDS & Kafka).
  • Owned the docs website with APIs & manuals, end-to-end for production releases.
  • Implemented multiple discrete event simulators for verification of agent behaviours.
  • Documented best practices, patterns and tutorials for designing effective multi-agent systems.
  • Implemented real-world system specs in a multi-agent architecture to highlight deficiencies in the development methodology leading to new protocols, e.g. researching interfaces for humans to effectively contribute into the agent decision making.

Oxen (Privacy Software/Blockchain) [2018 - 2022] oxen.io

  • Non-Profit
  • Startup
  • Open Source
  • C++14
  • Boost
  • CMake
  • Docker
  • Qt5
  • Cross Platform
  • Cryptography
  • 2018 - 2020: C++ Software Engineer

Oxen is a not-for-profit, open-source company developing privacy protocols and tools. I implemented[1] a decentralized layer of servers known as the Service Node[2] network that distributes the blockchain and maintains layer access-control. They coordinate peer-to-peer to evict underperforming and malicious peers whilst generating entropy for securing blocks using checkpointing[3] and a commit-reveal scheme known as Pulse[4].

With over 1k+ servers and growing, the Service Node network provides a sybil-resistant foundation to facilitate a privacy preserving onion routing network, Lokinet, and a privacy preserving messenger, Session.

  • Rapidly learned & up-skilled as their first developer in the startup to form a development methodology and hiring practices.
  • Implemented a resilient server layer over new P2P gossip protocols: node de/registration & rewards, service metrics & voting.
  • Formed immutable checkpoints to secure blocks using shared consensus to provide faster finalization of transfers on the network.
  • Created an on-chain DNS registry to map cryptographic keys to human readable aliases (e.g. Lokinet domains, Oxen wallets and Session aliases).
  • Transitioned from Proof of Work to Proof of Stake live in production, deprecated miners for a commit-reveal scheme to generate entropy for minting blocks.
  • Owned the release process (build/package/distribute) end to end.
  • Patched 0-days and exploits, recovering from consensus failure on a live production network.
  • Improved the test framework for including re-write of Monero's framework and adding integration tests using IPC over named pipes.

Older Work

2017: C++ Intern Tools Engineer, Wargaming Sydney

Game development company most popular for developing World of Tanks. I was in the tools team assisting with the development of the editor for the asset pipeline.

2014 - 2017: B. Computer Science, University of New South Wales

Projects

On-going

2018 - CURR: DN Library git.doylet.dev/doylet/dn

  • C style C++
  • Single File Library
  • Arenas
  • Pools
  • Hash-Tables
  • Arrays
  • Strings
  • OS Primitives (Threads/Mutexes/Barriers...)
  • Networking (cURL/Emscripten)
  • Profiler
  • Cross-Platform (Win32/POSIX/Emscripten)

My personal foundational libraries for tools in C-style C++ that replace the C/C++ standard libraries for my projects. It provides a set of primitives designed around explicit memory control with allocator-aware APIs, zero-allocation patterns, and arena-based virtual memory management where appropriate.

The library is designed for trivial integration: a single amalgamated header and implementation file with no external dependencies. It targets Win32, POSIX, and Emscripten/WASM that can be configured with compile-time feature toggles.

Core modules include arrays, hash tables, string manipulation with optional AVX-512 acceleration, a frame profiler, thread-local arena contexts with scratch memory, and a networking layer abstracting cURL and browser Fetch APIs. Debug tooling is built in: ASAN memory poisoning, use-after-free detection for scratch arenas, memory scrubbing on deallocation, and leak tracking.

It has continually evolved since the start of my programming career and has been a testing ground for understanding the implications of different API designs, how common functionality is built and exploring different primitives (like learning about AVX-512 to use in string APIs).

2023 - CURR: TELY Engine (Closed Source)

  • C style C++
  • Sokol
  • Dear ImGui
  • FreeType + HarfBuzz
  • 2D Renderer
  • Asset Management
  • Cross-Platform (Win32/Emscripten)

An in-house engine and framework built on Sokol that provides a platform layer, 2D batched renderer, asset management, font rendering with FreeType and HarfBuzz, streaming audio, video playback, and input handling. It is the foundation for most of my GUI projects.

It compiles as a native desktop app and can target the web. It includes a deferred asset loading system, a sprite sheet packer with keyframe animation support, a renderer that outputs vertex batches, a basic GPU wrapper (samplers, render passes, pipelines) and a networking layer backed by cURL on desktop and fetch APIs via the browser.

It is a project whose goal is to be a forcing function for learning about game technology as needed to build hobby projects. Its features are at various levels of maturity as necessitated to get my hobby projects functional.

2025 - CURR: Solid++ (Closed Source)

  • Python
  • C++ (GUI)
  • Chainflip
  • Hyperliquid
  • Market Making
  • ImGui
  • SQLite
  • WebSocket
  • Emscripten/WASM

A complete rewrite of my trading/market making bot in Python with a native C++ ImGui dashboard which also targets the web using Emscripten for remote monitoring. This was an experiment into the viability of using Python for faster iteration on protocol updates as well as testing newer strategies more easily. It was also an experiment in using ImGui for web UIs.

The rewrite traded-off latency for faster iteration given that Chainflip has a 6-second block time. This gives ample time for decision making and hence sub-second latency is not as critical. The bot runs two strategies: a delta-neutral hedge across Chainflip and Hyperliquid (perps and spot), and a basic Bybit spot strategy. Bot pricing is configurable using averages over a lookback window with tools to identify competing orders and to offer to beat or match them in real-time.

The C++ GUI compiles to both a native desktop app and a WASM web build allowing for quick local iteration whilst allowing remote monitoring. It communicates with the Python backend over WebSocket using a custom binary protocol using asynchronous APIs.

Archived

2024 - 2025: Liquid++ (Closed Source)

  • C style C++
  • Chainflip
  • Market Making
  • ImGui
  • Sokol
  • SQLite
  • Backend

A market-making bot written in C++ for Chainflip, a decentralised cross-chain exchange. The bot provides liquidity by placing limit orders on Chainflip's concentrated liquidity AMM, then hedges directional exposure by taking opposing perpetual positions on Hyperliquid. It pulls price data from Bybit as a secondary oracle to inform pricing.

The system connects to three exchanges simultaneously via WebSocket, each with dedicated rate limiters and staleness detection to prevent trading on stale data. Orders are priced using the external mid-price plus a configurable profit margin, and a kill-order is scheduled for the next block to cancel unfilled orders before they can be picked up at an unfavourable price.

It has hot-reload DLL support, a platform layer (Sokol) separates business logic into a reloadable DLL. Dear ImGui is used for monitoring positions, order fills, and exchange connectivity. A separate web dashboard server (CivetWeb) publishes binary heartbeats over WebSocket for remote monitoring in a browser.

2023: Terry Cherry game.doylet.dev/terry_cherry/

  • C style C++
  • Raylib
  • Emscripten
  • 2D Tower Defence-Esque

A 2-player local co-op top-down tower defence game developed over 4 weekends in a game jam. Players defend "Terry's Heart" from waves of love-themed enemies (catfish, smoochie teleporters, and clinger dashers) that march along waypoint paths toward the base.

Players earn coins by defeating enemies and purchase upgrades or buildings from the storefronts. A pub that slows enemies, a church that converts them to allies and an airport that flies them to the back of the queue. Monkey totems spawn periodically which can disable enemy portals when delivered to them shutting them down permanently to win.

The engine features a tree-based entity system with generation-indexed handles[1] to prevent use-after-free bugs, fixed-timestep physics with swept AABB collision and a waypoint path-finding system. Built on Raylib with a custom C++ meta-build system, hot-reload DLL support, and an Emscripten web build targeting WebGL.

2020: intc Software u128/256 bit port to C git.doylet.dev/doylet/intc

  • C99/C++
  • Open Source
  • Single File Library Port

intc is a port of calccrypto's uint128/256 library into a single header file library to allow u128/256 calculations. This port is primarily C first and provides C++ helpers like operator overloads that are opt in.

2020: RaylibSIMD SIMD Software rendering in C git.doylet.dev/doylet/RaylibSIMD

  • C99
  • SSE2
  • Graphics Programming

Raylib is a game-engine by Raysan5 whose main focus is to make game engine programming simple and enjoyable. In this project, I rewrote the software-rendering routine to use SSE2/3 instructions to attain the expected 4x speed-up by taking advantage of data-parallelism offered by SIMD.

2017: DTRenderer 3D Software rendering in C++ git.doylet.dev/doylet/DTRenderer

DTRenderer is an attempt to build a simple software renderer from the ground up. The main goal is to build an intuitive understanding of graphics mathematics, rendering pipeline and core concepts. It runs as a Win32 program with minimal dependencies.

  • 2D Software Rendering
  • Alpha Blending
  • Bilinear Filtering
  • Correct Color Space Pipeline (SRGB <-> Linear)
  • Rasterisation
  • Texture Mapping
  • Translation, Rotation, Scale
  • 3D Software Rendering
  • Full Bright, Flat, Gouraud Shading
  • Orthographic, Perspective Projections
  • Custom Wavefront Obj Loader (minimal subset)
  • Hot Reloadable DLL for Renderer Code (taken from Handmade Hero)

2017: Math Masher Math game for mobile doylet.dev/luneaustralia

Math Masher is a cross-platform mobile app that aims to teach basic arithmetic skills including addition, subtraction and multiplication by gamifying the learning experience. The app was developed in a team using the Cocos2DX framework in C++. My role in the project was as the lead developer and assisting role with asset design.

  • Project management (Trello, minutes meeting, code review etc.)
  • Game engine architecture (Gameplay, UI, shopping mechanics, debug)
  • Basic sound editing (Compressor, EQing, normalisation)
  • Asset designs (Creating graphical assets with Photoshop)

2017: DCHIP8 Chip8 interpreter git.doylet.dev/doylet/dchip-8

DCHIP8 aims to emulate the CHIP8 architecture to better understand at a lower level operations between memory, CPU, input and output.

  • Fetch, Decode, Execute Opcodes
  • Modelling memory, registers and basic CPU architecture
  • Software Rendering and interaction with Win32
  • Minimal dependencies, single file executable

2016: Dengine 2D engine for asteroids git.doylet.dev/doylet/dengine

Dengine is a solo project, 2D game engine developed with OpenGL and low-level libraries in C. The main goal of Dengine is to facilitate learning from many aspects of Computer Science. Alongside Dengine, Asteroids is being built which guides the development of features for the game. Dengine is inspired by Handmade Hero, with a focus on developing as many features with minimal libraries, such that it is not too time-consuming and counter-productive to do so.

  • Asset Management (load data into intermediate representations)
  • Audio API from OpenAL
  • Basic 2D Game Mathematics/Physics (Vector, Trig, Explicit Euler)
  • Collision Detection (Single Axis Theorem, Minkowski Sum/Diff, AABB)
  • Debug Services & Displays
  • Entity Component Systems
  • IMGUI Systems
  • Input Parsing
  • Push-Buffer Memory Systems
  • Small Size Array Optimisations
  • Standard Library Replacements (e.g. atoi, strlen, itoa, string)
  • Texture Atlas Support, Runtime Font Packing
  • OpenGL 2D Rendering Pipeline & Batching Render Calls