Projects

A custom programming language designed for verified algorithm development with built-in correctness checking and LaTeX documentation generation

• Designed and implemented a domain-specific language with custom lexer and parser achieving Turing completeness
• Built interpreter using visitor pattern for clean AST traversal and extensible node handling
• Implemented control flow structures (if/else, while, for loops) and array operations with proper scoping
• Solved complex grammar parsing issues through systematic debugging and architecture refactoring

React PWA for organizing game nights with drag-and-drop player management and an Imposter game mode

• Developed Progressive Web App using React with custom theme system and mobile-first responsive design
• Implemented drag-and-drop player management using @dnd-kit library with touch-friendly interactions
• Built game state management with React Context for consistent data flow across components
• Created smooth page transitions and animations using Framer Motion for enhanced UX

Chrome extension that visualizes conversation branches in Claude.ai, helping users track different conversation paths

• Developed Chrome extension using Manifest V3 with content scripts for deep webpage integration
• Implemented content hashing algorithm for generating unique message IDs and branch detection
• Built sidebar UI with tree visualization showing conversation structure and branch points
• Used Chrome Local Storage API for persistent conversation data across sessions

Android game featuring single-player mode with Minimax AI opponent and two-player pass-and-play

• Developed Android game using Kotlin with multiple activities and Intent-based navigation
• Implemented Minimax algorithm for unbeatable AI opponent with strategic move evaluation
• Created custom animations using Kotlin coroutines for smooth difficulty toggle transitions
• Built dual game modes (single-player AI, two-player pass-and-play) with conditional UI rendering

Python-based portfolio generator with Jinja2 templating, real-time file monitoring, and automated GitHub Pages deployment. The tool you're using right now to build this portfolio.

• Built Python generator with Jinja2 templating engine supporting template inheritance and dynamic content injection from JSON
• Implemented two-repository architecture separating build tool from deployment site with automated CI/CD pipeline
• Designed recursive directory traversal system for copying static assets with real-time file system monitoring using watchdog library
• Created watch mode with automated regeneration enabling rapid development iteration and immediate preview

Full-featured UNO card game with Flask REST API and multiple AI difficulty levels using game theory algorithms. Implements utility-based decision making and strategic play patterns.

• Designed object-oriented architecture with Card, Deck, and GameState classes following inheritance patterns for extensibility
• Implemented three AI difficulty tiers using game theory concepts: random selection, heuristic strategy, and utility-based decision making
• Developed utility function evaluating card plays based on threat assessment, card value management, and optimal color selection
• Built Flask REST API with JSON serialization enabling seamless transition from CLI to web platform

Memory infrastructure for multi-agent AI systems — giving agents durable, shared, identity-based memory that survives context windows, process restarts, and agent handoffs. Published on npm.

• Designed identity-first memory model with entity+key deterministic lookup, explicit confidence scores, and source attribution across agent sessions
• Built conflict-aware write engine with automatic detection, LLM arbitration, and human-in-the-loop escalation for unresolvable disagreements
• Published iranti CLI, @iranti/sdk TypeScript package, and iranti-control-plane operator dashboard to npm with cross-platform binary support
• Validated session persistence (8/8 cross-boundary) and exact retrieval (10/10 zero-context) through structured benchmark experiments
• Integrated with MCP, Claude Code hooks, Codex, CrewAI, and Python middleware — framework-agnostic memory for any agent stack

Chrome extension that types your content into any web field with convincingly human behavior — complete with variable speed, natural pauses, realistic typos, and self-corrections.

• Implemented variable-speed typing engine with inter-key jitter, natural pause modeling, and configurable profiles (Student, Professional, Rusher, SpeedBlitz)
• Built typo and self-correction simulation that mirrors real human error patterns and recovery timing
• Developed markdown and rich-text parser enabling structured content to be typed with correct formatting across editors
• Engineered Google Docs compatibility using Chrome Debugger Protocol for runtime keystroke injection beyond standard DOM events
• Wrote comprehensive test suite using jsdom covering timing accuracy, parser correctness, and rich-text rendering

A pipeline for importing USD 3D scene files into a live metaverse fabric — parsing geometry, computing world-space transforms, and publishing signed payloads with cryptographic author attribution.

• Implemented USD scene traversal using pxr (usd-core) to walk prim hierarchies and extract geometry, attributes, and world-space transforms
• Designed multi-language pipeline (Python parser → Node.js publisher) with clean handoff via structured JSON payloads
• Integrated ManifolderClient and MSF_Map_Svc APIs to write signed objects to live Patched Reality / Metaversal Corp fabric
• Built Ed25519 DID stub identity system for cryptographic author attribution, with roadmap toward on-chain ownership verification
• Delivered working end-to-end demo from sample USD scene to live metaverse environment within hackathon timeframe