I am a computer science student at Southern New Hampshire University (SNHU). I focus on engineering problems where software correctness, determinism, and inspectability matter:

• AI Agent Infrastructure & Reliable Execution: Building governed agent harnesses, execution sandboxes, and evidence-bound completion verifiers.
• Backend Systems & Data Integrity: Designing integer-exact financial ledgers, deterministic cash-flow forecasting pipelines, and schema-governed persistence.
• Low-Level Systems & Emulation: Modeling cycle-stepped ARM microarchitectures, memory bus waitstates, and scanline-accurate graphics rasterizers in C++17.
• Interactive Software & Game Engines: Decoupling headless game simulation from browser rendering, collision geometries, and offline-first Progressive Web Apps.

Python is my primary programming language, complemented by modern TypeScript/JavaScript, C++17, and Kotlin.

The six systems below demonstrate the core of my technical work across AI infrastructure, financial modeling, full-stack routing, computer architecture, offline-first education, and game simulation.

Stack: TypeScript, Node.js, Electron, SQLite FTS, Tree-Sitter | Role: Flagship 1 (AI Infrastructure)
Explore: Web Portal • Source Code • Technical Case Study • Releases

• What It Looks Like Running: A multi-interface desktop client (Electron, TUI, and CLI) where users direct autonomous agents with continuous streaming output, live symbol indexing, and structured task milestones.
• What Users Accomplish: Automate software engineering workflows without trusting unverified model text. Babel spawns isolated subprocesses, monitors file modifications, runs project test suites, and issues machine-verifiable completion receipts before declaring tasks complete.
• Core Engineering Challenge: Decoupling LLM generation from execution verification. Babel implements an evidence-bound execution harness: if compiler diagnostics or test assertions fail, the harness marks the task blocked regardless of agent confidence.
• Architecture: Layered operational prompt hierarchy (System Router, Behavioral OS, Domain Architects, Model Adapters), an SQLite full-text index for fast heuristic symbol lookup, and process supervision with watchdog timeouts.

Stack: Python 3.10+, SQLite, FastAPI, Hypothesis, Pydantic | Role: Flagship 2 (Backend & Mathematical Engineering)
Explore: Try Live App • Source Code • Technical Case Study • Android Companion

• What It Looks Like Running: An interactive web companion featuring a 90-day cash-flow timeline, live Safe-to-Spend P10 quantile gauges, projected liquidity trough indicators, and an interactive What-If Decision Studio with real-time fragility sliders.
• What Users Accomplish: Evaluate cash-flow fragility and answer critical financial questions before spending: "How much can I safely spend today without bouncing an upcoming obligation?"
• Core Engineering Challenge: Financial risk is path-dependent. Standard monthly budgeting tools ignore exact calendar sequencing: rent on the 1st vs. payroll on the 15th causes an overdraft even if the month ends positive. MonteCarlo-Ledger implements a two-stage forecasting engine: Stage 1 projects known commitments onto an exact calendar timeline; Stage 2 executes thousands of seeded Monte Carlo stochastic trials to stress-test that timeline against surprise expenses.
• Architecture: Enforces a signed-transaction integer-cents ledger (amount INTEGER NOT NULL, type IN ('Income', 'Expense', 'Adjustment')) where balances are strictly derived from transaction log deltas. Uses 64-bit integer cents throughout to eliminate floating-point drift, validated through property-based invariant testing.

Stack: TypeScript, Vite, React, Deno Edge Functions, Supabase Postgres | Role: Flagship 3 (Full-Stack Engineering)
Explore: Try Live App • Source Code • Technical Case Study • On-Device Companion

• What It Looks Like Running: A modern multi-model chat workspace showing live explainable auto-routing, real-time spend analytics ($0.1758 all-time settled, live turn tracking), per-turn spend caps, and model-tier complexity scoring.
• What Users Accomplish: Access premier frontier models (Claude, GPT, Gemini, DeepSeek) through a single unified interface with transparent cost attribution, automatic task-based model selection, and multi-model debate synthesis.
• Core Engineering Challenge: Eliminating vendor opacity and runaway cloud spend. Prismatix implements explainable model routing paired with fail-closed budget controls on Deno Edge Functions. Unpriced models fail closed with an explicit HTTP 409 Conflict, and admission database outages return HTTP 503 before invoking external providers.
• Architecture: Built on Deno Edge Functions and Supabase Postgres. Features client-side BYOK key encryption (AES-256-GCM), streaming token counters, and post-stream settlement receipts. Production web deployment runs commit 7d143a1.

Stack: C++17, CMake, SDL3, Google Oboe | Role: Flagship 4 (Systems Programming & Architecture)
Explore: Source Code • Technical Case Study • Open Issues & Conformance Status • Android Shell

• What It Looks Like Running: A high-performance C++17 desktop emulator (gba-desktop.exe) executing interactive synthetic video and timing conformance suites at 3x integer scale (720x480) with real-time 60 fps scanline rasterization.
• What Users Accomplish: Study cycle-stepped computer architecture, inspect ARMv4T pipeline hazards, and run verified homebrew and conformance test suites on a modular, portable emulation core.
• Core Engineering Challenge: Accurate hardware timing and bus waitstates without ad-hoc game hacks. The memory bus controller accurately models electrical waitstates: 0 waitstates for 32-bit IWRAM, 2 waitstates for 16-bit EWRAM, and configurable waitstates for Game Pak ROM.
• Status & Policy: Verified across 32 local core verifiers and public mGBA test suites (11/13 green). Testing is performed strictly against open-source synthetic suites; commercial ROM compatibility remains untested per legal policy.

Stack: TypeScript, React Native, Expo, Pyodide (WebAssembly), SQLite | Role: Flagship 5 (Product & Education Engineering)
Explore: Source Code • Technical Case Study • Architecture Notes

• What It Looks Like Running: An interactive mobile and web learning application where students write and execute real Python code directly inside the browser with immediate automated test assertion feedback.
• What Users Accomplish: Master programming fundamentals completely offline, execute code without paid server sandboxes, and export verifiable JSON evidence packets demonstrating genuine problem-solving mastery.
• Core Engineering Challenge: Running untrusted Python code safely in the browser without server dependencies while generating tamper-evident learning records. ProofPath isolates Pyodide WebAssembly inside dedicated WebWorkers with execution watchdogs, computing a 32-bit DJB2 content hash over passing code.
• Architecture: Bundles Pyodide WebAssembly with a local SQLite database for offline progress retention, supporting structured JSON portfolio export under a 4-tier evidence trust model.

Stack: TypeScript, React, HTML5 Canvas, Vite, Tailwind CSS | Role: Flagship 6 (Game Engine & Interactive Systems)
Explore: Play Live Game • Source Code • Technical Case Study • Engine Architecture

• What It Looks Like Running: A playable web-based creature-binding RPG featuring turn-based tactical combat, Elderhall exploration on 2D tilemaps, creature party management, and responsive gamepad/touch controls.
• What Users Accomplish: Play an authentic retro-style creature RPG in any browser, explore procedural wild encounter zones, and battle with deterministic state transitions that persist across offline sessions via PWA storage.
• Core Engineering Challenge: Eliminating simulation-rendering desync. Many web games tie game math to requestAnimationFrame, causing calculations to desync or drop inputs when backgrounded. Reliquary decouples game simulation into a pure headless battle engine: state transitions evaluate immediately upon action confirmation, and Canvas visual effects merely render the resolved state.
• Architecture: Pure functional battle logic, safe-spawn Poisson tile placement, Progressive Web App service worker caching, and schema-versioned localStorage save migrations.

The following concrete examples illustrate the engineering challenges addressed across these systems:

To eliminate agent completion hallucination, Babel decouples text generation from process verification. When an agent proposes code modifications, Babel spawns isolated subprocesses, captures compiler diagnostics and test exit codes, and writes a structured execution receipt. If a verifier check fails, the harness marks the task blocked regardless of model confidence.

Financial risk is chronological. A net-positive monthly balance provides zero protection if an account experiences a liquidity deficit mid-month. MonteCarlo-Ledger models the exact calendar sequence of bills and paychecks before overlaying stochastic variance. Safe-to-spend recommendations are derived from the 10th percentile minimum balance (the trough distribution) rather than optimistic averages.

Multi-model frontends often fail open when upstream providers update model identifiers or modify pricing tables, exposing users to runaway cloud spend. Prismatix implements pre-inference admission reservations on Deno Edge Functions: unpriced models fail closed with an explicit HTTP 409 Conflict, while admission database outages return HTTP 503, preventing untracked spend before invoking external providers.

The Game Boy Advance memory bus assigns distinct cycle waitstates to distinct memory regions: 0 waitstates for 32-bit fast IWRAM, 2 waitstates for 16-bit EWRAM, and variable waitstates for cartridge ROM access. GBA_Emulator accurately models these electrical timing constraints inside its C++17 memory controller, ensuring that DMA burst transfers and CPU instruction pipelines synchronize with public hardware test suites.

Running user-submitted Python code inside a mobile/web client without server sandboxes requires WebAssembly thread isolation. ProofPath runs Pyodide inside dedicated WebWorkers guarded by execution watchdogs. When a lesson passes, the system calculates a 32-bit DJB2 content hash (cf- prefix) over the submitted source, tracks test suite assertions, and packages the results into a structured JSON evidence packet.

If turn-based combat calculations depend on animation timers, backgrounding the browser tab or experiencing frame drops will desynchronize game state. Reliquary models combat as pure, immutable functional state transitions that evaluate immediately upon turn confirmation. The Canvas 2D engine subsequently queues visual effects without delaying game state progression.

I treat software engineering as an intentional discipline centered on requirements clarity, structural boundaries, and reproducible verification.

My personal workflow is documented in detail in How I Build:

• Human Engineering Direction: I define system architecture, data models, invariant boundaries, acceptance standards, and error-recovery contracts; investigate root causes when verifiers fail; and evaluate competing technical approaches.
• AI Coding Agent Implementation: Autonomous coding agents contribute substantial implementation across core algorithms, test suites, CLI parsers, and component structures, executing under close human architectural direction, requirements specification, root-cause investigation, and invariant governance.
• Evidence-First Verification: No task is declared complete based on AI generated assertions. Success requires passing clean compiler gates, running property-based test suites, and producing reproducible execution logs.

Beyond the six flagships, my public repositories include specialized developer tools, mobile companions, and game prototypes:

For complete repository licensing, classification, and qualification details, see the Portfolio Inventory and Project Index.

• LinkedIn: https://linkedin.com/in/gthgomez
• GitHub: https://github.com/gthgomez

This profile repository is public for portfolio presentation; see its LICENSE. Referenced projects retain their respective open-source or proprietary licenses.