LC Studio — Project Hub

Everything
I'm building.

Tools, simulations and experiments. Click any project for architecture and tech detail — then open the live version.

01
Productivity Tool
2025

Excel AI Engine

Auditable AI mutations for structured spreadsheet data

Describe a change in plain English. The engine builds a typed plan, previews every cell that changes and every downstream formula that recalculates, then commits atomically — or rolls back entirely. Nothing happens without your approval.

Next.js 14 OpenAI GPT-4o SheetJS TypeScript Vercel
View project
02
Scientific Computing
2025

Hurricane Simulator

Real-time atmospheric dynamics engine

A physics-based simulation modelling the formation and evolution of tropical cyclones. Adjustable sea-surface temperature, wind shear, and Coriolis parameters drive a real-time atmospheric grid.

Python NumPy / SciPy WebGL FastAPI Canvas API
View project

Excel AI Engine

Type a change in plain English. The engine reads your workbook, builds a typed mutation plan, and shows you a cell-by-cell diff — every value that changes, every formula that recalculates downstream — before a single byte is written. Commit atomically, or discard entirely. Every operation is logged with a full audit trail.

The Problem

AI tools for Excel either generate unauditable code or mutate files silently. When something goes wrong — and it does — there is no record of what changed, why, or what else it broke. The Excel AI Engine treats your workbook as a typed, auditable artifact. Every mutation is a structured plan: validated before it runs, previewed before it commits, and logged permanently. The blast radius of any change — every cell and formula that depends on what you touched — is computed and shown to you upfront.

Architecture

The pipeline runs in four stages:

01 — Workbook Read + Dependency Graph
openpyxl parses the .xlsx into a typed cell model. The engine builds a formula dependency graph — every cell's precedents and dependents — so the blast radius of any change is known before anything runs.
02 — Typed Mutation Plan
The LLM (Claude, temperature 0) reads the workbook context and your prompt, then emits a structured Plan — a validated, pydantic-typed list of atomic operations. No raw code, no imperative mutation; only typed operations the engine understands.
03 — Dry-Run + Cell Diff Preview
The plan runs in-memory against a copy of the workbook. The engine produces a cell-level diff — every value that changes, every formula affected downstream — and surfaces it for review. Nothing is written to disk yet.
04 — Atomic Commit or Rollback + Audit Log
On approval the plan executes with snapshot-and-restore rollback — it either applies fully or reverts entirely, no partial state. Every committed operation is written to a Postgres audit log with the plan, diff, model provenance, and timing.
Tech Stack
Python 3.12 + FastAPI
Engine + API backend
Anthropic Claude
LLM planner (temp 0)
openpyxl + pydantic v2
Workbook parsing + plan schema
Next.js 15 + TypeScript
Web console frontend
PostgreSQL
Audit log + rate limiting
Vercel + Railway
Frontend + backend hosting
Try It — Sample Workbooks

Download one of these workbooks, upload it to the engine, and try the prompts below. These are real operations the engine handles reliably today.

demo_pricings.xlsx
3 sheets — Prices (16 rows, 8 companies × 2 months), Inflation (8 regions), Summary (empty target)
↓ Download
Prompts that work
"Multiply the prices on the Prices tab for March and June with their corresponding March and June inflation rates for each region using the Inflation tab"
"Bold the header row and apply a navy fill to it on the Prices sheet"
"In the Summary sheet, create a table showing total Price by Region for March and June"
demo_budgets.xlsx
3 sheets — Actuals (7 accounts), Budget (same 7 accounts), Variance (empty target)
↓ Download
Prompts that work
"In the Variance sheet, add a table with Account, Actual, Budget, and Variance (Actual minus Budget) for each account code"
"Correct the Marketing budget on the Budget sheet from 75000 to 80000"
"Bold and navy-fill the header row on Actuals and Budget"
Ready to explore it?
Opens the full interface in a new tab
Open Project

Hurricane Simulator

A physics-based simulation modelling the formation and evolution of tropical cyclones. Adjustable sea-surface temperature, wind shear, and Coriolis parameters drive a discretised atmospheric grid that resolves in real time.

The Problem

Atmospheric simulation is largely locked inside opaque academic or government systems — difficult to explore, modify, or understand intuitively. This project makes the physics of hurricane formation visible and interactive: a learning tool as much as an engineering one.

Architecture

A real-time physics loop feeds a WebGL renderer:

01 — Atmospheric Grid
A discretised 2D grid models air pressure, temperature, humidity, and wind velocity at each node. Boundary conditions set sea-surface temperature and large-scale wind shear.
02 — Physics Solver
NumPy solves a simplified system of the primitive atmospheric equations at each timestep — pressure gradients, Coriolis deflection, moisture flux, and latent heat release.
03 — WebGL Renderer
Output is streamed to a Canvas via WebGL shaders, visualising wind vectors, pressure isolines, and intensity bands with sub-frame latency.
04 — FastAPI Backend
Heavy compute runs off the main thread on a Python FastAPI server, keeping the browser UI responsive while physics ticks at high frequency.
Tech Stack
Python 3.12
Physics Simulation
NumPy / SciPy
Numerical Solvers
WebGL
Real-time Rendering
FastAPI
Compute Backend
Canvas API
Visualisation Layer
Still in development
No live URL yet — check back soon.
Coming Soon