Social Network Platform

Originally developed as an academic PHP project with server-side rendered pages, this application was later modernized into a full-stack web application with a React frontend and PHP REST API backend. The system uses JWT-based authentication for secure user login and session management, with data stored in a MySQL database.

Key features include:

• User registration and authentication
• Role-based access control
• User profiles and profile management
• Status/post creation with optional image uploads
• Commenting system
• Private messaging between users
• Administrative panel for content and user management
• RESTful API architecture separating frontend and backend responsibilities

The application runs in Docker containers and uses an automated CI/CD pipeline to deploy updates to a VPS server on every push to the main branch.

The project demonstrates migration from a traditional monolithic PHP application to a modern SPA (Single Page Application) architecture using React and API-driven communication.

Real-Time Multiplayer Chess Platform

A full-stack web application for playing live chess games between two players over WebSockets. Built with a React and TypeScript frontend and a Node.js backend, the system uses Socket.io for real-time, bidirectional communication, with the server acting as the authoritative source of game state to validate every move and prevent cheating.

Key features include:

• Real-time two-player games over WebSockets
• Shareable game rooms via unique URL codes
• Server-side move validation and turn enforcement
• Full chess rules engine (legal moves, check, checkmate, stalemate, and draw detection)
• Interactive drag-and-drop board with pawn promotion selection
• Automatic game-end detection with result reporting
• Per-player board orientation and live game status
• In-memory game state management with room-based isolation

The application runs in Docker containers behind a shared Nginx reverse proxy that terminates SSL and routes both static assets and WebSocket traffic. An automated CI/CD pipeline deploys updates to a VPS server on every push to the master branch.

The project demonstrates real-time client-server communication with an authoritative server architecture, using a multi-stage Docker build to serve a compiled production frontend and backend.

Demo Slot Machine Game

A full-stack browser-based slot machine game with a hardware-accelerated graphics frontend and a server-authoritative game engine. Built with a TypeScript and PixiJS frontend rendering the reels and animations on a WebGL canvas, and a Node.js and Express REST API backend that computes every spin result, so outcomes and payouts are determined entirely server-side rather than trusted to the client.

Key features include:

• Animated reel rendering with PixiJS on a WebGL canvas
• Server-side spin logic determining symbols, win lines, and payouts
• REST API communication between client and game engine
• Configurable bet amounts with win/multiplier calculation
• Preloaded symbol textures for smooth spin animation
• Responsive canvas that scales to the viewport
• Clean separation between rendering (client) and game outcome (server)

The application runs in Docker containers behind a shared Nginx reverse proxy that terminates SSL and routes static assets and API traffic to the appropriate service. The frontend is compiled and served as static files through a multi-stage Docker build, with the production bundle delivered by an internal Nginx instance.

The project demonstrates a server-authoritative game architecture where all randomness and payout logic live on the backend, preventing client-side tampering, paired with a real-time graphics layer built directly on a low-level rendering engine.

Endless Runner Game

A side-scrolling endless-runner game in the style of the Chrome offline dinosaur game, where the player jumps over incoming obstacles and survives for as long as possible. This is a remake of an earlier version of the game: the original was rendered with the DOM and written in vanilla JavaScript, and it was rebuilt from the ground up as a hardware-accelerated Canvas game using PixiJS and TypeScript. The remake was produced through AI-assisted rapid prototyping, with the entire client generated and refined in two prompts.

Key features include:

• Hardware-accelerated rendering on a WebGL canvas via PixiJS
• Player physics with gravity and a chained mid-air double jump
• Randomly spawned obstacles that are despawned once they leave the screen
• Multi-layer parallax scrolling, with foreground hills moving faster than background hills and clouds drifting the opposite way
• Infinite scrolling backgrounds built on tiling sprites
• Axis-aligned bounding-box collision detection with game-over and instant restart
• Survival-based scoring
• Unified keyboard, mouse, and touch input
• Centralized, tunable game configuration for gravity, scroll speeds, and spawn timing

The frontend is compiled and served as static files through a multi-stage Docker build, with the production bundle delivered by an internal Nginx instance. The container runs behind a shared Nginx reverse proxy that terminates SSL and routes traffic to the service. The game is currently client-side only, with a server-authoritative layer planned for a future iteration.

The project demonstrates the migration of a browser game from DOM-based rendering and vanilla JavaScript to a low-level WebGL rendering engine, and the use of AI-assisted rapid prototyping to rebuild a complete, deployable application from a couple of natural-language prompts.