Portfolio

Posted Jan 30, 2026

By Jad Nohra

25 min read

Portfolio

Learning Journey

Technical tree showing projects, algorithms, study, and career connections.

Knowledge Graph

Interactive visualization of connections between career, projects, algorithms, and theory. Hover over nodes to highlight relationships.

Projects

2024-2025 - Linerate ZK Hardware Acceleration
- Hardware acceleration framework for zero-knowledge proof systems. Designed unified API supporting emulated (CPU), verilated (RTL simulation), and FPGA device execution modes. Implemented emulated mode and core interfaces; led architecture decisions for team-developed verilated and FPGA modes.
- Three-Mode Architecture: Designed unified device abstraction across emulated (pure software), verilated (Verilator RTL simulation), and FPGA hardware. Implemented emulated mode; led team on verilated and FPGA modes. Single codebase. Hardware-software co-design enabling algorithm development on CPU, cycle-accurate validation on Verilator, deployment on FPGA.
- Xlang Compiler: Led development of domain-specific language and compiler for xcheck accelerator. Computation graph construction (DAG). Operations: Load/Store, Add2/Add3, Mul, MAC (multiply-accumulate), Interleave, Constants. Compiler pipeline: detriangulation → instruction scheduling → register allocation → VLIW code generation. Register bank allocation with coloring. ALU/LSU instruction encoding. Emulator for validation.
- Compute Kernels: NTT (Number-Theoretic Transform), FRI fold operations, tensor expand/operations, inner products, extrapolate line, sum composition evaluations. Left/right fold kernels. Product vector-scalar operations. Memory stress testing.
- Device Management: FPGA bitstream programming, VFIO driver binding, DMA memory management, PCIe device configuration. Host-to-card (H2C) and card-to-host (C2H) data transfer. Register-level hardware control. AWS S3 bitstream distribution.
- Resource Management: Memory frame allocation, task graph scheduling, multi-threaded/single-threaded runners. Device resource controllers for emulated, verilated, and FPGA targets. IOMMU integration. Constraint-based memory alignment and transfer unit management.
- Integration with Binius: Hardware acceleration for Binius zero-knowledge proof system. Finite field operations over binary fields. Polynomial commitment schemes. Multi-linear extensions.
- Tech: Rust, Verilator, FPGA (Xilinx), PCIe, DMA, VFIO. Algos: NTT, FRI, Tensor operations, Finite fields, Polynomial commitments, VLIW, Register allocation, Instruction scheduling.
- Applied at #1 Irreducible.
2023-2024 - FERNRIDE Safety Function — Autonomous truck safety layer
- Safety-critical perception and control layer for teleoperated autonomous trucks. Designed and implemented complete safety function from perception to actuation, achieving TÜV SÜD certification.
- Video: YouTube demo.
- Hazard Zone Model (HZM): Designed comprehensive safety specification expanding perceived area with all potential noise sources—LiDAR calibration, weather effects, uncertainty of future driver action. Articulated truck-trailer kinematic modeling for trajectory prediction under steering uncertainty, integrated as swept-path analysis noise source. Paper-to-production prototype—adapted academic ground segmentation algorithm, hardware bring-up. Rewrote pipeline for resource-constrained certifiable embedded platform.
- Safety Perception: LiDAR-based ground plane segmentation with zero false negatives requirement. Dual-sensor approach (radar + LiDAR) for weather robustness. Validated in Estonian winter operations—snow-covered ground detection, heavy rain with zero false positives/negatives.
- Safety Case Design: Developed DFD-based approach keeping design close to code with provable statements about output relations. Part of TÜV SÜD certification.
- Function Testing Framework: Scenario/test database for systematic validation of open-loop safety decisions. Replay-based testing using recorded drive data with labeled ground truth.
- Tech: C++, ROS2. Algos: Ground plane segmentation, Point cloud processing, DFD analysis, SOTIF.
- Applied at #2 FERNRIDE.
2021-2022 - Statistical Test Design for AV Safety Validation — Fleet-level safety statistics
- Statistical framework for proving autonomous vehicle safety at deployment scale — designing hypothesis tests for fleet-level safety validation, applying Design of Experiments (DoE) to test strategy, and quantifying confidence bounds for rare-event failure rates.
- Fleet-Level Safety Statistics: Binomial confidence intervals (Wilson score method) for p≈0. Fleet encounter probability formula: p_encounter = 1 - (1 - rarity_p)^fleet_size. Safe fleet size estimation from test data with significance level α=0.05. Lower confidence bound calculations for conservative safety claims.
- Hypothesis Testing Framework: Null hypothesis: True failure probability ≥ threshold. Test design: observing zero failures in N test trials. Statistical power analysis for deployment decisions. Calculated failure reduction multipliers (e.g., 1/256 reduction needed for 100-vehicle fleet at 1 failure per day tolerance).
- Design of Experiments (DoE) for AV Testing: Recognized stratified sampling vs simple random sampling distinction for ODD coverage. Critiqued “vanilla binomial confidence intervals” as inapplicable to full ODD (cannot treat as zero-dimensional reliability test). Factorial design applied to test space. Plackett-Burman designs for efficient screening. Analysis of Monte Carlo limitations.
- Statistical Test Strategy: Coverage dimensions as strata in stratified sampling. Equivalence classes as expert-opinion factorial design. DVP (Design Verification Plan) from DoE perspective. Integration of white-box analysis with statistical validation. Documents: “AV Testing From a Design of Experiments Perspective”, “DVP Coverage from a DoE Perspective”.
- Model Validation & Uncertainty Quantification: Gaussian process model discrepancy quantification. Parameter uncertainty vs model inadequacy. Sequential calibration approaches. Bayesian uncertainty quantification methods.
- Tech: Python, SciPy, Statsmodels. Algos: Binomial confidence intervals, Wilson score, Hypothesis testing, Design of Experiments, Stratified sampling, Factorial design, Plackett-Burman, Gaussian processes, Uncertainty quantification.
- Books: #1 Statistics for Experimenters, #2 Probabilistic Safety Assessment.
- Integration with SOTIF, UL4600, safety case documentation.
- Patent: US20230030474A1 - Scenario-based safety validation.
- Applied at #3 Argo AI.
2021-2022 - VTT Simulation Platform — AV simulation framework
- Multi-layer simulation framework for autonomous vehicle testing — enabling systematic validation of detection, prediction, tracking, and motion planning through physics-based modeling and deterministic execution.
- Layered Simulation Architecture: Multi-layer Environment State (ES) with Transformation Functions (TF). Layer 0 ground truth, subsequent layers apply noise/filtering. Enables isolated testing of detection, prediction, tracking, motion planning.
- AV Compute Model: 8-dimension timing model — Execution Time (distribution sampling), Branching, Messaging, Triggering, Transmission Time, Queuing (FIFO/LIFO), Clock Synchronization, System Load. Time series modeling for latency. SOTIF/FMEA connection.
- Driver Model: Built on Wiedemann Model (1974), Intelligent Driver Model (1999), Enhanced IDM. “Specialist Driver” concept for edge case testing. Agent-based modeling validation methodology. TTC metrics.
- Vehicle Dynamics Modeling: Bicycle model, tire cornering stiffness, yaw inertia, road load coefficients (coast-down testing). Steering actuator time constants, rack conversion.
- Path Refinement Analysis: QP optimization with horizon points (trajectory discretization). Linearized dynamics constraints. CVXGEN solver with iterative refinement. Soft/hard envelope constraints (convexification). Savitzky-Golay filtering for steering analysis. Reachability analysis for solver convergence.
- Resimulation System: Transform Graph DAG, MTR orchestration, overlay management, deterministic discrete-event scheduling at scale.
- Tech: C++, Python. Algos: Discrete-event simulation, MPC, QP, ABM, IDM, Bicycle model, Time series, Convex optimization.
- UL4600 safety certification. SOTIF analysis. FMEA integration.
- Applied at #3 Argo AI, #2 FERNRIDE.
2018-2020 - daisy — Traffic simulator
- Traffic flow simulation for autonomous vehicle testing scenarios — built during AV work to model realistic traffic patterns and edge cases.
- Tech: Python. Algos: Agent-based simulation, traffic flow modeling.
- Video: YouTube demo.
- Applied at #4 Audi AID.
2018-2020 - PaCoS — Concurrency determinism simulator
- Deterministic concurrency simulator for debugging distributed systems — ensuring reproducible behavior in parallel AV software stacks.
- Tech: Python. Algos: Discrete event simulation, deterministic scheduling.
- Applied at #4 Audi AID.

May 2019 - TheNotes — Study notes 2013-2018 published to GitHub

Collection of mathematical and technical study notes accumulated over 5+ years, covering physics foundations, linear algebra, analysis, and formal logic — a personal reference and learning archive.
Covers physics, linear algebra, geometry, logic across 90+ documents.
Notes: LinAlg Done Right, 2022 robotics transforms

Source Tree

├── 2011-2012
│   ├── attribution.pdf
│   ├── quotes1-0-100.pdf
│   └── theplan.pdf
├── 2013-2014
│   ├── Notes on the GJK Algorithm..pdf
│   ├── Notes on the Linear Complementarity Problem.pdf
│   ├── Notes on Euler's Writings.pdf
│   └── ... (30 files)
├── 2015
│   ├── Notes on Potter's Set Theory and its Philosophy.pdf
│   ├── rotation.pdf
│   ├── lagrfrmw.pdf
│   └── ... (26 files)
├── 2016
│   ├── dform.pdf
│   ├── notes_coll_det.pdf
│   ├── ml_survey.pdf
│   └── ... (19 files)
├── 2017
│   ├── treat_rbd_1.pdf
│   ├── plql.pdf
│   └── ... (11 files)
├── 2018
│   ├── Free Occurrences in FOL.pdf
│   └── thought_base.pdf
├── 2019
│   └── memo_linear-algebra-done-right.pdf
└── 2022
  └── mapping_robotics_transform_terminology_to_abstract_linear_algebra.pdf

Sep 2017 - tag_export — Digital library index
- A curated, tagged bibliography of technical books and papers — built to quickly locate authoritative references during study sessions and project research.
- Curated references for physics, math, CS — used for quick lookup during study.
- tag_export
Apr 2017 - defdefqed — FOL prover, semantic graph crawler
- A first-order logic theorem prover and semantic graph crawler — built to formalize mathematical exploration and automatically extract relationships from mathematical texts.
- Tech: Python. Algos: First-Order Logic (notes), resolution, unification.
- Notes: FOL, thought_base, Barwise Liar, Zakon
- Motivated by desire to formalize mathematical exploration. Video demo.
2017 - Study: Programming Logic
- Deep dive into the theoretical foundations of programming languages — type theory, lambda calculus, and their connections to logic.
- Algos: Lambda calculus, Type theory.
- Notes: plql, plql_short, plql_pl_flavors, compute
- tag_export: Type Theory, Lambda Calculus
2017 - Study: Rigid Body Dynamics
- Formal treatment of rigid body dynamics after years of hands-on work at Havok — connecting practical simulation experience to mathematical foundations in mechanics and constraint solving.
- Algos: Rigid body dynamics (notes), Lagrangian mechanics (notes).
- Notes: treat_rbd_1, treat_rn, solve, ineq, speed_proof
- tag_export: Mechanics, RBD (★★ Penalty Method, Multibody, Geometric Mechanics)
- Formalized understanding after years at #5 Havok.
2016 - Study: Analysis & Geometry
- Rigorous study of differential geometry and real analysis — the mathematical framework underlying physics simulation, manifolds, and continuous optimization.
- Algos: Differential forms, Manifolds, Measure theory.
- Notes: Differential Forms, road_dform, Manifolds, Lagrange proof, Analysis, MVT/IVT/Taylor, Measure, Continuity, pointillistic
- tag_export: DiffGeom, Calculus of Variations, Real Analysis, NSA
- Applied at #5 Havok for solver formalization.
~2016 - HKDS High-Fidelity Solver at #5 Havok
- R&D for high-fidelity constraint solver targeting robotics and machinery simulation — going beyond game physics to industrial precision.
- Context: HKDS overview. More detail. Videos: Titan arm, Digger. YouTube: Titan4 Robot Arm, Digger, Digger & Terrain. Prerequisites: Rotations and Basics, work on stabilizing constraints, notebook notes on ‘universal constraint’, substepping algorithm (a stumbling block for others at multiple occasions). Prototyping using Julia: MLCP solver. Dynamics debugging tool: trace.
- Tech: C++. Algos: MLCP, substepping, co-simulation.
~2016 - TOI Argument at #5 Havok
- Formal proof that the Time-Of-Impact tunneling problem has no complete solution — proving an open problem unsolvable, redirecting team focus from finding a solution to managing trade-offs.
- Context: Open problem ever since the ‘TOI’ engine was abandoned. Multiple attempts that replaced artifacts with other artifacts. Proved that the problem is not solvable: TOI argument. Effect: stop searching for the solution, focus on which artifacts to trade and when.
- Algos: Continuous collision detection, TOI analysis.
~2015 - Network Physics R&D at #5 Havok
- Research and prototyping for networked multiplayer physics — synchronization, prediction, and rollback for distributed rigid body simulation.
- Context: Research report and proposed designs. Prototype including low-level framework.
- Tech: C++. Algos: Client-server physics, state synchronization, sector partitioning.
~2015 - hinges_py — RBD simulator
- Python rigid body dynamics simulator for research and prototyping — exploring constraint formulations and numerical methods outside the main codebase.
- Tech: Python. Algos: Rigid body dynamics, constraint solving, forward Euler.
- Used for HKDS research and arxiv publication validation.
~2015 - trace — Real-time data plotting
- Real-time data visualization tool for physics debugging — plotting solver convergence, constraint forces, and numerical residuals.
- Tech: Python. Algos: Streaming data visualization.
- Applied at #5 Havok for dynamics debugging.
2015 - arxiv: Uniqueness of Minima at #10 Guided Knowledge
- Published mathematical paper proving uniqueness conditions for certain least squares problems — theoretical foundations for IMU sensor fusion optimization.
- Algos: Least squares, optimization theory, uniqueness proofs.
- Notes: Project GK notes
~2014 - Physics-2014 Contact Solver at #5 Havok
- Complete rewrite of Havok’s contact constraint solver — shipped in all games since ~2014, optimized for branch prediction and cache efficiency.
- Context: Mental models of CPUs at race with CPU improvements — benchmarking ignoring real data becomes dangerous. Research (Agner’s manuals) → branch prediction as main actor in this context. New (intrusive) optimization: coupling geometry processing to solver using data rearrangement. For comparison: Bullet solver. Havok’s focus: performance. No bugs ever reported. Defensive code (tunable defensiveness — math library only has INFTY and NAN warnings). Found bugs in other pieces of code, including hard to find bugs due to slow accumulation of wrong calculation. Tunable per-platform using a very carefully configured set of macros (>10 options → code path combinations). Also: deterministic scaling of cores (Intel many-core CPU R&D).
- Tech: C++, SIMD. Algos: Gauss-Seidel, sequential impulse, constraint solving.
~2014 - Job Queue Combinatorial Delay Mode at #5 Havok
- Automated race condition debugging technique for hard-to-reproduce threading bugs.
- Context: Bug that was hard for dev support team to repro (1/100000). Introduced timing fuzzing into the system by instrumentation — different threads slowed down by different random amounts. Ran automatically, found bug after some hours. Repro then easy to debug.
- Tech: C++. Algos: Timing fuzzing, race condition detection, instrumentation.
~2013-2015 - Geometry Numerical Issues at #5 Havok
- Deep investigation of floating-point numerical issues in collision geometry — ray-triangle, ray-sphere intersection with robust epsilon handling.
- Context: Jira epsilon analysis. Ray-sphere: improvement by intuitive solution. Ray-triangle: improvement by analytical solution (books like Floating-Point Computation by Strebenz). Telescoping debugger. Led to interest about numerical analysis. Sampler prototype (RRT). Interval math library with pessimistic approximate but fast bounds (2x slower than normal arithmetic). Also first steps into numerical analysis for dynamics: Residuals.
- Tech: C++. Algos: IEEE 754, interval arithmetic, ULP analysis.
~2012 - Nintendo WiiU Math Library at #5 Havok
- Low-level math library optimization for Nintendo WiiU’s PowerPC-based CPU — working around buggy compiler optimizations and limited SIMD.
- Context: Instruction-level ARM (handicapped two-float SIMD). Buggy compiler in terms of performance optimization.
- Tech: C++, PowerPC assembly. Algos: SIMD vectorization, instruction scheduling.
2015 - Study: Foundations & Logic
- Study of mathematical foundations — set theory, logic, and the philosophical underpinnings of mathematics itself.
- Algos: Set theory, Model theory, Proof theory.
- Notes: Potter Set Theory, Potter Reason’s Kin, Gödel 1, Gödel 2, Semantics, Hestenes GA
- tag_export: Set Theory, Model Theory, Proof Theory
2015 - Problem-Solving Methodology
- Approach for managing many technical topics in parallel when deep focus on one at a time is no longer possible.
- Context: Too many topics to care about. In the past had luxury to focus one at a time, since some years cannot afford this anymore. Stack keeps growing bigger. Tried many techniques: physical notebooks (GK notes leading to arxiv publication), large single-topic latex documents. Currently: combination of physical notes, latex summaries, and gitlab project management. The biggest challenge is still memorization — do not do it actively anymore except when necessary. Work as a ‘processing machine’: open notes, switch context for a while, process for results. The older the topic, the longer the lead time — can take from a couple of hours to a couple of weeks.

Sep 2015 - MLCP 2.0 — LP solver in Julia

Implementation of linear programming and LU decomposition — exploring numerical methods for constraint solving that underpin physics engines.
Tech: Julia, GLPK. Algos: Linear programming (notes), LU decomposition.
Key files: lp_glpk.jl, lu.jl.
Notes: Eigenvalues, eigenvalues2
Built on lamby research; applied at #5 Havok and #10 Guided Knowledge.

Source Tree

├── _dcd_off.jl
├── _dcd_on.jl
├── _load_common.jl
├── _load_lp_1.jl
├── _load_lu_1.jl
├── arg.jl
├── bench/
│   └── impcol_a.mtx.gz
├── conv.jl
├── load_lp_dcd.jl
├── load_lp.jl
├── load_lu.jl
├── load.jl
├── lp_bench.jl
├── lp_glpk.jl
├── lp_jad.jl
├── lp.jl
├── lu_bench.jl
├── lu_julia.jl
├── lu_std.jl
├── lu.jl
├── mlcp.jl
├── shared_funcs.jl
└── shared_types.jl

Jul 2015 - asinus_salutem — Math expression parser

Interactive math expression parser with symbolic computation — a CLI tool for quick mathematical exploration and verification.
Tech: Python, SymPy. Algos: Expression parsing, AST construction.
Key files: as.py.
Built for mathematical exploration tooling.

Source Tree

├── as.py
├── helper_arg.py
├── helper_math1.py
├── helper_term.py
└── scripts/
  ├── gk_notes_p45.txt
  ├── script1.py
  ├── test_basics.txt
  ├── test_comp.txt
  ├── test_df.txt
  ├── test_mtest.txt
  ├── test_parser.txt
  ├── test_scope.txt
  └── test_ztest.txt

2013-2014 - Study: Mathematics & Physics History
- Intensive self-study period driven by curiosity — exploring the historical and philosophical foundations of mathematics and physics through primary sources and classic texts.
- Algos: LCP (notes), GJK (notes), Eigenvalue decomposition.
- Notes: History & Philosophy: Jammer’s Force, Stevin, Whittaker Aether, Morris Kline
- Notes: Foundations: Euler, Euclid, Zakon, Barwise Liar, Number Theory, Infinity, Convergence
- Notes: Linear Algebra: Eigenvalues, Hefferon LinAlg
- Notes: Algorithms: LCP, LCP supp, GJK
- Key files: lamby, gjk0.py
May 2011 - Floating Point Analysis — IEEE 754 deep dive
- Low-level exploration of IEEE 754 floating-point representation — bit manipulation, epsilon calculation, and denormal handling essential for numerical stability in physics code.
- Tech: Python, C++. Algos: IEEE 754 bit manipulation, epsilon calculation, denormals.
- Key files: bitfp.cpp, bitfp.py.
- Notes: asymp_not
- Applied at #5 Havok for low-level numerical optimization.
Source Tree
```
├── bitfp.cpp
├── bitfp.py
└── line_err.py
```
2011-2012 - Study: Mathematical Foundations — 77-neurons Project Perelman
- Year-long structured self-study curriculum in mathematics with study partners — building rigorous foundations in calculus, proofs, and linear algebra through weekly exercises and discussions.
- Algos: Calculus, Mathematical proof, Linear algebra.
- Books: The Calculus Lifesaver (Banner), Book of Proof (Hammack), Linear Algebra (Hefferon)
- 77-neurons-project-perelman: Calculus, Proofs, Linear Algebra
2009-2011 - Killzone 3 AI Systems at #6 Guerrilla Games
- Environment-aware AI physical behavior for Killzone 3 — jetpack navigation, owl patrol AI, environment interaction.
- Context: SPU + PS3 multithreading/DMA tricky bug chasing.
- Tech: C++, PS3/SPU. Algos: Behavior trees, environment queries, physical animation.
- Video: Jetpack and Owl AI.
2009-2011 - Killzone 3 Vehicle AI at #6 Guerrilla Games
- Vehicle pathfinding and motion planning for AI-controlled vehicles in Killzone 3.
- Context: Prototyping (VehicleTest).
- Tech: C++. Algos: Motion planning, vehicle dynamics, path following.
- Video: Vehicle AI.
2009-2011 - Automatic Region Generation at #6 Guerrilla Games
- Automated navmesh region generation using skeletonization — improving on Recast’s “ugly and cryptic” code with better corner case handling.
- Context: Porting of Recast ‘ugly and cryptic’ code. Improvements on corner cases that other companies presented as challenges during GDC. Research skeletonization algorithms. Choose and implement. Modify to fit application (stray edges).
- Tech: C++. Algos: Skeletonization, Medial axis transform, region decomposition.
Nov 2010 - RecastMOD — Navigation mesh system
- Modified version of Recast & Detour — the industry-standard navmesh library used in AAA games for AI pathfinding through voxelization and mesh generation.
- Tech: C++, OpenGL, Recast & Detour. Algos: Voxelization, Navigation mesh, [A](https://en.wikipedia.org/wiki/A_search_algorithm).
- Key files: Recast.cpp, RecastRasterization.cpp, DetourStatNavMesh.cpp.
- Notes: Collision Detection, algcrumb
- Built on AI Sandbox pathfinding; applied at #6 Guerrilla for automated navigable space.

Aug 2010 - Bigfoot Animation — Skeletal animation with physics

Skeleton retargeting and motion planning system — exploring character animation pipelines, physics-based locomotion, and motion capture processing.

Context: Mocap loader, skeleton semantics, footplant detection. Bigfoot video. Example: smart pointers 10 years ago.
Tech: C++, OpenGL, GLM, Bigeye UI. Algos: BVH, Skeletal animation, Motion retargeting, Quaternion (notes).
Key files: LoaderBVH.cpp, Retarget.cpp, Locomo.cpp, Planner.cpp.
Notes: RBD, Lagrangian, Rotation, Covariance, Hestenes GA
Built on Puppeteer/Bigeye; applied at #7→#6→#5. Video.

Source Tree

└── src/
  ├── BF/
  │   ├── 3rdparty/
  │   ├── BFMath.h
  │   ├── Camera.cpp
  │   ├── Camera.h
  │   ├── ColorUtil.cpp
  │   ├── ColorUtil.h
  │   ├── DrawUtil.h
  │   ├── GridRenderer.cpp
  │   ├── GridRenderer.h
  │   ├── LoaderBVH.cpp
  │   ├── LoaderBVH.h
  │   ├── Locomo.cpp
  │   ├── Locomo.h
  │   ├── LocomoRender.h
  │   ├── Random.cpp
  │   ├── Random.h
  │   ├── Rendering.h
  │   ├── Skeleton.cpp
  │   ├── Skeleton.h
  │   ├── SkeletonAnalyzer.cpp
  │   ├── SkeletonAnalyzer.h
  │   ├── SkeletonPhysicsModel.cpp
  │   ├── SkeletonPhysicsModel.h
  │   ├── SkeletonRenderer.cpp
  │   └── SkeletonRenderer.h
  ├── Main.cpp
  ├── Planner.cpp
  ├── Retarget.cpp
  └── Viewer.cpp

Aug 2010 - BlenderToBVH — Animation export tool

Blender addon to export armature animations to BVH format — enabling custom animation pipelines and motion capture integration.
Tech: Python, Blender API. Algos: Armature traversal, coordinate system conversion.
Key files: bvh_export.py.
Used in Bigfoot animation pipeline.

Source Tree

├── bvh_export.py
├── BVHFriendlyArmature.blend
├── OneBone_NoRots.blend
├── OneBone_RotX90.blend
├── OneBone_RotY90.blend
├── OneBone_RotZ90.blend
├── OneRoot_NoRots_1Child_NoRots.blend
├── OneRoot_NoRots_1Child_Rot1.blend
├── OneRoot_Rot1_1Child_Rot1.blend
├── OneRoot_Rot1_2Child_Rot1.blend
├── Proto1.blend
├── Test3Bones.blend
├── proto1_export.bvh
├── Test1.bvh ... Test10.bvh

May 2010 - Bigeye UI — UI framework

Lightweight retained-mode UI framework with scene graph rendering — built for rapid prototyping of graphics and simulation tools.

Tech: C++, OpenGL, MagickWand, Win32. Algos: Retained-mode rendering, Scene graph.
Key files: Bigeye.cpp, RenderNodes.h.
Used for rapid prototyping throughout career.

Source Tree

└── src/BE/
  ├── ARB_Multisample.cpp
  ├── ARB_Multisample.h
  ├── Assert.h
  ├── BEMath.h
  ├── Bigeye.cpp
  ├── Bigeye.h
  ├── Demo.cpp
  ├── LibInclude.h
  ├── MagickWand.cpp
  ├── MagickWand.h
  ├── MainWindow.cpp
  ├── MainWindow.h
  ├── OGL.cpp
  ├── OGL.h
  ├── Platform.h
  ├── Renderer.cpp
  ├── Renderer.h
  ├── RenderNodes.cpp
  ├── RenderNodes.h
  ├── RenderTreeBuilder.cpp
  ├── RenderTreeBuilder.h
  ├── WidgetEvent.h
  ├── Widgets.cpp
  └── Widgets.h

Apr 2010 - Puppeteer — BVH viewer

BVH file loader and skeletal animation viewer — foundation for character animation research and motion capture visualization.
Tech: C++, OpenGL, GLM. Algos: BVH parsing, skeletal rendering.
Key files: LoaderBVH.cpp, Skeleton.h.
Foundation for Bigfoot animation system.

Source Tree

└── src/
  ├── app.h
  ├── ARB_Multisample.cpp
  ├── ARB_Multisample.h
  ├── Camera.cpp
  ├── Camera.h
  ├── dSFMT/
  ├── freeglut/
  ├── glm/
  ├── LoaderBVH.cpp
  ├── LoaderBVH.h
  ├── main.cpp
  ├── mesh.h
  ├── NeHeGL.cpp
  ├── NeHeGL.h
  ├── Random.cpp
  ├── Random.h
  ├── Rendering.h
  ├── Skeleton.cpp
  ├── Skeleton.h
  ├── SkeletonRenderer.cpp
  ├── SkeletonRenderer.h
  ├── strtk/
  └── wavefrontObjLoader/

2008-2010 - AI Sandbox at #7 AiGameDev
- Open-source game AI development framework — main programmer for a platform used by the AI game development community for research and education.
- Tech: C++. Algos: HPA*, locomotion system, Reinforcement learning.
- Notes: ml_survey. Books: #3 AI Game Programming Wisdom
- Main programmer; co-authored “Parallel Pathfinding on Modern Hardware”. Applied at #6, #5.
Apr 2009 - Obstacle Avoidance — Steering behaviors
- Implementation of velocity obstacles and steering behaviors — local collision avoidance for crowds and NPC navigation.
- Tech: C++, 2D visualization. Algos: Velocity obstacles, collision prediction, steering.
- Applied at #7, #6. Video.

Apr 2009 - TicTacToe AI — AI algorithms testbed

Classic game AI algorithms implemented as a learning exercise — minimax, alpha-beta pruning, and reinforcement learning on a simple domain.
Tech: C++, Visual Studio. Algos: Minimax, Alpha-Beta pruning, Value iteration (RL).
Notes: FOL, plql
RL contribution to #7 AI Sandbox.

Source Tree

├── Readme.txt
├── TicTacToe.sln
├── TicTacToe.vcproj
└── src/
  ├── Array.hpp
  ├── main.cpp
  ├── Ptr.hpp
  ├── Random.hpp
  ├── SuperHeader.hpp
  ├── TicTacToeAIPlayerAlphaBetaMinimax.cpp
  ├── TicTacToeAIPlayerAlphaBetaMinimax.hpp
  ├── TicTacToeAIPlayerConsoleInput.cpp
  ├── TicTacToeAIPlayerConsoleInput.hpp
  ├── TicTacToeAIPlayerHeuristic.cpp
  ├── TicTacToeAIPlayerHeuristic.hpp
  ├── TicTacToeAIPlayerRandom.hpp
  ├── TicTacToeAIPlayerRLValueIter.cpp
  ├── TicTacToeAIPlayerRLValueIter.h
  ├── TicTacToeGame.cpp
  └── TicTacToeGame.hpp

Apr 2009 - Graphics Framework — Quake3 BSP renderer

BSP-based renderer loading Quake 3 maps — exploring spatial partitioning, PVS culling, and real-time rendering techniques from classic game engines.
Tech: C++, OpenGL, Win32. Algos: BSP traversal, PVS culling, lightmaps.
Built on thrashit3d experience from university.

Source Tree

├── GfxFramework/
│   └── Source/
│       ├── BasicRenderer.cs
│       ├── BezierPatch.cs
│       ├── EffectContext.cs
│       ├── Renderer.cs
│       ├── RenderResourceManager.cs
│       ├── Scene.cs
│       ├── TriangleListType.cs
│       └── UniformGridTesselator.cs
├── Quake3App/
│   └── Source/
│       ├── Game1.cs
│       └── ManualCamera.cs
└── Quake3Lib/
  ├── Q3ShaderParser/
  └── Source/

2006-2008 - World-Of-Football at #9 Kimera

Complete indie game engine for a football (soccer) game — custom rendering, physics, animation, and neural network-based goalkeeper AI.

Context: YouTube videos.
Tech: C++, DirectX. Algos: Custom physics, Neural networks (goalkeeper AI), spatial partitioning.
Foundation for #8 Sixteen Tons and #7 AiGameDev.

Source Tree

├── dep/
│   ├── DXUT_9_0_c/
│   ├── squirrel_2_1_1_sqplus/
│   └── tinyxml/
├── Doc/
├── Media/ (screenshots, videos)
├── WitchEngine3/src/WE3/
│   ├── audio/
│   ├── coll/
│   ├── coordSys/
│   ├── geometry/
│   ├── input/
│   ├── math/
│   ├── mesh/
│   ├── phys/
│   ├── render/
│   ├── scene/
│   ├── script/
│   ├── skeleton/
│   ├── spatialManager/
│   └── ui/
├── WOF2/src/WOF/
│   ├── match/
│   │   ├── Clock.cpp
│   │   ├── Match.cpp
│   │   ├── Team.cpp
│   │   ├── Player.cpp
│   │   ├── collision/
│   │   ├── entity/
│   │   ├── scene/
│   │   ├── script/
│   │   └── spatialQuery/
│   └── script/
└── WOF_Debugger/

1998 - University Projects (AUB) — Early graphics and systems programming

First explorations in 3D graphics and distributed computing during computer engineering degree at American University of Beirut — foundations for all subsequent graphics and systems work.
thrashit3d — Software 3D renderer with full pipeline: projection, occlusion, rasterization (flat/Gouraud/wireframe), z-buffering, viewport clipping
RayTracer — Ray tracing with BVH acceleration, Blinn-Phong shading, hard shadows, supersampling, parallel rendering
xu1 — 3D racing game engine with ASE model loading, octree spatial partitioning, static geometry builder
watereffect — Java height map wave simulation with circular/spherical wave propagation, real-time image distortion
2dshooter — Java game engine (fivemagics) with 2D collision detection, physics engine, GUI system, resource loading, XML scene description
GraphEdit — 3D equation grapher with symbolic expression evaluation and distributed rendering
Foundation for #9 Kimera and all subsequent graphics work.

Source Tree

├── 2dshooter/fivemagics/ (Java game engine)
│   ├── applet/GenericApplet.class
│   ├── collision/
│   │   ├── ICollisionHandler.class
│   │   └── d2/{circle,rect}/CollisionArea.class, CollisionEngine.class
│   ├── dataformats/AwtImage.class, XMLFile.class, XMLTag.class
│   ├── engine/
│   │   ├── IEngine.class
│   │   ├── d2/physics/PhEngine.class, PhObject.class
│   │   └── gui/GUIEngine.class, WMenu.class, WTextConsole.class
│   ├── evt/Event.class, TimedEventManager.class
│   ├── geo/d2/D2FloatPoint.class, D2Line.class
│   ├── gfx/
│   │   ├── PixelData.class, IBlittable.class, IGfxImage.class
│   │   ├── d2/GfxEngine.class, ImageAnimation.class
│   │   └── filter/hmap/HeightMap.class, CircularWave.class
│   ├── res/ResEngine.class, ResLoaderThread.class
│   └── projects/thrashem/Applet.class, PlayerShip.class, EnemyShip.class
├── graphedit/ (screenshots, index.html)
├── RayTracer/
│   ├── data/bunny.obj, cornell_box.obj/.mtl
│   ├── screenshots/ (render results)
│   └── src/
│       ├── main.cpp
│       ├── 3rdparty/
│       │   ├── awilliam/
│       │   ├── LofstedtAkenineMoller05/
│       │   ├── PixelToaster1.4/
│       │   ├── plyLoader/
│       │   └── wavefrontObjLoader/
│       ├── rayTracer/
│       │   ├── BoundingVolumeHierarchy.cpp/.hpp
│       │   ├── Camera.cpp/.hpp
│       │   ├── Material.cpp/.hpp
│       │   ├── Math.cpp/.hpp
│       │   ├── ParallelProcessor_Simple.cpp/.hpp
│       │   ├── PostProcess.cpp/.hpp, GaussianBlur.cpp/.hpp
│       │   ├── Primitive.cpp/.hpp
│       │   ├── Primitive_{Sphere,Plane,Triangle,Quad,Cone}.hpp
│       │   ├── Ray.hpp, RayTracer.hpp
│       │   ├── Renderer.cpp/.hpp
│       │   ├── RenderImage.cpp/.hpp, RenderTarget.cpp/.hpp
│       │   ├── Scene.cpp/.hpp
│       │   └── SpatialAccelerator.cpp/.hpp
│       └── WE3/ (engine utilities)
├── thrashit3d/
│   ├── engine/
│   │   ├── ThrashIt3D.cpp, ThrashIt3D.h
│   │   ├── TIStageOcclusion.cpp/.h
│   │   ├── TIStageProjection.cpp/.h
│   │   ├── TIStageRasterization.cpp/.h
│   │   ├── TIStageRasterizationFlat.cpp/.h
│   │   ├── TIStageRasterizationGouraud.cpp/.h
│   │   ├── TIStageRasterizationWireframe.cpp/.h
│   │   ├── TIStageTransformation.cpp/.h
│   │   ├── TIViewport.cpp/.h
│   │   └── TIZBuffer.cpp/.h
│   └── geom/
│       ├── TIAngle.cpp/.h
│       ├── TIBasicVertex.cpp/.h
│       ├── TIGeometry.cpp/.h
│       ├── TITransform.cpp/.h
│       ├── TITriangle.cpp/.h
│       └── TIVertex.cpp/.h
├── watereffect/ (23 Java classes)
│   ├── Applet1.class, GenericApplet.class
│   ├── CircularWave.class, CircularWave2.class, SphereWave.class
│   ├── HeightMapImage.class, IHeightMapGenerator.class
│   ├── IScene.class, Scene1.class
│   └── Drop1Event.class, TimedDrop1Event.class
└── xu1/src/ThrashIt/
  ├── FileFormats/
  │   ├── ASE/ASEFile.cpp/.h, ASEGeomObject.cpp/.h
  │   └── TIS/TISFileStructs.cpp/.h
  ├── General/Collection/
  │   ├── CArray.cpp/.h, CHashTable.cpp/.h
  │   ├── Tree.cpp/.h, FixedTree.cpp/.h
  │   └── String.cpp/.h, Fraction.cpp/.h
  └── MabenEngine/TIStaticGeometry/
      ├── PreBuild/TIStaticBuilder.cpp
      └── RealTime/TIStaticGeometryRealTime.cpp/.h

Career

Irreducible (2024-) Engineering Director, ZK/hardware
FERNRIDE (2023-24) Principal Engineer, autonomous trucks
Argo AI (2021-22) Engineering Manager, AV simulation
Audi AID (2018-20) Simulation Tech Lead
Havok/Microsoft (2011-18) Lead Physics R&D
Guerrilla Games (2009-11) Senior AI, Killzone 3
AiGameDev (2008-10) Main programmer, AI Sandbox
Sixteen Tons (2008) Nintendo DS engine
Kimera Studios (2006-08) Indie engine
Guided Knowledge (2015) IMU optimization

Books

Favorite technical books studied throughout career.

Statistics for Experimenters (Box, Hunter, Hunter) — Design of experiments, hypothesis testing, confidence intervals
Probabilistic Safety Assessment in the Chemical and Nuclear Industries (Fullwood) — Safety analysis for chemical and nuclear industries
AI Game Programming Wisdom (4 volumes) — Game AI algorithms and techniques
Linear Algebra (Hefferon) — Free textbook, worked through completely in 77-neurons with detailed notes
Book of Proof (Hammack) — Introduction to mathematical proof techniques
Linear Algebra Done Right (Axler) — Abstract approach to linear algebra, memo notes
Mathematical Thought from Ancient to Modern Times (Morris Kline) — History of mathematics, notes
Euclid’s Elements (Heath translation) — Classical foundations of geometry, notes
The Calculus Lifesaver (Banner) — Worked through in 77-neurons weeks 1-20
The Symmetric Eigenvalue Problem (Parlett) — Numerical linear algebra, notes
Set Theory and its Philosophy (Potter) — Foundations of mathematics, notes
Reason’s Nearest Kin (Potter) — Philosophy of mathematics, notes
The Liar: An Essay on Truth and Circularity (Barwise & Etchemendy) — Logic and paradoxes, notes
Basic Concepts of Mathematics (Zakon) — Foundations, notes
Concepts of Force (Jammer) — History and philosophy of physics, notes
A History of the Theories of Aether and Electricity (Whittaker) — Classical physics history, notes
There’s Something about Gödel (Berto) — Incompleteness theorem, notes 1, notes 2
Mathematical Logic (Chiswell & Hodges) — First-order logic, handwritten notes
Reforming the Mathematical Language of Physics (Hestenes) — Geometric algebra for physics, notes
Euler’s Writings — Primary sources, notes

This post is licensed under CC BY 4.0 by the author.

Learning Journey

Knowledge Graph

Projects

Career

Books

Trending Tags