I build machine learning systems, explore mathematical reasoning, and occasionally lose an unreasonable amount of time to a performance bottleneck that turns out to be one line of code.

My work sits at the intersection of systems programming, machine learning research, and mathematical reasoning, with a focus on adaptive learning algorithms, neural-symbolic systems, and efficient computation.

I like building things from first principles, understanding what's happening under the hood, and finding ways to make them work better.

Self-Adaptive Gradient Boosting · Rust

My attempt to make gradient boosting more adaptive to changing data distributions, without sacrificing the performance that makes these systems useful in the first place.

PKBoost explores concept-drift handling, entropy-Newton hybrid split-gain formulations, histogram-based learning, and systems-level optimization.

• Rust-native GBDT engine
• Adaptive learning and drift-handling mechanisms
• SIMD and memory-layout optimization
• Python interoperability through PyO3

My oldest child. Has a few thousand downloads and still needs supervision.

Mathematical Reasoning & Verification · Rust

An open-source engine exploring structured mathematical reasoning, rule-based methods, and verification-oriented approaches to multi-domain mathematical analysis.

I'm interested in bridging neural generation with symbolic reasoning, because getting an answer is useful, but understanding whether it's correct is considerably more useful.

The child who asks "but can you prove it?" at family dinners.

Low-Latency Decision Systems · C++

A research project exploring low-latency decision-making under strict timing constraints, with an emphasis on market microstructure signals and performance-sensitive computation.

Focused on the engineering challenges of making decisions quickly without losing sight of correctness.

The financially ambitious one. Currently not allowed near the family brokerage account.

Trajectory-Conditioned Semantics · Python

An investigation into trajectory-conditioned semantics and dynamic computational pathways in GPT-2-small.

Exploring how computational trajectories relate to model behaviour, and what we might learn by studying the process rather than just the output.

The mysterious one. Even I don't know where this is going yet.

• Rust: I see a memory-management problem and immediately wonder whether rewriting it in Rust would help.
• SIMD: Doing one thing at a time is a perfectly reasonable approach. I just don't want to.
• Cache locality: I will happily spend an afternoon optimizing memory access patterns. This is apparently a personality trait now.
• Benchmarking: I don't trust a speedup until I've measured it three times and questioned the methodology twice.
• Gradient boosting: I genuinely enjoy making weak learners work together. There may be a lesson in there somewhere.
• Optimization: Sometimes the bottleneck is the algorithm. Sometimes it's memory bandwidth. Sometimes it's me refusing to leave well enough alone.

• Measure first. Optimize second.
• A benchmark without context is just a number wearing a suit.
• Theoretical complexity matters. So does the hardware you're running on.
• Reproducibility is part of the engineering, not an optional extra.
• There is always another bottleneck. Unfortunately, it knows where I live.

Interested in ML systems engineering, applied AI research, performance engineering, and building systems that are as interesting under the hood as they are from the outside.