DEV Community: Apoorv Gupta

🔐🌈Light Chaser: Decoding Lost Memories on the Longest Day of the Year🌞

Apoorv Gupta — Sun, 21 Jun 2026 18:11:10 +0000

This is a submission for the June Solstice Game Jam

What I Built

Light Chaser is a story-driven endless runner inspired by the June Solstice, Pride Month, and the legacy of Alan Turing.

In Light Chaser, players explore a world slowly being consumed by darkness. As a Light Chaser, your mission is to collect fragments of lost light and restore color, memory, and hope to the world before the longest day comes to an end.

The game combines three major June themes:

🌞 The June Solstice

The entire game is built around the passage of daylight. Players begin their journey at dawn and progress through morning, noon, golden hour, and eventually sunset. As daylight changes, the world evolves visually and mechanically, creating a constant sense of movement and urgency.

🌈 Pride Month

The world initially appears almost completely colorless. By collecting Light Orbs, players gradually restore vibrant colors across the environment. Each restored color unlocks new stories, visual effects, and interactions, representing self-expression, identity, and authenticity.

🔐 Alan Turing

Hidden throughout the world are Turing Fragments, encrypted messages inspired by codebreaking and cryptography. Players solve cipher-based mini-puzzles to reveal pieces of a larger message honoring Alan Turing's contributions to computing and artificial intelligence.

Along the way, players meet travelers who have lost important memories. By restoring light, players help these characters recover forgotten pieces of themselves and their stories.

The goal was to create a game that feels hopeful, colorful, and reflective while remaining fun and accessible.

Video Demo

Code

https://github.com/StephCurry07/Light-Chaser/

Play Online

https://light-chaser-june-solstice.vercel.app/

How I Built It

Light Chaser was built using Phaser 3 and TypeScript.

Core Gameplay

The game uses an endless-runner architecture where the player automatically advances through a procedurally generated world. The player can jump, slide, and collect Light Orbs while avoiding hazards created by spreading darkness.

Dynamic Solstice System

One of the most important systems in the game is the Solstice Cycle.

The environment transitions through multiple daylight phases:

Dawn
Morning
Noon
Golden Hour
Sunset

Each phase adjusts lighting, colors, obstacle density, and difficulty, helping the player feel the passing of time throughout a single run.

Color Restoration System

The world starts in grayscale.

As players collect Light Orbs, saturation gradually increases across the environment. Additional particle effects, environmental details, and visual enhancements unlock as more color returns to the world.

This mechanic became the visual heart of the project.

Turing Fragment Cipher System

To honor Alan Turing, I implemented collectible encrypted messages.

Players discover fragments hidden throughout the world and solve simple cryptography puzzles inspired by historical codebreaking techniques. Successfully solving puzzles reveals pieces of a larger hidden message that can only be assembled at the end of the game.

AI-Powered NPCs

Travelers encountered during gameplay are generated using Google's Gemini API.

Each NPC has:

A unique name
A personal story
A lost memory
Dialogue before and after memory restoration

Rather than using AI as a novelty feature, I wanted it to reinforce the game's themes of identity, memory, and self-discovery.

Generated content is cached before gameplay begins to ensure smooth performance and avoid interruptions during a run.

Prize Category

Best Google AI Usage

Light Chaser uses Gemini to generate unique travelers and memory recovery stories.

Every generated character represents someone who has lost a meaningful part of themselves to the spreading darkness. Players help restore those memories through gameplay, creating personalized stories that connect directly to the game's themes.

Rather than generating content for the sake of using AI, Gemini serves as a narrative system that helps make each playthrough feel unique and personal.

Best Ode to Alan Turing

Alan Turing's work in codebreaking and computing inspired the Turing Fragment system.

Players collect encrypted messages throughout the world and solve cipher-based challenges to uncover a hidden tribute. The puzzles draw inspiration from historical cryptography while remaining accessible to players unfamiliar with encryption.

By combining codebreaking mechanics with themes of memory and discovery, the game aims to celebrate both Turing's technical achievements and his lasting impact on modern computing.

Thank you for playing Light Chaser.

May your path always lead toward the light. ☀️

From a Broken GogoAnime Hack to a Universal Streaming Remote

Apoorv Gupta — Sun, 07 Jun 2026 18:27:38 +0000

Reviving AniRemote(Now LazyRoll)

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

AniRemote is a phone-as-remote system that lets you control video playback on your laptop directly from your phone.

Open a video on your laptop, scan a QR code, and your phone instantly becomes a remote control.

The current version supports:

Crunchyroll
Netflix
YouTube
Generic HTML5 video players

Users can:

Play/Pause videos
Seek forward and backward
Adjust playback speed
Control volume
Toggle subtitles
Skip intros and credits
Navigate episodes
View live playback state from their phone

Under the hood, AniRemote consists of:

A FastAPI backend that manages rooms and WebSocket communication
A React mobile-first remote interface
A browser userscript that interacts directly with streaming websites

What makes this project special to me isn't the technology.

It's the fact that this project has followed me through multiple stages of my growth as a developer.

Demo

Repository

GitHub Repository Link

Live Demo

Screenshots

QR pairing and room connection

Mobile remote interface

3 Simple steps to setup

The Comeback Story

This project started as a very small experiment and without a name.

Version 1: The idea: Python backends

Over a year ago, I wanted a simple way to control video playback without constantly reaching for my laptop.
I was watching anime and wanted basic controls from my phone. Had to wake up if needed to move forward or backward or pause.
I thought this might be a common problem for people who don't have a proper setup(TV or something), i.e., just graduated from college bachelors.
So I thought it might scale as well. Not only anime, but to webseries on various platforms which this generation watches. Although I don't have such major interests apart from anime, and rarely some movies.

Websockets were not working for some reason. Enough debugging but couldn't get through... So had a mini version without websockets which had limited capability. Then this project was put to rest.

Version 2: The PyAutoGUI Era

Due to sudden urge and so much news regarding new seasons for my favourite animes, I again gained interest in watching those, and thought let's do something interesting. Started that project again, and this was a major break from my rest of not coding or doing anything productive on my personal laptop. I genuinely liked it... So many agents were part of this haha.

At the time, my solution looked something like this:

Phone
 ↓
FastAPI
 ↓
PyAutoGUI
 ↓
Keyboard Shortcut
 ↓
Browser

When I pressed pause on my phone, the backend would trigger keyboard shortcuts on my Windows machine using PyAutoGUI. Again, for some reason I wanted to do my projects in WSL itself. It just was an extra layer of difficulty. There was no use of WSL as such as I needed to run a script on my machine only... So I was just sending commands from WSL to a script on my machine and then proceeded. Even GPT denied this idea.

It worked.

Kind of.

The architecture was extremely simple:

FastAPI backend
Phone sends HTTP requests
PyAutoGUI simulates key presses

There was:

No real-time communication
No synchronization
No room management
No browser integration
No support for multiple websites

But this version taught me a lot.

I learned:

FastAPI fundamentals
Cross-device communication
WSL networking
Running services accessible from a phone
Communication between Windows and WSL environments

Had a better looking UI slowly, added some features, that's it.. Enough of what I would use. Although using pyautogui you have some limitations... you have to be active on that tab... Full screen won't work sometimes... But when I actually made it work, it was a Eureka moment. *** It would only work on my machineeee *** though. haha.

GogoAnime played a major role in this experimentation. I wanted to watch Mob Psycho. Writing very bad scripts only just for going to next episode... exploring the gogoanime links... a lot
I got to understand that this won't scale to other apps, but as long as I had implemented that and my work is being done, I was happy.

Three unrelated things collided at exactly the same time:

I wanted to watch Mob Psycho 100.
Crunchyroll didn't have it available for me.
GogoAnime exposed a playground where I could experiment with browser automation. It went down only after my experimentation was done... saving my sense of satisfaction.

So now, coding problem isn't the issue, design problem is.

The Shift That Changed Everything -- Final Version

The biggest change wasn't a feature.

It was how I thought about the project.

Originally, my goal was:

Make it work.

Now my goal became:

Make it extensible.

Netflix, Crunchyroll, YouTube, and many other sites all expose controls differently.

But from the user's perspective, the actions are always the same:

Play/Pause
Seek
Next Episode
Skip Intro
Toggle Subtitles

That realization pushed me toward implementing a site adapter architecture.

Instead of scattering platform-specific logic throughout the codebase, each streaming service now implements a common interface.

Adding support for a new platform became:

Create Adapter
      ↓
Implement Commands
      ↓
Done

instead of rewriting large portions of the application.

Looking back, this was probably the first time I consciously applied a system design principle to one of my personal projects.

Finish-Up-A-Thon: Building AniRemote

For this challenge, I decided to finally finish the project properly.

The result became AniRemote.

The architecture now looks like this:

Phone Browser (React Remote)
            │
            ▼
      WebSocket
            │
            ▼
FastAPI Backend Relay
            │
            ▼
      WebSocket
            │
            ▼
 Browser Userscript
            │
            ▼
Streaming Website

The backend handles:

Room creation
Host/controller pairing
Real-time message routing
Connection management

The frontend provides:

Mobile-first remote controls
Live playback status
Connection monitoring
Responsive touch-friendly controls

The userscript provides:

Site detection
Adapter execution
State synchronization
QR code pairing
Streaming platform integration

One of my biggest milestones was finally embracing WebSockets.

A year ago, I avoided them because I wasn't comfortable with connection lifecycle management, reconnection logic, and state synchronization.

Now WebSockets sit at the center of the entire architecture.

Commands flow instantly from phone to browser, while playback state flows back to the phone in real time.

The project that once relied on HTTP requests and simulated keyboard presses became a real-time synchronized system.

Again, many agents led to this. Copilot was one of those, which understands the codebase the best among other agents, and we have that GitHub integration as well...iykyk.

Before vs After

Before

HTTP requests only
PyAutoGUI keyboard simulation
Single-device experiment
No real-time communication
No browser integration
No room system
No QR pairing
GogoAnime-focused prototype

After

FastAPI WebSocket backend
Real-time bidirectional communication
Mobile-first React remote
QR-based pairing
Room management
Site adapter architecture
Netflix support
Crunchyroll support
YouTube support(in debugging mode)
Live playback synchronization
Extensible platform support

My Experience with GitHub Copilot

GitHub Copilot played an important role while reviving AniRemote.

Rather than generating entire features, it helped remove friction throughout the project.

Some of the ways I used Copilot included:

Refactoring message handling logic
Building adapter scaffolding for new platforms
Debugging asynchronous communication issues
Improving React component structure
Creating repetitive TypeScript and JavaScript patterns
Improving error handling and reconnection flows

One area where Copilot was especially helpful was iteration speed.

Because AniRemote involves multiple moving parts (frontend, backend, userscript, and streaming-site integrations), I spent a lot of time experimenting with architecture and communication flows.

Copilot helped me spend less time writing repetitive code and more time focusing on the actual design decisions.

What I'm Most Proud Of

The most satisfying part of this project isn't that it supports multiple streaming services.

It's that I finally finished it.

This project started as a simple idea to make anime watching more comfortable.

Over time it became a learning vehicle for:

FastAPI
WSL networking
Browser automation
WebSockets
Real-time communication
System design
Adapter architectures

AniRemote(LazyRoll) is the result of revisiting an old idea with new skills.

And that's exactly why the Finish-Up-A-Thon felt like the perfect excuse to finally bring it across the finish line.

Laptop/PC Device Anomaly Analyzer: Self-Healing System Powered by Agentic Postgres

Apoorv Gupta — Mon, 10 Nov 2025 07:31:10 +0000

This is a submission for the Agentic Postgres Challenge with Tiger Data

What I Built

Laptop Anomaly Analyzer is an autonomous, AI-powered monitoring system built on Agentic Postgres + Tiger MCP + Gemini.

It continuously collects local system metrics (CPU, RAM, Disk, Network I/O), detects performance anomalies in real time, and automatically explains why they happened — all from within Postgres itself.

No external ML service, no Python inference engine — just Agentic Postgres acting as its own AI brain.

The project began as a simple TimescaleDB-based logger for my laptop performance, but evolved into an agentic database experiment where the DB doesn’t just store telemetry, it understands, reasons, and reacts.

Demo

🔗 GitHub Repository: github.com/StephCurry07/laptop-anomaly-analyzer

(Repo includes collector script, MCP config, and dashboard setup)

Outputs:

Dashboard Preview:

![Grafana Dashboard]

How I Used Agentic Postgres

This project combines several of Agentic Postgres’ most advanced features:

⚙️ Tiger MCP (Model Context Protocol)

Runs three autonomous database agents:
- anomaly_detector → runs every 10 minutes to detect CPU/RAM anomalies.
- root_cause_agent → triggers on new anomalies, uses vector search to find similar incidents.
- daily_summary → summarizes system performance once a day using Gemini reasoning.
All logic executes inside the database, orchestrated through MCP — no external scripts required.

💬 Tiger CLI

Provides a natural-language interface:

 "Summarize anomalies in the last 24 hours"
 "Find similar CPU spikes from past week"

Overall Experience

It was my first time using postgres for a project. Building with Agentic Postgres completely changed how I think about data systems. Instead of pushing data to an external model or pipeline, the database itself became the reasoning layer, thanks to MCP and TigerData.

Stack Used

Postgres + TimescaleDB
Tiger MCP
TigerData
Gemini CLI
Grafana (for visualization)
Python (for metric collection)

Beyond the Cache: AI-Driven Incident Management with Redis

Apoorv Gupta — Mon, 11 Aug 2025 06:58:01 +0000

This is a submission for the Redis AI Challenge: Beyond the Cache.

What I Built

I built an AI-powered incident management platform that doesn’t just track incidents—it actively tries to fix them automatically in real-time.

Instead of being a passive dashboard, the system reacts instantly to new issues by triggering an autofix workflow backed by Redis Streams and JSON storage.

When an incident is detected, Redis:

Stores it as the primary database in JSON format.
Pushes it into a Redis Stream for processing.
Supports real-time WebSocket updates to all connected clients so the UI reflects changes instantly.

The system can:

Detect: New incidents are pushed into Redis JSON.
Fix: A service attempts context-specific fixes.
Update: The dashboard is refreshed via WebSocket with status changes.

This makes the platform not just a monitoring tool—but a self-healing system.

Demo

Github Link: https://github.com/StephCurry07/Redis-IncidentResponseDashboard

📹 Video Walkthrough: YouTube Link

Screenshots:

How I Used Redis 8

I used Redis 8 well beyond simple caching:

Primary Database (RedisJSON)
- Incidents are stored directly in RedisJSON with rich metadata (severity, status, description, tags).
- Updates are instant and atomic—ideal for high-frequency changes from multiple services.
Real-time Streams for Autofix Pipeline
- Every new incident is appended to a Redis Stream (incident_stream).
- A background AI service consumes from this stream to attempt automated fixes, logging results back to Redis.
Pub/Sub for UI Live Updates
- On every update (fix, status change), a message is published to incident_updates.
- The frontend listens over WebSockets for instant UI refreshes without polling.
Full-Text Search (RediSearch) (optional enhancement)
- Allows users to quickly filter incidents by description, tags, or owner with sub-millisecond search results.

Why It’s Beyond the Cache

Redis is the operational core of this system—without it, real-time reaction, distributed event processing, and instant updates wouldn’t be possible.

It’s:

A primary DB (RedisJSON)
A data pipeline (Streams)
A search engine (RediSearch)

... all in one.

Instead of just serving cached reads, Redis orchestrates the entire lifecycle from incident detection → AI fix → live UI updates.

Next Steps

Implement AI autofix logic to handle different infrastructure types.
Integrate with CI/CD pipelines for proactive rollback.
Add historical analytics using RedisTimeSeries.

Stock Search and Insights Using Algolia and n8n

Apoorv Gupta — Mon, 28 Jul 2025 01:08:01 +0000

This is a submission for the Algolia MCP Server Challenge

Stock Search & Insights Platform

What I Built

I built a Stock Search & Insights Platform powered by the Algolia MCP Server for blazing-fast symbol and company name lookups.

Algolia provides instant search across an index of stock names and symbols.
Bun serves as the lightweight backend to fetch data and interact with external APIs.
n8n acts as an orchestration backend, managing workflows for technical analysis, AI-driven insights, and data enrichment.
TwelveData APIs are used for fetching real-time prices, technical analysis, and SMA calculations.
Chart-IMG API generates advanced charts with Bollinger Bands, RSI, and Volume indicators.
GPT‑4o‑mini analyzes the data and produces quick, AI-driven insights for each stock.

The result: A single interface where users can search for a stock, instantly view real-time price data, AI-powered analysis, and technical charts — all in one place.

Demo

GitHub Repo: https://github.com/StephCurry07/Algolia-StockSearch
Video Walkthrough: https://youtu.be/BVtRHilMbRo

How I Utilized the Algolia MCP Server

Built an Algolia MCP Server to manage and query a custom stock index containing symbols, company names, and exchanges.
Exposed MCP-like endpoints (/mcp/searchStocks, /mcp/analyzeStock) that act as a single entry point for the frontend, abstracting away multiple API calls and complex workflows.
Integrated Algolia InstantSearch with my React frontend for fast, typo-tolerant, and responsive search.
Used the MCP server as a broker between Algolia, n8n workflows (for chart generation, technical analysis, and AI insights), and external APIs (TwelveData & Chart-IMG).
This architecture decouples the frontend from multiple data sources — the MCP server handles enrichment, error handling, and data aggregation before sending a unified response back to the UI.

Key Takeaways

Performance is key: Algolia MCP made stock searching instantaneous, which is crucial for a financial data app.
Workflow automation saves time: n8n helped me orchestrate data fetching (real-time quotes, SMA, technical indicators) and combine them into a single response for the frontend.
AI adds value: Using GPT‑4o‑mini, I transformed raw numbers into actionable insights for end-users.
Charting matters: Integrating Chart-IMG allowed me to display professional-grade charts with key indicators effortlessly.
Learned how to combine Algolia + MCP + Bun + n8n + React + AI into a cohesive product pipeline.