Oliver Hardi

About Me

Hi, I'm Oliver — a self-taught high school developer focused on exploring the intersection of computer science, mathematics, physics, and art.

My past work has a strong focus on computer graphics and real-time rendering, where I use advanced techniques like path tracing and light transport approximations. These projects were created using a basis in physics and mathematical subjects, such as linear algebra, calculus, and statistics.

Beyond graphics, I'm actively exploring machine learning and its applications in quantitative finance and algorithmic trading. I enjoy bridging the gap between theoretical concepts and practical implementations, whether that's rendering photorealistic images or analyzing market patterns.

I try to build experience through long-term personal projects. I believe the best way to understand complex systems is to build them from the ground up.

Skills

Computer Graphics
Machine Learning
Physics Simulations
Procedural Generation
OpenGL/WebGL/WebGPU
FRC Programming
C++
JavaScript
Python
GLSL/HLSL
Web Dev (HTML/CSS)
Java

WebGL
Spectral Path Tracer

This is a physically based path tracer implemented in JavaScript and WebGL. It simulates light transport in a 3D simulation constructed from meshes of triangles. All features in this project rely on no outside libraries and were built entirely from scratch.

  • Spectral wavelength based rendering
  • A custom BVH (bounding volume hierarchy) implementation
  • Supports gltf separated file imports (.gltf and .bin)
  • MIS using environment map importance sampling
  • Automatic conversion from typically stored materials to custom spectral PBR materials
  • Complex camera lens simulation, using focal length, aperture radius, etc. for depth of field

WebGL
Fractal "Path marcher"

This is another custom path tracer built in JavaScript and WebGL, but this time focused on rendering fractal geometry using ray marching. This project is able to render complex fractals defined by iterative mathematical functions.

The camera lens simulation in this project is also more advanced, allowing for more realistic images.

C++ and OpenGL
Barnes-hut N-body Simulation

This is a C++ implementation of a large-scale N-body simulation using the Barnes-hut algorithm.

The Barnes-hut algorithm is an efficient method for simulating the gravitational interactions between a large number of bodies. It works by recursively dividing the simulation space into a hierarchical tree structure called a quadtree.
Separate to the Barnes-hut algorithm, I also perform a collision detection and resolution step using a spatially hashed grid to handle collisions between bodies.

In my implementation I multithreaded the force and collision calculations to greatly improve performance.

The circles are rendered using instancing in OpenGL for efficiency.

WebGL
(2D) Path Tracer

This is a 2 dimensional path tracer created over the span of 3 days. It simulates light transport in a 2D environment, demonstrating how light behaves differently in lower dimensions.

JavaScript
Impulse Physics Engine

This is a 2D physics engine built in JavaScript using an impulse-based method for simulating rigid body dynamics. It supports various shapes, including n-sided irregular convex polygons. The engine handles collision detection in two phases:

  • Broadphase: Utilizes Axis-Aligned Bounding Boxes (AABB) for efficient preliminary collision checks
  • Narrowphase: Implements the Separating Axis Theorem (SAT) for precise collision detection between convex shapes

Python (PyTorch)
ML Market Predictor

This is a machine learning model built in Python using PyTorch to predict stock market movements based on historical data. The model utilizes short-term indicators to make fast trades.

  • The model uses LSTM (Long Short-Term Memory) architecture
  • Uses historical stock data and technical indicators as input features
  • Predicts percentage change over a future interval

OpenGL + CUDA
3D Boid Simulation

This is a 3D boid simulation implemented in C++ using OpenGL + CUDA interop. The boid algorithm simulates flocking behavior in birds through three main rules: separation, alignment, and cohesion. The simulation utilizes a spatial hashing algorithm to optimize the neighbor lookup to O(n).

OpenGL compute shaders and used to handle building the hashes, which are sorted with a CUDA kernel using a radix sort.

Contact Me

Feel free to reach out through any of these links or check out my other stuff!

×