Tyler Forstrom

Open to software engineering roles

Software Engineer

Tyler Forstrom

I build software that's easy to try, easy to explain, and honest about its limits.

I'm a computer science student at Cornell, and most of my projects start with a question I can't let go of. Does Reddit hype actually predict stock moves? What would code look like if it read like plain English? I'd rather build the real thing and find out than settle for something that only looks good in a screenshot.

See what I've built ↓ GitHub LinkedIn Résumé (PDF)
Tyler Forstrom

Projects

Everything here is live. Every project has a demo you can actually click around in. Search below, or filter by topic.

Simulation & machine learning

Adaptive Ecosystem Lab: five species that learn to survive together

I wanted to see whether five species could learn to live together with no rules handed to them, just reward and a lot of trial and error. So I built a vectorized 2D ecosystem and a multi-agent reinforcement learning trainer from scratch in NumPy and PyTorch. Herbivores, predators, decomposers, pollinators, and engineers each train their own policy network at the same time, in a world that pushes right back. The messy part is what makes it a real ML project: the run kept quietly falling apart. A predator policy would mode-collapse, the food web would crater into NaNs, and about 70% of the compute went to waste. I tracked down all three failure modes and fixed them with a PPO ratio-overflow guard, a global carrying cap, and an adaptive entropy controller, which took the run from always collapsing to actually stable. The live demo replays the real trained ecosystem and charts the training score as it collapses and recovers.

  • Python
  • PyTorch
  • Multi-agent RL
  • PPO from scratch
  • Training stability
  • NumPy vectorization
Live demo → Code →

Market Simulator: a stock market grown from thousands of trading bots

Instead of backtesting against historical prices, I built the market itself: thousands of trader agents placing orders into an order book, with prices coming out of how they interact. Then I added a validation layer to ask the question nobody likes to ask. Do these strategies actually have an edge once you account for costs? Most didn't, and I kept that result instead of burying it. Volatility forecasting was the signal that held up, and the simulator now feeds calibration data to my Portfolio Insight Copilot. I also audit the simulator against known empirical laws of real markets, and I'm upfront about where it still falls short.

  • Python
  • Simulation
  • Applied statistics
  • Data engine
Live demo → Code →

BanditFeed: watch a recommendation algorithm think

Recommendation algorithms decide what most of us read, but they're invisible. BanditFeed makes one watchable: it ranks real RSS articles using contextual bandits, shows you exactly why each article was recommended, and visibly updates its beliefs every time you click or skip something. After a few minutes of playing with it, the explore-vs-exploit tradeoff behind every feed you scroll stops being abstract.

  • FastAPI
  • Recommendation systems
  • Contextual bandits
  • Real article data
Live demo → Code →

Finance & markets

TickerPulse: a trend radar for stock-market chatter

This started with a question: when a stock blows up on Reddit, is the internet predicting the move or chasing it? TickerPulse pulls in public chatter from Reddit, StockTwits, Bluesky, and Hacker News, figures out which tickers people are actually talking about (harder than it sounds; "$A" is a real ticker), scores the mood of every post, and groups the conversation into themes. The dashboard ranks what's trending, flags unusual spikes, and lines social buzz up against real price data so you can see who's leading whom. A GitHub Actions cron keeps the whole thing running for free.

  • Python NLP pipeline
  • FinBERT sentiment
  • React + Recharts
  • Netlify Functions
  • Time-series analytics
Live demo → Code →

Portfolio Insight Copilot: an AI finance tool that knows its limits

An experiment in making an AI finance tool that's actually honest. You can build a portfolio, search a broad universe of U.S. tickers, compare against SPY, QQQ, and SCHD, and run an AI risk review that shows you exactly how it scored things instead of hand-waving. And when the app doesn't have great data on a smaller ticker, it says so. Estimates are clearly labeled as simulation-backed instead of being passed off as live quotes.

  • JavaScript
  • Fintech AI
  • Simulation-backed data
  • AI guardrails
Live demo → Code →

Data & maps

NYC Real Estate Map: what 338k homes actually sold for

Most real-estate sites show asking prices. I wanted what homes actually sold for, so I built this on 338,000 recorded sales from NYC Open Data: real deeds, real dates, no scraped listings. There's an interactive map with price heatmaps and neighborhood comparisons, plus a Market Insights tab that answers the questions buyers actually have: which neighborhoods are heating up, which are cooling off, and when in the year prices dip. Behind it, a daily pipeline cleans the data and quietly throws out the $10 "sales" between family members.

  • FastAPI
  • PostgreSQL / PostGIS
  • React + TypeScript
  • MapLibre GL
  • Data engineering
Live demo → Code →

Languages & tools

Plain: a programming language that reads like English

I kept watching people bounce off their first programming language because the syntax got in the way before the ideas could. So I built Plain, a complete language written from scratch in Python: tokenizer, parser, optimizing bytecode compiler, and a stack-based virtual machine. You write real programs in words you already know, errors point at the exact line and explain themselves, and a visual step-debugger in the browser walks your code one statement at a time, so you can watch variables change and the call stack grow. The optimizer folds constants and fuses hot instructions, which makes programs run up to about 4.8x faster than the original tree-walking interpreter. Every push runs a differential suite plus hundreds of fuzzed random programs in CI to prove both engines behave identically, error messages included. The demo site runs the real compiler in your browser, with practice problems pinned beside the editor, a bytecode viewer, and 16 solved LeetCode problems.

  • Python
  • Language design
  • Compilers
  • Bytecode VM
  • Step debugger
  • WebAssembly (Pyodide)
Live demo → Code →

GlassDB: a SQL database you can see through

Every project I build sits on a database, and I didn't love treating that layer as a black box. So I built one from scratch in Rust, with a pager and buffer pool, a write-ahead log, a B+tree, a SQL parser, and a query planner, all with zero dependencies and no unsafe code. Then I put a glass wall on it: the demo runs the real engine in your browser through WebAssembly, so you can watch it think. Run WHERE id = 250 and two pages light up; filter on a column with no index and watch it walk every leaf. My favorite part is the testing. A simulated disk cuts the power at every single write, hundreds of crash-and-recover cycles in CI, and the suite proves committed transactions always survive while half-finished ones never show up.

  • Rust
  • Systems programming
  • B+tree & write-ahead log
  • Query planner
  • Crash-injection testing
  • WebAssembly
Live demo → Code →

Magpie: watch threads steal work from each other

Threads are normally invisible, so I built a work-stealing thread pool in C that you can actually watch. Eight real OS threads each own a queue of work, and when one runs dry it steals a task off the back of a busy thread's pile instead of sitting idle. To give it lopsided work to chew on, the demo renders a Mandelbrot fractal one tile at a time: the dark interior is slow and the empty space is fast, which is exactly when stealing earns its keep. The browser demo replays a real recorded run, so you watch the image paint in tile by tile, tinted by whichever thread drew it, while a per-thread timeline shows the moment one thread steals from another and a speedup chart shows the gains flattening out as the work runs past the cores. The part I cared about most is that it holds up: the tests prove every task runs exactly once even under heavy stealing, and CI runs the whole suite on Linux and macOS under AddressSanitizer and UndefinedBehaviorSanitizer.

  • C
  • Systems programming
  • Concurrency
  • Work-stealing
  • pthreads
  • Zero dependencies
Live demo → Code →

Mathematical Solver: ask any math question in plain English

I wanted one place that could take a math or stats question, typed the way you'd actually ask it, and not just hand back an answer but show the work. So I built a solver from scratch in plain JavaScript. A natural-language parser turns questions like "what is the probability of 3 heads in 10 coin flips" or "does the sum of 1/n^2 converge" into the right type of problem, then routes them to the matching engine. It covers algebra, calculus, linear algebra, graphing, numerical methods, probability, statistics, and time series, and every result comes with step-by-step reasoning, a table of artifacts, and a graph or expression tree when that helps you see why. No libraries do the math. It's all hand-written, from Newton's method and Holt exponential smoothing to chi-square goodness-of-fit, and 200+ regression tests pin every solver so the answers stay correct as the engine grows.

  • JavaScript
  • Symbolic math
  • Numerical methods
  • Applied statistics
  • Natural-language parsing
  • Zero dependencies
Live demo → Code →

Games & graphics

Photon Forge: a 3D puzzle game about bending light

Drag mirrors, prisms, and filters onto a 3D board, then route beams of light through the scene to hit your targets. It started as a way to turn computer-graphics concepts like reflections, ray intersections, and color filtering into something you can play with instead of just read about. The math underneath is real, but the goal was always for the puzzles to feel intuitive. There's a sandbox mode if you want to build your own levels.

  • JavaScript
  • Three.js
  • Computer graphics
  • 3D game UI
Live demo → Code →

Ripple: a wave-interference puzzle

A little browser puzzle about wave physics. Place emitters so the ripples reinforce the targets you want and cancel out the ones you don't. It's built with vanilla JavaScript and Canvas, and every level is generated backwards from a known solution, so the puzzles are always solvable. Tricky, but never unfair.

  • JavaScript
  • Canvas
  • Wave physics
  • Procedural generation
Play → Code →

About

I'm a computer science student at Cornell (graduating December 2026, with a business minor), and I learn best by building. When a system catches my interest, I make a working version of it: a market simulator to understand trading behavior, a recommendation demo to understand ranking algorithms, a graphics puzzle to understand rays and reflections.

I care about building things that can be explained and tested. If I can't tell you plainly how something works, I don't trust it yet. I've interned as an app developer at Kahua, shipped full-stack features, and helped start an investing club at Cornell. Outside of code you'll find me at the gym, training martial arts, gaming, or out on a golf course. Right now I'm looking for software engineering roles where I can keep building practical systems and learn from strong engineers.

Tools I work with

Get in touch

I'm looking for software engineering roles and internships, but I'm also happy to talk projects, trade feedback, or answer questions about anything on this page. Email is the fastest way to reach me:

Email me GitHub LinkedIn