DEV Community: Ekram Zafar

Lightkeeper — Defending the Last Light of the Solstice

Ekram Zafar — Sun, 21 Jun 2026 18:08:52 +0000

Video Demo

Live Demo

Play the game here:

https://your-vercel-link.vercel.app

This is a submission for the June Solstice Game Jam 2026.

Introduction

Every year, the June Solstice marks the longest day of the year—a celebration of light at its strongest moment. But that moment is also a turning point. After reaching its peak, daylight slowly begins to fade and darkness gradually returns.

That idea inspired me to create Lightkeeper.

Rather than using the solstice as a simple visual theme, I wanted to transform it into a gameplay mechanic. The player is not merely observing the struggle between light and darkness—they are actively participating in it.

In Lightkeeper, you become the final guardian of a fading world. Darkness spreads relentlessly across the land, shadow creatures emerge from forgotten places, and the last remaining source of hope rests in your hands.

Your mission is simple:

Keep the light alive.

The challenge, however, becomes increasingly difficult as darkness grows stronger with every passing moment.

The Story Behind the Game

Long ago, the world was protected by the Eternal Sun, a magical force that maintained balance between day and night.

Every solstice, the Sun's power would reach its maximum strength and illuminate every corner of the world.

But during one fateful solstice, something changed.

A mysterious force known as the Shadow King emerged from the Void and began consuming the world's light.

Ancient temples collapsed.

Sacred forests fell silent.

Entire civilizations disappeared beneath endless darkness.

As the final solstice approaches, only one guardian remains—the Lightkeeper.

Armed with fragments of the Eternal Sun, the Lightkeeper must collect scattered light energy, defend the remaining sanctuaries, and confront the darkness before the world is lost forever.

Gameplay Overview

Lightkeeper is a real-time survival game built around resource management, exploration, and increasing difficulty.

The player must constantly make decisions while under pressure.

Should you chase a distant orb to restore energy?

Should you risk fighting enemies to protect your remaining health?

Should you focus on survival or maximize your score?

The game continuously asks these questions while darkness spreads throughout the world.

Core Gameplay Loop

The gameplay loop is built around four interconnected systems:

1. Explore

The player moves around the map searching for Light Orbs.

2. Collect

Collecting orbs restores energy and slows the spread of darkness.

3. Survive

Shadow creatures actively pursue the player.

4. Endure

The longer the player survives, the stronger the darkness becomes.

This simple loop creates a constant sense of urgency.

Resource Systems

One of the primary goals of the project was creating multiple systems that influence one another.

Rather than relying on a single health bar, the game introduces several survival mechanics.

Health System

Health represents the physical condition of the Lightkeeper.

Taking damage from enemies reduces health.

If health reaches zero:

Game Over.

This encourages players to avoid unnecessary risks.

Energy System

Energy is the magical fuel that powers the Lightkeeper.

Unlike health, energy decreases continuously over time.

This means the player cannot remain idle.

To survive, players must actively seek out Light Orbs scattered across the map.

This creates a natural exploration mechanic without requiring explicit objectives.

Darkness System

The Darkness Meter is the heart of the game.

Darkness increases continuously throughout the match.

As darkness grows:

Visibility decreases
Tension increases
Survival becomes more difficult
Boss encounters become possible

Darkness acts as both a timer and a difficulty scaling system.

If darkness reaches 100%, the world is consumed and the game ends.

Score System

Players earn points through:

Collecting orbs
Surviving longer
Avoiding damage

The score system encourages replayability and allows players to challenge themselves after mastering the mechanics.

Enemy Design

The enemies represent manifestations of the spreading darkness.

Their purpose is not only to damage the player but to create pressure and force movement.

If players stay in one area for too long, enemies eventually surround them.

This prevents passive gameplay and keeps the experience dynamic.

Shadow Creatures

Shadow Creatures are the first enemies encountered.

Characteristics:

Constant pursuit behavior
Moderate movement speed
Continuous pressure

Although individually weak, they become dangerous in groups.

Boss Encounter

When darkness reaches dangerous levels, a powerful boss appears.

The boss symbolizes the darkness reaching its peak strength.

Unlike regular enemies, the boss:

Has increased size
Has significantly higher health
Creates a dramatic shift in gameplay

The boss encounter serves as the climax of each run.

Visual Design

The visual direction was inspired by fantasy worlds where light and darkness are constantly in conflict.

Key visual goals included:

Strong contrast between light and shadow
Bright collectible objects
Dark atmospheric environments
Clear visual feedback

The player character uses bright colors to immediately communicate safety and hope.

Enemies use darker colors and shadow-inspired designs to emphasize danger.

Visual Effects

Several effects were added to improve player feedback.

Orb Collection Effect

When collecting a Light Orb:

A flash effect appears
The player receives immediate feedback
The action feels rewarding

Darkness Overlay

As darkness increases:

The environment becomes darker
The atmosphere changes gradually
Players feel increasing tension

This effect visually reinforces the game's core mechanic.

Technical Implementation

The project was developed using modern web technologies.

Frontend

React
Vite

Game Engine

Phaser.js

Language

JavaScript

Planned AI Integration

Future Google AI Integration

Architecture

The game is structured around several independent systems:

Player System

Handles:

Movement
Health
Energy

Enemy System

Handles:

Spawning
AI movement
Pursuit behavior

Orb System

Handles:

Collection
Energy restoration
Darkness reduction

UI System

Handles:

Health bar
Energy bar
Score display
Darkness display

Boss System

Handles:

Spawn conditions
Boss state
Endgame pressure

Separating these systems made development significantly easier.

Challenges During Development

Game jams always involve solving unexpected problems.

This project was no exception.

Learning Phaser

Although I had prior programming experience, building a real-time game introduced new challenges.

Understanding:

Scenes
Physics systems
Collision handling
Object groups

required significant experimentation.

Balancing Darkness

Darkness became the most difficult mechanic to tune.

When darkness increased too slowly:

The game felt easy.

When darkness increased too quickly:

The game became frustrating.

Finding a balance required many rounds of testing.

Enemy Spawning

Enemies needed to feel threatening without creating unfair situations.

Several adjustments were made to:

Spawn locations
Movement speed
Spawn frequency

to achieve a better balance.

UI Design

Creating useful UI elements took more time than expected.

Players need immediate access to:

Health
Energy
Score
Darkness level

Without clear information, decision-making becomes difficult.

What I Learned

This project helped me improve my skills in:

JavaScript game development
Phaser.js
Game balancing
Resource management systems
Player feedback design
Debugging interactive applications
Real-time event handling

Most importantly, I learned how small mechanics can combine to create meaningful gameplay experiences.

Future Plans

The current version is only the beginning.

Future updates could include:

Gemini AI Events

Dynamic story events generated by Google Gemini.

Examples:

Ancient shrines
Wandering spirits
Random quests
World-changing events

This would make every playthrough unique.

Additional Enemy Types

Shadow Brutes
Shadow Mages
Flying Wraiths
Elite Hunters

New Bosses

Multiple bosses with unique abilities and attack patterns.

Skill Tree

Unlockable upgrades:

Increased speed
Improved energy efficiency
Light shields
Special abilities

Procedural Maps

Randomly generated worlds for increased replayability.

Sound Design

Ambient music
Boss themes
Collection effects
Environmental audio

Sound would dramatically improve immersion.

Code

GitHub Repository:

https://github.com/ekramzafar/lightkeeper

Prize Categories

Best Google AI Usage

Lightkeeper is designed with future Gemini-powered dynamic events in mind.

The goal is to use AI not simply for text generation, but to influence gameplay and create unique experiences for players.

Best Overall Game

The project combines:

Survival mechanics
Resource management
Enemy AI
Boss encounters
Dynamic difficulty
Strong theme integration

into a cohesive gameplay experience centered around the June Solstice.

Final Thoughts

Lightkeeper began as a simple question:

What if the June Solstice itself became a game mechanic?

From that idea emerged a world where light and darkness are not just visual themes, but active forces that shape every decision the player makes.

The project challenged me to think about gameplay, balance, visual feedback, and storytelling in new ways.

While there is still much more I would like to build, I am proud of what was accomplished during the jam.

Thank you for taking the time to play, review, and experience Lightkeeper.

May the light endure.

Building NeuroSense AI: A Human-Centered Stress Insight Assistant Powered by Gemma

Ekram Zafar — Sun, 24 May 2026 18:26:03 +0000

# Building NeuroSense AI: A Human-Centered Stress Insight Assistant Powered by Gemma

This is a submission for the Gemma 4 Challenge: Build With Gemma

Introduction

AI systems are often designed to answer questions, summarize information, or generate content. But I wanted to explore a different question:

Can AI understand emotional context and provide supportive insights rather than only responding with text?

That question led me to build NeuroSense AI, a human-centered stress insight assistant powered by Gemma.

The goal of this project is not medical diagnosis. Instead, it aims to understand conversational signals and generate meaningful insights that help users better reflect on emotional patterns.

Students, developers, and professionals frequently experience stress from exams, deadlines, projects, and workload pressure. Traditional systems often generate generic responses without understanding emotional context.

NeuroSense AI attempts to make interactions more meaningful.

What NeuroSense AI Does

Users can enter natural messages such as:

"I have exams tomorrow and I haven't slept properly for two days."

The system analyzes the conversation and generates:

Emotional understanding
Stress indicators
Contextual explanations
Personalized recommendations
Session tracking
Dashboard insights

Why I Selected Gemma

For this project I needed more than keyword matching.

I specifically needed:

Context understanding
Human-like reasoning
Flexible deployment
Efficient inference
Meaningful response generation

Gemma was selected because emotional conversations require understanding relationships between ideas rather than detecting isolated words.

For example:

Keyword matching might simply detect:

"exam"

But Gemma can understand:

pressure
exhaustion
emotional state
context across the message

That difference was important for this project.

How Gemma Powers NeuroSense AI

Gemma serves as the core reasoning engine behind NeuroSense AI. Rather than relying solely on keyword detection, Gemma analyzes the full conversational context to identify emotional patterns, stress indicators, and underlying concerns.

For each user interaction, Gemma helps:

Understand emotional context
Generate meaningful stress insights
Provide personalized recommendations
Produce human-centered responses
Support reflective self-awareness

This enables NeuroSense AI to deliver more context-aware and meaningful guidance compared to traditional rule-based approaches.

System Architecture

User

↓

NeuroSense Interface

↓

Gemma Processing

↓

Emotion Analysis

↓

Stress Insights

↓

Dashboard Visualization

Features Implemented

✅ Emotional analysis

✅ Stress insight generation

✅ AI-powered recommendations

✅ Session history tracking

✅ Dashboard visualization

✅ Privacy-focused design

✅ Human-centered interaction flow

Technology Stack

Python
Streamlit
SQLite
Plotly
Gemma
Hugging Face Spaces

Live Project

GitHub Repository:

https://github.com/ekramzafar/NeuroSenseAI

Live Demo:

https://huggingface.co/spaces/ekram7/NeuroSenseAI

https://drive.google.com/file/d/1iWYGloEBF_wlLFnHVJG6_RQI8UKkpnxr/view?usp=sharing

Future Improvements

Future ideas include:

Voice emotion analysis
Multilingual support
Wearable integrations
Personalized long-term trends
Context memory

Final Thoughts

Building NeuroSense AI changed the way I think about AI systems.

The goal should not always be making AI larger.

Sometimes the goal is making AI more meaningful.

AI should not only generate answers.

It should understand people.

From Models to Meaning: How Building NeuroSense AI with Gemma 4 Changed My View of Local AI

Ekram Zafar — Sat, 23 May 2026 20:25:01 +0000

There is a strange thing I noticed while learning and building around AI.

Every time a new model appears, the first conversations usually sound very similar.

People ask:

How many parameters does it have?
How fast is it?
Which benchmark did it beat?
How does it compare against another model?

I understand why those questions matter.

Benchmarks matter.

Performance matters.

Reasoning matters.

But after spending time thinking about a project idea called NeuroSense AI, I slowly realized that I was becoming interested in a very different question.

Not:

"How powerful is this model?"

But:

"What kind of experiences can this model create for people?"

That question stayed with me.

And unexpectedly, it started from something very ordinary.

Not from a research paper.

Not from a benchmark chart.

Not from a technical conference.

It started from student life.

The Moment I Started Thinking About This Differently

As students, we all experience moments that feel strangely familiar.

You sit down to study.

You open your laptop.

You create a plan.

Maybe:

finish assignments
prepare for examinations
complete projects
revise notes

Everything feels manageable.

Then something changes.

You check one notification.

You remember another deadline.

You realize you forgot about another task.

Suddenly your brain becomes noisy.

Your thoughts become:

"I am behind."

"I am running out of time."

"Why can't I focus?"

"Why am I feeling overwhelmed?"

I think many people have experienced some version of this.

Now imagine opening an AI assistant and writing:

"I have exams tomorrow and I feel exhausted."

Most systems would probably generate something like:

"Take a break and stay positive."

Technically that is not wrong.

But something felt incomplete to me.

Because human conversations are rarely only about the words we type.

Human conversations contain invisible things:

emotion
context
uncertainty
stress
frustration
fear
pressure

The sentence itself may be small.

But what sits behind that sentence may be much larger.

That became the starting point for an idea I called:

NeuroSense AI

What Is NeuroSense AI?

NeuroSense AI is a privacy-focused AI assistant concept designed around emotional context and stress insight.

I intentionally use the word insight instead of diagnosis.

The purpose is not to replace professionals.

The purpose is not to become a medical system.

The goal is much simpler:

Create a system capable of listening more intelligently.

I started imagining an interaction like this:

User:

"I haven't slept properly in three days and I cannot focus."

Traditional interpretation:

A sentence.

Potential contextual interpretation:

possible stress indicators
exhaustion patterns
emotional strain
repeated negative sentiment

Then I started asking myself:

Can an AI system understand conversations in a way that feels closer to human interaction?

Not perfect understanding.

Not magical understanding.

Just better understanding.

Why This Made Me Think About Local AI

As soon as I started thinking about systems involving emotional conversations, another issue immediately appeared.

Privacy.

Mental well-being conversations are different from ordinary prompts.

People may discuss:

stress
emotional struggles
personal thoughts
educational pressure
private experiences

This raises an interesting question:

Where should that information live?

For many AI systems today, information usually travels somewhere else.

User input moves to remote infrastructure.

Processing happens remotely.

Response comes back.

That process works.

But I started wondering:

What if AI could stay closer to users?

That was where Gemma 4 became interesting.

Why I Chose Gemma 4

One lesson I keep learning during development is:

Choosing a model is not about selecting the biggest option available.

A good model choice should solve a problem.

For NeuroSense AI I needed several things:

understanding of conversational context
support for longer interactions
flexibility for future environments
strong reasoning capability
opportunities for more private experiences

Gemma 4 became interesting because it felt less like one model and more like an ecosystem.

Understanding the Gemma 4 Family Through a Builder's Perspective

Instead of asking:

"Which model is strongest?"

I started asking:

"Which model fits which problem?"

Small Models (2B and 4B)

Smaller models immediately stood out to me.

Historically, smaller models often meant sacrificing capability.

But efficient models create interesting opportunities.

Imagine:

A student carrying an AI study assistant on a phone.

Imagine:

An educational application operating in lower-resource environments.

Imagine:

AI systems running on devices closer to users.

That changes accessibility.

Because not every developer owns expensive hardware.

Not every student owns powerful systems.

Smaller capable models reduce barriers.

31B Dense Model

Larger dense models become useful for:

deeper conversational workflows
research assistance
document understanding
advanced reasoning tasks

Mixture-of-Experts Architecture

This architecture fascinated me because it approaches computation differently.

Instead of activating everything all the time:

specific experts become active depending on the task.

The idea itself feels interesting because it resembles something humans often do.

Humans do not use every skill simultaneously.

We use different abilities depending on the situation.

The Feature That Completely Changed My Thinking

Initially I looked at the 128K context window and reacted like many people:

"That sounds impressive."

Then I stopped looking at the number.

I started looking at possibilities.

What becomes possible when systems remember more?

Imagine:

A semester-long student assistant.

Imagine:

A research assistant reading multiple papers simultaneously.

Imagine:

An emotional support system recognizing patterns across conversations.

Without context:

AI gives responses.

With context:

AI starts understanding situations.

That difference matters much more than I initially thought.

The Biggest Lesson I Learned

The most surprising lesson was not technical.

It was human.

As developers we often optimize for:

speed
architecture
memory
benchmarks
parameters

But users think differently.

Users usually ask:

"Will this help me?"

"Can I trust it?"

"Does this understand me?"

Behind every prompt there is usually a person.

Behind every message there is usually a story.

And sometimes behind that story there are emotions invisible to machines.

Final Thoughts

Before exploring Gemma 4, I thought mostly about capability.

Now I think more about responsibility.

Powerful AI matters.

But meaningful AI matters more.

Maybe the future of AI is not only larger systems.

Maybe it is systems that understand people better.

Because eventually the question stops being:

"Can we build intelligent systems?"

And becomes:

"Can we build systems that create better human experiences?"

That is the question I want to keep exploring.