Nabla is an aviation AI startup out of Boeing's AerospaceXelerated program. Weave is the EFB app I designed and built in React Native / Expo / TypeScript. It's used by 1,000+ pilots across multiple Japanese airlines; Skymark Airlines announced production rollout in May 2026.

The visualization layer renders turbulence as a volumetric field the pilot can fly through, not a flat overlay stamped on a map. The data arrives on the GPU as a 3D texture; I ray-march it in custom GLSL so density reads as depth along the flight path, on Three.js and React Three Fiber. It runs inside React Native on a cockpit tablet, so the volumetric pass renders at reduced resolution and is reconstructed to full frame. That's what holds framerate on a mobile GPU.

Beyond the app I work across the stack: GraphQL backend on AppSync, Python optimization pipeline, AWS CDK infrastructure, offline-first data architecture, real-time WebSocket sync.

A real-time operations platform for a Japanese hybrid carrier. I owned it end to end: architecture, UX, and stakeholder scoping directly with the airline's operations team. In production with the full operations control team.

• 01A fully custom interactive Gantt chart for flight schedule management. Gesture-driven zoom and pan, MotionValue-driven layout for 60fps scrolling, real-time sweep clock, delay visualization with Gaussian probability curves.
• 02Automated ML delay prediction pipeline running 4× daily via EventBridge, calling an external ML API, deserializing Parquet responses, and detecting cascading delays before they propagate.
• 03Time-travel queries via DynamoDB Streams capturing changes across 11 tables with jsondiffpatch. The team can reconstruct any past schedule state.
• 04Fully serverless stack: Next.js 15, GraphQL on AppSync with 42 resolvers, 14 DynamoDB tables, 8 Lambda functions, 4 CI/CD pipelines.

A real-time architectural visualization bridge. A designer edits geometry in Rhino 8; a separate Electron app shows a photoreal preview that updates live as the model changes.

The sync layer is where the work went. A custom C# plugin on the Rhino side streams scene deltas over a binary protocol: transform updates are 128 bytes instead of full-mesh resends, unchanged scenes generate zero traffic via content-hash-based reconnect, large meshes use hybrid binary frames.

The renderer is a deferred PBR pipeline I wrote in WebGPU. Deferred so lighting cost scales with the pixels on screen rather than the number of lights, which is what you want for real-time. Lighting is physically based: sun and ambient in real-world lux, exposure in EV100, so the image responds like a physical camera. Image-based lighting from HDRI environments; material and HDRI libraries pulled from open sources.

v2 shipped; currently working on cascaded shadow maps and a probe-based GI pass next.

A gradient engine that treats color as physics. It solves nine phenomena in scene-linear light (atmospheric scattering, thin-film iridescence, subsurface, ocean depth), then runs them through one shared tone-map, exposure, and post-FX path. The output is just a gradient. The engineering is everything upstream of it.

Every phenomenon is a small pure-physics function: Rayleigh and Mie scattering for sky, thin-film interference for iridescence. Each emits scene-linear stops, and they all converge on one develop() pass that does tone-map, exposure in EV, post-FX, and trim. Splitting physics from display means a new phenomenon inherits the whole color pipeline for free, and a 423-case parity harness keeps that shared path byte-identical across every edit.

The core is a de-wash engine I call Radiance. Physically-correct color tends to look washed out, and naive saturation goes neon. This rides the OKLCH gamut cusp instead: it pushes chroma to ~0.92 of the gamut wall and absorbs the overshoot by shedding lightness toward the cusp rather than chroma toward gray. Saturated, never clipped to neon. Around it, three more passes: a spectral de-haze strips the achromatic Mie veil at the source, a hue-bridge fills muddy crossovers along the shortest saturable arc, and a perceptual reparametrization evens out where the transition lands.

It re-solves on every frame, rAF-coalesced and synchronous. That beat a Web Worker here: the worker's async bursts visibly chopped while dragging, and no single solve runs longer than a frame. A WebGL LUT samples the already-developed stops, so the GPU never duplicates the tone-map.

A browser-based agent that builds full-stack web apps. The user describes an idea in natural language; a wizard turns it into a project plan, a task graph, and a vision document; an agentic loop then implements the code inside an in-browser sandbox with live preview.

• 01A custom git-like VCS with immutable content-addressed blob storage and patch-hunk commits rather than full snapshots, to keep storage cost flat as projects grow. Three-way merge handled in the same layer.
• 02The sandboxed runtime as the source of truth during agent sessions, rather than the database. Avoids a class of stale-read bugs that show up when an LLM iterates faster than your write-replication.
• 03A tool-loop architecture designed to stop the model hallucinating identifiers mid-session: title-based references, shared mutable context across tools, client-side resolvers for any tool that needs to block on user interaction.
• 04Real-time collaborative substrate throughout, so multiple users and the agent can operate on the same project state without stepping on each other.