NOONFALL: A Solstice Game About a City Where the Sun Forgot to Set

anaykushwaha — Sun, 21 Jun 2026 22:54:37 +0000

This is a submission for the June Solstice Game Jam (https://dev.to/devteam/join-the-june-solstice-game-jam-1000-in-prizes-3jla?bb=263597)

What We Built

We built NOONFALL, a short 2D story-action game inspired by the June solstice. The game follows a courier carrying the last fragment of night through a city where the sun refuses to set. Sunlight drains the player’s energy, while shadows restore it. Players dash through exposed areas, avoid shadowless enemies, collect memory fragments, and survive a final chase before choosing the city’s fate.

Video Demo

The demonstration video link (with voiceover/commentary): https://youtu.be/mHQhZl5JKHQ

Code

GitHub repo: https://github.com/ariv-chaudhry/Summer-Solstice-Hackathon-2026.git

How We Built It

We built NOONFALL with Phaser 3, TypeScript, and Vite as a browser-playable game. The project was structured around separate systems for movement, energy, dialogue, enemies, levels, HUD, audio, and the final chase. Levels are data-driven, with platforms, sunlight zones, shadows, enemies, checkpoints, and story triggers defined separately. This helped us iterate quickly while keeping the code clean and manageable.

Team

This was built by a team of two (we call ourselves the Hackstreet Bois):
Ariv Chaudhry (development) - DEV: @arivchaudhry
Anay Kushwaha (assets / visuals) - DEV: @anaykushwaha

From Prototype to Product: Building TaskLite with Next.js, Copilot, and a Real State System

anaykushwaha — Sun, 07 Jun 2026 22:08:37 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge (https://dev.to/challenges/github-2026-05-21)

What I Built

TaskLite is a modern task management application built using Next.js, TypeScript, and Tailwind CSS

It allows users to create tasks, assign priority levels, track completion status, and view productivity insights through a real-time dashboard

The project started as a simple task input prototype, but evolved into a structured multi-page application with centralized state management, persistent storage, and a clean UI system

This project represents my effort to transform a basic idea into a functional, production-style application with proper architecture and usability

Demo

GitHub Repository:

https://github.com/anaykushwaha/tasklite.git

Since this submission doesn't include a live deployment link, screenshots below demonstrate the application in action

The app includes:

Task creation with priority levels
Filtering by status and priority
Persistent task storage
Real-time dashboard analytics

Before

These are images of the project before I used Github copilot. the project itself was pretty basic, and I didn't optimize it at all, with the most basic functions being the only operational aspects of this project. Image 1: File Structure of the project. Image 2: Readme of the project. Image 3: The basic UI of the project when deployed

After

These are images after I got into this hackathon. The basic functions of the project are obviously the same, but highly more enhanced. Moreover, I added some more aspects to it, such as a priority system, a detailed dashboard, etc. Image 1: The UI of the project now. Image 2: The Active tasks tab (showing all tasks still active / incomplete. Image 3: The Completed tasks tab (showing all completed tasks). Image 4: The High Priority tab (showing only high priority tasks so the user can focus on specific tasks if time's low). Image 5: The Dashboard (basically a report of your progress through your tasklist)

The Comeback Story

The project initially started as a simple task input prototype but lacked structure, consistent state management, and UI cohesion

During the final refinement phase, the application was rebuilt around a centralized TaskStore architecture to unify state across all pages

Key improvements included:

fixing inconsistent state behavior across pages
introducing persistent storage for tasks
improving UI spacing and layout consistency
restructuring components for better reusability
adding a functional dashboard for productivity tracking

The result is a stable, multi-page task management system with real-time updates and a significantly improved user experience

My Experience with GitHub Copilot

GitHub Copilot played a key role in speeding up development and improving code structure throughout the project

It helped with:

generating boilerplate React components
suggesting TypeScript interfaces and patterns
assisting in debugging state-related issues
accelerating UI iteration using Tailwind CSS
improving overall development speed during the final sprint

While Copilot assisted with implementation, the architecture decisions and final refinements were made manually to ensure correctness and consistency

DEV Community: anaykushwaha