[ Index of Work ]
Projects
Repositories & Live Demos
///Scientific Machine Learning & Differentiable Systems
JAX-Accelerated Differentiable Simulation Engine
> The Engineering Problem
Physics simulators are usually hand-derived forces run in a Python time loop, which is slow and awkward to differentiate.
> The ML & Mathematical Solution
This engine defines one potential energy and gets the forces by JAX autodiff, then JIT-compiles the whole rollout into a single XLA kernel that stays differentiable end to end, so inverse problems reduce to gradient descent through the simulator. Measured: the compiled rollout runs 48x faster per step than the eager loop at 1k nodes, and reverse-mode gradients cost a flat 2.4x the forward pass (benchmarks).
Tech Stack
Real-time Mesh Dynamics WebGPU Visualizer
> The Engineering Problem
Interactive cloth and mesh simulation in the browser has to solve thousands of constraints per frame at 60 fps without going unstable.
> The ML & Mathematical Solution
This runs the entire particle mesh on the GPU with WebGPU compute shaders written in Three.js TSL, using small-step Position-Based Dynamics so it stays stable and you can grab and drag any node, with a CPU WebGL2 fallback where WebGPU is missing.
Tech Stack
Neural Implicit Fields (SDF & NeRF Renderer)
> The Engineering Problem
Meshes tie 3D geometry to a fixed resolution, and classical renderers break the gradient chain, so a shape cannot be learned directly from images.
> The ML & Mathematical Solution
A coordinate MLP stores the shape as a continuous function and is rendered differentiably, either as a neural signed distance field by sphere tracing or as a NeRF-style radiance field by volume integration, so an image or silhouette loss backpropagates into the network weights.
Tech Stack
Differentiable Digital Twin (Inverse Problem Solver)
> The Engineering Problem
Designing a load-bearing structure means searching a huge space of material layouts for the stiffest one under a fixed budget.
> The ML & Mathematical Solution
This backpropagates through a finite-element solver in PyTorch, so one backward pass optimizes the whole material field with Adam, and the resulting design and its optimization trajectory replay in the browser on a WebGPU player.
Tech Stack
///Graph Machine Learning & Generative Modeling
Graph ML Lab: 3D Spatial Graph Generation
> The Engineering Problem
Generating realistic 3D branching morphologies, like trees or neuron-like arbors, is hard because proximity does not imply connectivity: the discrete graph topology and the continuous 3D geometry have to be modelled together, which off-the-shelf generative models do not handle.
> The ML & Mathematical Solution
A graph generative-modelling framework written from scratch in pure PyTorch (no PyG or DGL), built around energy-based and probabilistic models: a conditional graph VAE, autoregressive spatial-tree generation, and a joint discrete-continuous diffusion that denoises graph structure and 3D node positions at the same time.
Methodology Highlights
- Joint discrete-continuous diffusion over topology and 3D coordinates
- Autoregressive spatial-tree VAE with joint topology-geometry sampling
- Custom GCN/GAT message-passing layers built from raw tensor operations
- Evaluation pipeline: morphological metrics, Sholl analysis, spatial MMD
Tech Stack
///Differentiable Simulation & Physics
Mesh-Based Differentiable Physics Simulator
> The Engineering Problem
Tuning a physics simulation to hit a target behaviour normally needs gradient-free search, because conventional simulators are not differentiable. That is slow, sample-inefficient and hard to fit into an optimisation loop.
> The ML & Mathematical Solution
A fully differentiable pipeline in PyTorch: mesh topology initialises a particle-spring system, forces follow energy-based formulations, and end-to-end backpropagation through the continuous dynamics lets you optimise physical parameters with custom PyTorch loss functions.
Methodology Highlights
- Differentiable physical pipeline: gradients flow through the full simulation
- Custom PyTorch loss functions for gradient-based simulation control
- Energy-based force formulation derived from mesh topology
- Vectorised, GPU-accelerated tensor operations (CUDA / MPS)
Tech Stack
Knitted Models
> The Engineering Problem
Procedurally generating manufacturable woven, knit and chain-mail strand patterns on arbitrary 3D surfaces requires robust traversal of mesh connectivity and smooth, exportable curve geometry.
> The ML & Mathematical Solution
A geometry-processing pipeline that ingests quad meshes, builds a half-edge data structure for O(1) topological traversal, traces continuous strand paths, and fits Catmull-Rom or Hermite splines. The result renders with GPU path tracing or exports to OBJ for downstream tooling.
Methodology Highlights
- Half-edge data structure for O(1) topological traversal
- Catmull-Rom and Hermite spline interpolation for smooth strand geometry
- Weave, knit-loop and chain-mail pattern generation from quad topology
- GPU path tracing for rendering; OBJ export
Tech Stack
Traer Physics Simulations
> The Engineering Problem
Interactive real-time particle and cloth simulation in the browser needs high-throughput compute and an architecture that can optionally offload to a heavier GPU backend without rewriting the renderer.
> The ML & Mathematical Solution
A real-time particle-system engine with structural, shear and bending spring constraints that runs standalone on flat Float32Array buffers, or streams from a PyTorch backend over a binary WebSocket protocol (10 to 20 times faster than JSON) at 60 Hz behind an unchanged renderer.
Methodology Highlights
- Float32Array buffers for high-performance browser-side compute
- Structural, shear and bending constraints for cloth simulation
- Binary WebSocket protocol with an optional PyTorch backend at 60 Hz
- Decoupled compute / render architecture
Tech Stack
Ricci Flow on Surfaces of Revolution
> The Engineering Problem
Evolving a geometry under a curvature-driven PDE is numerically stiff and prone to blow-up, and making the process explorable means streaming solver state to a 3D frontend in real time.
> The ML & Mathematical Solution
A finite-difference PDE solver with Fourier filtering and reparametrisation for stability that evolves surface metrics toward constant curvature, computes curvature fields as geometric data, and streams them to a Three.js frontend over WebSocket.
Methodology Highlights
- Finite-difference PDE solver with Fourier filtering and reparametrisation for stability
- Curvature-field computation as geometric data
- Python to Three.js streaming over WebSocket
- Real-time 3D rendering with curvature-based colouring
Tech Stack
///Scientific Computing & Numerical ML
DiffQFT: Differentiable Computation on Curved Geometries
> The Engineering Problem
Computations on curved, non-Euclidean geometries hinge on expensive high-dimensional integrals, and inferring the parameters of such a system means differentiating through that whole numerical pipeline, which black-box solvers cannot do.
> The ML & Mathematical Solution
A fully differentiable computation framework (PyTorch autograd) for multi-dimensional tensor operations and Monte-Carlo integration over a curved 2D (hyperbolic) domain. It trains neural surrogate models that replace expensive Monte-Carlo evaluations, a physics-informed neural network for a non-linear PDE, and a gradient-based inverse-optimisation workflow that recovers latent parameters from boundary observations.
Methodology Highlights
- Custom autograd functions for integration on non-Euclidean domains, for geometric data processing and topological reasoning
- Neural surrogate models replacing Monte-Carlo evaluation for order-of-magnitude speedups
- Physics-informed neural network (PINN) for a non-linear (Klein-Gordon) PDE
- Gradient-based inverse problem: recovering latent parameters from boundary data
- Energy-based, non-linear (Sine-Gordon) model under a differentiable optimisation framework
Tech Stack
Neural ODE: Learning Chaotic Dynamics
> The Engineering Problem
Can a neural network learn the equations of a chaotic dynamical system straight from trajectory data, built entirely from scratch with no ML libraries, so that every part of the autodiff and optimisation loop is visible?
> The ML & Mathematical Solution
A from-scratch neural network (matrix ops, He initialisation, forward/backward pass, Adam) learns the Lorenz vector field against an RK4 ground-truth integrator and trains live in the browser. A companion PyTorch prototype backpropagates through the RK4 solver as a differentiable simulation.
Methodology Highlights
- From-scratch neural network: matrices, He init, backprop, Adam, no ML libraries
- RK4 numerical integrator for ground-truth chaotic trajectories
- Real-time, in-browser training loop
- PyTorch prototype: gradient-based simulation through the RK4 solver
Tech Stack
PINN Solver
> The Engineering Problem
Classical PDE solvers need bespoke meshing and a separate implementation per equation, and shipping them for interactive use is heavyweight.
> The ML & Mathematical Solution
Physics-Informed Neural Networks solve 10 PDEs with a custom physics loss (PDE residual plus boundary and initial conditions). The approach is mesh-free and gradient-based. Pre-trained models run inference client-side in JavaScript, and a training CLI handles new equations and hyperparameter sweeps.
Methodology Highlights
- Custom physics-informed loss: PDE residual + boundary/initial conditions
- Mesh-free, gradient-based PDE solving across 10 equations
- Client-side JavaScript inference, no backend required
- Training CLI for custom equations and hyperparameter sweeps
Tech Stack
Integration Visualizer
> The Engineering Problem
Computing and explaining integrals across symbolic, numerical and stochastic methods, and verifying vector-calculus theorems, usually means stitching together disconnected tools with no shared 3D view.
> The ML & Mathematical Solution
A unified engine that computes single-through-flux integrals via symbolic (SymPy), numerical (SciPy) and Monte-Carlo (PyTorch) pipelines, verifies the Green, Stokes and Divergence theorems, and renders surfaces, vector fields and integration regions interactively in 3D.
Methodology Highlights
- Symbolic, numerical and Monte-Carlo computation pipelines
- Interactive 3D visualisation of surfaces, vector fields and regions
- Theorem verification: Green, Stokes, Divergence