C++ · GPU · rendering and simulation

Rendering &
graphics engineering.

My projects explore computer graphics and GPU pipelines, photorealistic and stylized rendering, physical simulation, symbolic mathematics, advanced algorithms, and deep learning.

I build full implementations and interactive visualizations to make these ideas tangible. They range from browser applications and hybrid CPU/GPU desktop tools to an unusual rendering setup built on Rive’s 2D vector engine.

Start with the flagships

What's shown hereFour featured projects introduce four areas of my work. Hover over one to reveal four related projects, then click any card to explore.

RadianceLab previewRadianceLab
RIVX previewRIVX
Modal2D previewModal2D
Symbolic Unfolded previewSymbolic Unfolded
Rendering
Aperture previewAperture
Photon Primitives previewPhoton Primitives
Flatland — Light Transport previewFlatland — Light Transport
Analytical Render · LTC previewAnalytical Render · LTC
01

Flagships

These six projects are the ones I'm most proud of: each combines technical depth, refinement and innovation in its design. RadianceLab is an interactive CPU/GPU rendering system with ten rendering modes, including methods from my own research paper and unpublished follow-ups. RIVX explores how rendered 3D scenes can become Rive animation, alongside extended drawing, editing and live GPU computation. Modal2D is a physically based audio simulator and musical instrument designer that lets you create music by simulating physical interactions, with no recorded samples needed. Crucible2.5D explores coupled materials and their changing surfaces; Symbolic Unfolded makes symbolic reasoning inspectable; Fortune’s Loom exposes the geometry, data structures and difficult cases of a sweep-line algorithm.

Three glass spheres refract a striped backdrop and cast sharply defined volumetric caustics.A glass sphere casts colorful volumetric caustics into the surrounding medium.ResearchDesktop + VideoMotion tour · speeds labeledConnections
Research

RadianceLab

Graphics · Research

An interactive CPU/GPU renderer for exploring light transport in a variety of scenes. Switch among ten selectable modes spanning established methods and photon estimators from my own research, edit materials and media in place, inspect paths and intermediate structures, then set up the camera and refine a beauty shot.

Fun factIts unpublished photon hourglass sweeps rays refracted through a glass sphere into a ruled sheet; a camera ray gathers their light by crossing that sheet analytically, without a beam radius to blur the caustic.

Photon primitivesLight transport & renderingOpenGLC++
Read the full brochure Brochure ↗Overview Technical docs Validation
The native RIVX studio reconstructs a green illuminated room with contour lines.The reimagined Rive entry shines a flashlight through glass into a misty, reflective scene.ResearchDesktop + VideoGrowingAccelerated previewConnections
System
How much of a 3D world can become a Rive animation?

RIVX

Rive · Vector graphics

A graphics studio built around a 3D-to-Rive experiment: turn motion and lighting into keyed .riv animation or contour paths, connect Rive to live GPU computation, and extend its drawing and editing tools with content-aware effects.

Fun factIt started as a Rive scripting competition entry: a small hybrid rasterizer and ray tracer with depth of field, built within a few days.

Gaussian splattingLight transport & renderingRiveC++
Read the full brochure Brochure ↗Overview
Annular finite-element mesh with a colored displacement field in Modal2D.Three tuned instruments linked to the score and playable note pads in Modal2D Music mode.ExperimentalDesktop + VideoAccelerated previewConnections
System

Modal2D

Sound

Create a fully physically based virtual musical instrument, starting with a shape, its mass and stiffness. FEM gives its vibration modes; a strike, bow or rub excites those modes to reconstruct the sound. Each shape has its own sound profile. Turn it into an instrument through careful manual tuning or an algorithm that adjusts the geometry to reach musical notes, then assemble the instruments into choirs.

Fun factNot one recorded sample: every note, even a choir playing a score, comes from the shapes' own vibration modes.

Finite elements (FEM)Inverse designCUDAC++
Read the full brochure Brochure ↗Overview
Torn, incandescent flame sheets in Crucible’s explosive material test.A glossy burger with melted cheese and sausage filling blackened on one side by heating.Ferrofluid pulled to one side through a colorful, asymmetric magnetic field.ExperimentalDesktop + VideoAccelerated previewConnections
System
Tearing, heating, baking, searing, exploding, magnetizing, growing: in 2.5D.

Crucible2.5D

Physics

A comprehensive 2D physical simulation laboratory coupling MPM, SPH and Eulerian fluids, with tearing, heating, anisotropic material structure, baking, explosions, magnetism and living materials that can grow. It's called 2.5D because I added approximate depth support to keep porous materials connected: a tunnel through a flat 2D slice can split it in two, while material outside that slice can still hold it together.

Fun factI audited a physical simulation course and kept building on my final project. Whenever I see something interesting at SIGGRAPH, I try adding a simplified version; over time, it grew into this system.

Material point methodPhysical simulationOpenGLC++
Read the full brochure Brochure ↗Overview
ExperimentalLiveAccelerated previewConnections
System
A hand-built computer algebra system with visible solution steps and checks for proposed antiderivatives.

Symbolic Unfolded

Math

A hand-built Ruby computer-algebra system centered on finding symbolic solutions—for example, expressing an integral exactly instead of approximating it numerically. It searches substitutions, identities, rational decomposition and integration by parts, then differentiates and samples the result to check it. The same expression engine also supports differentiation, simplification, exact arithmetic, residue-theorem integration, vector calculus, and more.

Fun factThis project was built from the ground up, without using any symbolic math libraries. The core part was also written completely by hand.

Symbolic integrationComputer algebraWebAssemblyRuby
Open the app Brochure ↗Overview
ExperimentalLiveAccelerated previewConnections
System
Follow Fortune's sweep through its beachline, event queue and numerical decisions. Switch tree backends and compare how they work.

Fortune’s Loom

Algorithms

A showcase of Fortune's algorithm and Apollonius diagrams, with the moving front, event queue, tree structures and arithmetic decisions all visible together. Compare beachline backends and precision policies, and inspect how degenerate cases are handled differently.

Fun factIt began as a purely Crystal project. Later, Crystal started to feel limiting, so I ported it to C++ while keeping the UX design. The Crystal version and the C++ beachline trees were written without any AI assistance.

Fortune sweepComputational geometryWebAssemblyC++
Open the app Brochure ↗Overview
02

My own research

Photon Primitives is the estimator family behind RadianceLab's most sophisticated module: photons swept into beams, rings, sheets and volumes, with MIS across the strategies. Holography & depth reconstruction builds off-axis holographic depth sensing inside a path tracer and works through what the finished depth map hides: wrapped phase, rolling shutter, multipath.

ResearchArticleConnections
Research
A simple idea opening up infinite possibilities.

Photon Primitives

A general framework for unbiased path connection, a vast family of geometric estimators, and a visual language for NPR. Complementary strategies and MIS turn that flexibility into measured rendering performance. Unpublished follow-ups explore surface footprints, signed derivatives, and the verified, fast photon hourglass implemented in RadianceLab.

Fun factOne photon sample can turn into a whole family of paths: release some of its coordinates and they sweep a curve, sheet or volume that a camera ray can hit.

Photon primitivesLight transport & renderingC++Algorithm visualization
Read the article Brochure ↗Overview
ResearchArticleConnections
Research
Digital holography & depth reconstruction: the approaches and caveats.

Holography & depth reconstruction

Build off-axis holographic depth reconstruction inside a physically based path tracer, then expose the caveats hidden by the final depth map: illumination tilt and delay, sweep geometry, rolling shutters, wrapped phase, wavelength choice, discontinuities and multipath scattering. Interactive setups show where each distortion enters and how the reconstruction pipeline resolves it.

Fun factNo light waves interfere here: the 'hologram' is an algebraic analogy built from modulated illumination and sensor correlation.

Time-of-FlightComputational imagingC++Algorithm visualization
Read the article Brochure ↗Overview
Which projects used these
Photon primitive estimators compared
Direction trio, balanced with MIS, inside RadianceLab

RadianceLab runs the family as one of its ten modes, the unpublished hourglass included. Aperture carries the holographic capture in the browser. RIVX draws the swept primitives as vector shapes. The first versions were Mitsuba and Tungsten modules; these are faster and better finished.

RadianceLab Aperture RIVX
03

Shaders and GPU pipelines

ShaderWeave is the shader development platform I use daily for experiments. It turns a GLSL, CUDA or OptiX pass into a node with a framebuffer, supporting complex shader graphs, feedback networks and Shadertoy-style shaders. WebGPU Atelier's main module shows how an image is built stage by stage, with intermediate buffers viewable on screen; the wider collection spans hundreds of WGSL shaders and many other experiments. Aperture is a real-time path tracer with advanced camera and imaging features, including a draggable tilt-shift plane and a hologram reconstruction module.

Desktop + VideoAccelerated previewConnections
System

ShaderWeave

Systems

A desktop shader designer focused on both convenience and breadth: work with GLSL, CUDA and OptiX in the same network while inspecting intermediate results together. Compose and connect render passes intuitively, and attach live previews to make debugging easier.

Fun factWritten almost entirely by hand, UI included; AI came in only during the latest polishing stage. I later reused this project's UI design in other projects.

Algorithm visualizationOptiXC++CUDA
Read the full brochure Brochure ↗Overview
LiveAccelerated previewConnections
System
A WebGPU studio for rendering, living patterns, inverse physics and quantum thought experiments.

WebGPU Atelier

Follow a rendered WebGPU scene through its shaders, buffers and intermediate passes, then explore laboratories spanning pure mathematics, evolving systems such as SmoothLife and reaction–diffusion, swarm dynamics, forward simulation, inverse physics and more. Quantum erasers and delayed-choice models sit alongside light transport, fluid solvers and a physical-contact Galton board: a broad collection of ideas whose internal computations remain visible.

Fun factThis project started as a purely educational tool, then grew into an exploration of all sorts of fun ideas and techniques. The Barebone module is closest to what I originally had in mind.

Participating mediaLight transport & renderingWebGPUTypeScript
Open the app Brochure ↗Overview
ResearchLiveConnections
Study
A path tracer in one fragment shader, with tilt-shift, dispersion, a time-of-flight gate and holograms on top.

Aperture

Graphics · Optics

A real-time path tracer for computational optics: compose a tilt-shift photograph, separate wavelengths, gate light by travel time, and reconstruct holographic measurements. Image formation and the controls that change it are part of the same experiment.

Fun factThe tilt-shift mode adapts Andrew Kensler's thin-lens construction (Ray Tracing Gems II, chapter 31); a draggable three-point gizmo gives you direct control over the focal plane.

Time-of-FlightComputational imagingWebGLJavaScript
Open the app Brochure ↗Overview
04

Inverse problems

Inverse Mechanics shapes a lens until its caustic draws a picture, then finds the kick that lands a body on target. Inverse Render Lab fits shape, material and light to renders, and images around a corner from transients. A Solid from its Shadows carves the solid its silhouettes agree on, then again in 4D.

ExperimentalLiveAccelerated previewConnections
System
Choose the ending. Search for the motion that reaches it.

Inverse Mechanics & Optics

Inverse design

Place the bodies, choose their destinations, then search for the kicks that get them there—with adjustable preferences for tumbling, impacts or detours through the scene. A C++/WASM simulator makes each candidate testable and replayable. The optical bench asks the same inverse question of caustics, shadows and thread art.

Fun factI originally got this idea when I saw a research paper at SIGGRAPH more than 10 years ago.

Geometric opticsInverse designWebAssemblyC++
Open the app Brochure ↗Overview
LiveConnections
System
Reconstructing shapes from renders—and seeing around corners.

Inverse Render Lab

Three connected inverse problems: reconstruct a 3D shape, separate material from illumination, and image around a corner. Inspect the measurements, solver, and residual to see what each reconstruction actually establishes.

Fun factIn its around-the-corner imaging experiment, blocking some light with an edge reveals more about a hidden scene: the shadow separates directions that otherwise blur together.

Gaussian splattingComputational imagingWebGPUJavaScript
Open the app Brochure ↗Overview
WIPLiveWIPAccelerated previewConnections
Exploration
Pick the shadows first: three lights, three silhouettes, and the app carves a candidate solid from their shared constraints, then applies the same idea in 4D.

A Solid from its Shadows

Choose up to three lights and the silhouette each should cast. Shadow Creator intersects the extruded silhouettes into a 3D visual hull and renders it live as a signed-distance field, with six animated fractal targets. The 4D mode carves the same way from three prescribed projections. Two 5D field explorers sit behind a second launcher.

Fun factHigher dimensions give more room to match shadows, though arbitrary targets can still conflict. The harder design problem for me is keeping the animated view consistent and making it feel physical.

Ray marchingComputational geometryWebGPUC++
Open the app Brochure ↗Overview
05

Established techniques, made practical

Analytical Render solves a polygon light three ways: exact diffuse irradiance, LTC-fitted GGX from the published tables, and Monte Carlo. LightField refocuses a rendered light field and scores NeRF and Gaussian splats, view by view, against the path-traced capture. BalanceForge trains controllers with NEAT, CMA-ES and PPO, written from scratch.

ExperimentalLiveConnections
Study
Approximate area lighting with geometric integrals, then compare it with Monte Carlo.

Analytical Render · LTC

Graphics · Lighting

Linearly Transformed Cosines approximate a complex BRDF lobe with a transformed cosine, turning direct lighting from polygonal area lights—especially quads—into closed-form edge integrals. Compare that deterministic result against Monte Carlo in a material garage while the fit and geometry stay inspectable.

Fun factLet the Monte Carlo side converge and its noise disappears; what still differs is the LTC fit's bias, which no amount of sampling removes.

Linearly transformed cosinesLight transport & renderingWebGPUC
Open the app Brochure ↗Overview
Desktop + VideoAccelerated previewConnections
System
Intuitive light field creator, viewer, and neural field trainer.

LightField / Neural

Capture a scene, then walk through its recorded light. Direct ray-field modes reveal both convincing views and surreal seams, layers and gaps; those artifacts are part of the visual exploration. Refocus the same observations or fit NeRF, Instant-NGP and Gaussian splats to compare another way of carrying the scene.

Fun factThe captured light field can be viewed immediately, but it usually needs dense sampling and good coverage to look good. Neural models take time to train, but they can fill some gaps and improve views from sparse or irregularly arranged captures, depending on coverage.

Gaussian splattingComputational imagingCUDAC++
Read the full brochure Brochure ↗Overview
ExperimentalLiveAccelerated previewConnections
System
Build the learning loop from the ground up and watch it work.

BalanceForge

Deep learning

A learning workbench built around balancing, dodging, writing and putting. Follow observations through a neural policy into physical motion, then inspect how training changes the network and its behavior. The signals, policy and learning process stay visible beside the task.

Fun factI didn't realize that perfect triple-pendulum showcases could use classical control instead of deep learning until I started working on this project.

CMA-ESControl systemsWebAssemblyC++
Open the app Brochure ↗Overview
06

Games, puzzles and π

Hackenbush Lab evaluates Red-Blue-Green positions exactly, surreal values as BigInt rationals and nimbers by the Fusion Principle. Computing π gathers sixty machines around Galperin's colliding blocks, each labelled exact, bounded, statistical, biased or π proxy. Rubik & Variant Studio holds seventy puzzles, led by Latch Cube, where each turn changes which turns are legal.

LiveAccelerated previewConnections
Study
A Hackenbush solver exploring surreal numbers, nimbers, and game values.

Hackenbush Lab

Draw and cut red, blue and green positions, then inspect canonical game forms, component sums and structural reductions. Exact finite-game analysis distinguishes surreal numbers from nimbers and fuzzy games.

Fun factA single green edge is worth 'star': either player can move to zero, yet star is not equivalent to zero; it's confused with zero (yes, that's the technical term).

Exact arithmeticGame theoryJavaScriptAlgorithm visualization
Open the app Brochure ↗Overview
LiveAccelerated previewConnections
Exploration
How many ways can we calculate π by counting physical events?

Computing π Through Physics

Two colliding blocks find π. A rolling body keeps the digits; an imperfect bounce can lose them. Explore the real collision traces, unfold the geometry, then try fields, random pours and a statistical counter on a 3D energy sphere.

Fun factI tried to give the 3D phase-space view more mathematical meaning but hadn't found a way at the time. This project includes e too: start with an empty glass and pour independent, uniformly random amounts between zero and one glassful until it overflows; the average number of pours approaches e.

Computational geometryJavaScriptPhysical simulation
Open the app Brochure ↗Overview
LiveAccelerated previewConnections
Exploration
A Rubik’s cube workbench for solving and exploring exotic variants.

Advanced Rubik & Variant Studio

Begin with Latch Cube, where each turn changes which turns are legal. Compare directional locks, bandaged pieces, coupled moves, and reactive variants through synchronized 3D puzzles, flat nets, and local route graphs.

Fun factSome puzzles in this set have directional constraints that can block the inverse of a legal move. Getting back may require a different route instead of simply reversing the scramble or using familiar memorized sequences.

State-space searchAlgorithm visualizationReactTypeScript
Open the app Brochure ↗Overview
07

Intuitive visualizations

The pieces where the picture carries the idea and the presentation matters as much as the method. First, we have our visualization system based on Fortune's Loom, which lets us showcase a wide range of algorithms clearly and conveniently. Then we have dedicated visualizations for cases where the framework's generic presentation lacks visual clarity.

Algorithm Visualization FrameworkOne visual framework for algorithm studies, grown out of Fortune's Loom.

3D Fourier · selected frequency regions
3D Fourier · selected frequency regions
Filter bank · one image, separate bands
Filter bank · one image, separate bands
Gaussian fitting · a field of soft primitives
Gaussian fitting · a field of soft primitives
Oriented splats · fit and inspect the basis
Oriented splats · fit and inspect the basis
LiveAccelerated previewConnections
Atlas
Every finished algorithm gets a visual home. A reusable library favors inspection; dedicated studies add polish.

Theory Workbench

An expanding visual notebook: whenever I finish an algorithm, I add a way to inspect it. A reusable C++ visualization library makes transforms, fitting, graphs and intermediate states easy to visualize and compare; examples include 3D Fourier decomposition with animated signals and 2D Gaussian splat fitting. Some algorithms are visually simple, and the shared framework favors showing their internal state over a polished individual presentation.

Fun factMy original idea was to create a small scripting language that made creating visualizations as easy as possible, but that turned out to be overly ambitious and unnecessarily complex, which is why this ended up as a library instead of a language.

Gaussian splattingGame theoryWebAssemblyC++
Open the app Brochure ↗Overview

GraphicsCurves and intersections, light transport in 2D, a prism bench, a soap film, computational photography, and the CPU doing a GPU's job.

LiveConnections
Atlas
Curves and intersections compared where the differences show, with every formula on screen.

Curve Atlas

Put Bézier curves, classical splines, local Yuksel interpolation and constrained curve families beside one another to see how they work and where they differ in action. Then follow 2D/2D and 2D/1D intersections—with each formula exposed—from isolated curve geometry into the same dimensional-reduction ideas used by Photon Primitives.

Fun factOne polynomial meets eleven position constraints to within about 2.6e-7, yet swings roughly 230 units outside their bounding box. Shape control matters as much as meeting the constraints.

Curve algorithmsComputational geometryReactTypeScript
Open the app Brochure ↗Overview
Desktop + VideoAccelerated previewConnections
Study
Visualizing the rendering process elegantly in 2D.

Flatland — Light Transport

A 2D transport laboratory where camera rays, light paths and photon gathers stay visible. Explore the broader Ruby/Raylib desktop tool, or compare PT, direct-light MIS, LT and finite-radius photon mapping in a smaller browser showcase running the corrected Ruby core.

Fun factIn a flat world the picture is one-dimensional: the browser camera is a pinhole with 64 angular radiance bins.

Monte Carlo methodsLight transport & renderingWebAssemblyRuby
Read the full brochure Brochure ↗Overview
LiveConnections
Study
Show the science behind dispersion without introducing wave optics.

Spectral geometric optics

An optical bench designed for intuition: move the geometry and follow each wavelength through reflection, refraction and total internal reflection. Exaggerated dispersion makes the difference between RGB color and a spectrum easy to see; it is a visual foundation for the larger spectral renderers.

Fun factFresnel splitting, dispersion and total internal reflection can all be demonstrated using animated light particles.

Geometric opticsComputational imagingJavaScriptLight transport & rendering
Open the app Brochure ↗Overview
LiveConnections
Study
One membrane. Two routes toward minimal area.

Minimal Membrane

Surface tension pulls a soap membrane toward lower area; here we simulate that in two ways. Compare direct area minimization with damped physical relaxation on the same constrained membrane. Shared geometry and diagnostics expose how an optimization problem and a dynamical system approach related equilibria.

Fun factWith no load, both solvers share one equilibrium condition, yet they can still settle into different shapes.

Differential geometryWebGLTypeScriptInverse design
Open the app Brochure ↗Overview
LiveConnections
Study
A broad showcase of key ideas in computational photography.

Computational photography

Edit gradients or frequencies, stitch overlapping views despite bad matches, recover HDR radiance, and refocus a light field using images alone. Each experiment exposes the intermediate data that makes the result possible.

Fun factIts HDR scene and its 10 × 10 camera array are not photographs: both were path-traced in Aperture.

Light fieldsComputational imagingJavaScriptAlgorithm visualization
Open the app Brochure ↗Overview
LiveConnections
Study
How well can the CPU do a GPU's job?

Realtime Graphics on CPU

Smoke, cloth, path tracing, voxel splats and image processing, computed on the CPU in a browser. The deliberately pixelated view makes SIMD, threads and accumulation easy to compare: change the quality and inspect where the time goes.

Fun factThreads don't always help: the cloth solver stays deliberately serial where parallel overhead outweighed the useful work.

Monte Carlo methodsLight transport & renderingWebAssemblyC++
Open the app Brochure ↗Overview

AlgorithmsThree demos built for one idea each.

LiveConnections
Study
For a BST, how essential is balancing and how does each flavor differ?

Seven search trees

One ordered set, seven maintenance strategies. Compare evolving structure, mean lookup depth and structural edits under identical input—then connect those local choices to the beachline trees in Fortune.

Fun factSome trees enforce balance for every input order; others, such as treaps, use random priorities to stay shallow on average—even with sequential inputs.

Data structuresJavaScriptAlgorithm visualization
Open the app Brochure ↗Overview
LiveConnections
Study
The queues, updates and assumptions behind familiar graph algorithms.

Graph algorithms

Inspect the queue, update and assumption behind a graph algorithm: compare lazy and eager Prim, follow SPFA’s frontier, and read Floyd–Warshall’s path witnesses. The result is only the beginning; the working state explains why it is valid—or where an assumption fails.

Fun factAllow negative edges and it looks for a concrete case where Dijkstra and Bellman–Ford disagree.

Graph algorithmsGraph theoryJavaScriptAlgorithm visualization
Open the app Brochure ↗Overview
LiveConnections
Study
Follow the bits, stored ranges and updates inside a Fenwick tree.

Fenwick trees

Follow prefix sums, range updates and range-sum queries, then extend them into two dimensions. Stored intervals and step-by-step traces show why each bit operation visits the right entries.

Fun factThe lowest set bit of an index is both the size of the block it stores and the step to the next index: i += i & -i to update, i -= i & -i to query.

Data structuresReactJavaScriptAlgorithm visualization
Open the app Brochure ↗Overview

MathematicsRoundness, complex functions, harmonics, Catalan bijections, Laplace transforms.

LiveConnections
Study
What counts as a good circle?

Circle · Roundness Lab

What should closeness to a circle mean? Draw a loop, inspect radial error, curvature and harmonics, then compare scoring rules against counterexamples. Scale-normalized measurements expose defects that a single convenient score can hide.

Fun factDraw-a-perfect-circle games can reward a loop just for being small; here, shrinking a drawing leaves its score unchanged.

Fourier analysisComputational geometryJavaScriptAlgorithm visualization
Open the app Brochure ↗Overview
LiveConnections
Study

Drawing with harmonics

Draw a gesture, keep its timing, and inspect its moving spectrum. Compare local STFT, global Fourier coefficient selection, cosine symmetry, pinned-end sine modes and local wavelet detail—with a working reconstruction for each.

Fun factTrace the same trefoil fast, then slowly: the outline stays identical, its local spectrum does not.

Fourier analysisSignal processingJavaScriptAlgorithm visualization
Open the app Brochure ↗Overview
LiveConnections
Study
Seemingly unrelated formations following the same rule.

Catalan structures

Different combinatorial objects share one recursive structure. Explore the bijections between trees, balanced parentheses, lattice paths and triangulations, then watch the reflection principle account for invalid paths. A focused combinatorics study with the correspondence made explicit.

Fun factReflect a bad lattice path at its first crossing and every one lands on the same off-diagonal endpoint; that is the subtraction in the Catalan count.

CombinatoricsReactJavaScript
Open the app Brochure ↗Overview
LiveEarlier desktop · accelerated previewConnections
Study
Fourier is one slice. Explore the complex-frequency landscape.

Laplace transform studies

Explore how the Laplace transform extends Fourier analysis with exponential weighting. Drag a slice through complex frequency, inspect convergence and reconstruct a signal from a contour. See how convolution in time becomes multiplication after transformation.

Fun factAt σ = 0 the demo's growing exponential has no convergent Fourier integral; raise σ above 0.30 and the weighted signal becomes integrable.

Fourier analysisComplex analysisRubySignal processing
Open the app Brochure ↗Overview
Why these five

Five pages, one idea each: how round a shape is, what a complex function does to the plane, how harmonics draw a figure, how Catalan objects map onto each other, and what a Laplace transform hides. Laplace is the roughest of them.

Roundness Complex functions Harmonics Catalan Laplace
08

Educational

Years as a teaching assistant shaped how I explain ideas. These two projects explore that approach: Integral Atlas tries to make difficult techniques intuitive, while Clique Proofs asks what it means to understand an idea from several different viewpoints.

WIPLiveIn progressConnections
Atlas
Hard integrals often reveal beautiful ideas.

Integral Atlas · A guide to tricky integrals

A work-in-progress study notebook, begun with an Integral Bee puzzle. Worked examples explore symmetry, substitution and parameter tricks; contour visualizations help explain selected complex-analysis examples. The focus is on making a few reusable ideas clear.

Fun factOne example pairs x with 1/x: the integral of log(x)/(1+x²) from zero to infinity equals its own negative, so it is zero.

Numerical integrationComplex analysisReactTypeScript
Open the app Brochure ↗Overview
WIPLiveIn progressConnections
Atlas
Related theorems, and every direct route between them.

Clique Proofs

A proof atlas: related theorems and every direct route between them, not one chain. Why do Prim and Kruskal both work? Why can compactness have such different definitions? Follow an argument between two viewpoints and see the assumptions it needs.

Fun factSequential compactness and compactness agree in metric spaces, but that can't simply be assumed for every topological space, so each relation in the atlas states its hypotheses.

Fourier analysisCombinatoricsJavaScriptGraph theory
Open the app Brochure ↗Overview
Work in progress

Both started as things I wanted to teach: one tricky integral, and the habit of asking why two definitions pick out the same property. I am cutting them down to the problems and proofs that teach one idea each.

Integral Atlas Clique Proofs
09

This portfolio

The last project is this portfolio itself. I put a lot of effort into its cards, brochures, connection map and interactions, and I'm proud of the result. Performance matters here too: live experiments start on demand and pause when they leave the viewport.

The portfolio itself is the last project—and it has gone through countless iterations.Meta project

This portfolio

Interface · Editorial system · Interactive documentation

A portfolio designed to make technical work easy to explore: animated cards and composed previews lead to brochures with explanations, interactive schematics and live experiments. A connection graph links related ideas across projects, while an in-page editor and review workflow help refine the collection.

I am not a professional web designer or artist, but I care about art as much as graphics and mathematics. I want the presentation to show the same care as the work behind it.

Design systemInteractive documentationInformation architectureStatic publishing
Brochure ↗How this website works. You are already inside it.
10

Techniques & topics

Choose a technique to see the projects, and the connections, behind it.

Domains

Technical fields and problem families.

Algorithms & methods

Named algorithms, estimators, solvers, and mathematical constructions.

Browse by field; select a heading to explore that domain. Methods can span fields; each appears here once. Counts show each technique’s own projects, ordered within each field.

Across fields

Platforms & frameworks

Execution platforms, graphics APIs, and application frameworks.

Languages

Programming and shader languages used substantially by the project.

11

Connected ideas

Follow a project into its mathematical and engineering connections.

Behind the work

Mathematics becomes
a working system.

I am a software engineer working in computer graphics and GPU simulation, with seven years in physically based rendering, shader development and GPU pipelines.

The habit is the same across this site: build the forward model, keep its intermediate state on screen, and measure before claiming. Several of the mathematics pieces began as teaching aids; the standard for those is one step past the usual demo.

Research marks my own research: original investigations, published or in progress. System marks a complete application with a scope statement and a validation record. Atlas marks a collection of related studies inside one framework. Study marks a focused piece that isolates one idea. Exploration marks open-ended work where the direction mattered more than the destination.

Project screenshots

Project overview