DEV Community: shanaldo7

PHANTOM SHELL

shanaldo7 — Wed, 28 Oct 2026 11:19:16 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

What I Built

PHANTOM SHELL: The House That Remembers is a retro horror game concept that turns a computer terminal into a gateway to a haunted world.

The player starts in an abandoned room with an old CRT monitor, a mysterious terminal, and a presence that seems to know more than it should. As the investigation progresses, the player explores strange locations, discovers corrupted memories, interacts with ghosts, and uncovers a disturbing mystery.

But this isn't just a terminal puzzle game.

The terminal and the physical world are connected. Discovering a file can change a room. Examining a photograph can trigger a conversation. A ghost might lie, contradict another character, or reveal something that changes how the player understands the entire story.

The project combines:

Retro 2D pixel-art horror with atmospheric environments and eerie visual effects.
An interactive simulated terminal with fictional commands and discoverable files.
AI-powered ghost conversations that let players ask questions naturally.
Exploration and environmental storytelling across interconnected locations.
Branching mysteries and hidden secrets that reward curiosity.
A shared game state connecting dialogue, evidence, puzzles, and room progression.

I interpreted Ghost in the Machine as the feeling that something inside a computer is trying to communicate with you—and that you may not want to know what it remembers.

Demo

Live demo: [https://phantom-shell.ai.studio/]

The best demonstration would show the player discovering a strange terminal message, exploring the haunted room, speaking with a ghost, and uncovering a clue that changes the environment.

Code

GitHub repository: [https://github.com/shanaldo7/PHANTOM-SHELL]

The project is designed around a modular architecture so the terminal, exploration scenes, characters, puzzles, and story progression can evolve independently while sharing the same game state.

The terminal is simulated inside the game. It does not execute arbitrary commands on the player's real operating system.

How I Built It

I approached PHANTOM SHELL as an interactive storytelling project rather than a conventional chatbot.

The core design connects three systems:

The terminal: Players investigate fictional files, discover clues, and unlock story events.
The haunted world: Rooms change as the player uncovers memories, solves puzzles, and encounters supernatural characters.
The AI characters: Ghosts can respond to natural-language questions, react to discoveries, and present different interpretations of the mystery.

The visual direction draws from classic retro horror games, using pixel-art environments, limited color palettes, dark corridors, CRT effects, and unsettling environmental details.

The architecture is intended to support a lightweight 2D rendering system and a suitable JavaScript/TypeScript stack, with Node.js where a backend is needed.

For AI, the project explores using an open-source or open-weight model for character dialogue and narrative interactions. [Insert the exact model, framework, and inference setup actually used in the submitted build.]

A key design decision is to keep important game rules in application code. AI-generated dialogue can make characters feel alive, but validated game logic controls inventory, puzzle completion, room unlocking, and story progression.

This keeps the mystery playable even when an AI response is unexpected or the model is unavailable.

Why Does Open Innovation Matter?

Open innovation makes it possible to experiment with AI experiences that go beyond a simple question-and-answer interface.

With open-source tools, open-weight models, and community-built frameworks, developers can explore how AI fits into interactive worlds, how character behavior can be controlled, and how AI-powered experiences can remain accessible on modest hardware.

For PHANTOM SHELL, this matters because the AI should be part of the atmosphere and storytelling—not just a chatbot placed inside a game.

I want to explore how a player can investigate a mystery, question an unreliable character, compare conflicting accounts, and gradually uncover a story through their own curiosity.

Open tools also make the project easier for other developers to inspect, adapt, extend, and contribute to.

My Agent Session

[Optional: Add your DevRelay session link or embed your saved agent session here.]

This section can document how AI-assisted development helped shape the game mechanics, narrative design, asset strategy, and implementation.

The Spirit of It

Imagine sitting alone in a dark room, rain tapping against the window, while an old computer displays a message you don't remember writing.

You type a command.

The terminal responds.

Then something else speaks:

"Did you hear that click in the buffer?"

At first, it sounds like a glitch. You investigate the room, discover an old photograph, and ask the ghost standing beside the mirror who it is.

It replies:

"That's a strange question. You used to know."

That is the feeling I want PHANTOM SHELL to create: not just fear of a monster, but the unsettling possibility that the machine remembers something you have forgotten.

The deeper the player investigates, the less certain they become about which memories are real, which characters are telling the truth, and who—or what—is actually speaking through the terminal.

The machine isn't necessarily haunted by the dead. It might be haunted by what it remembers.

Thanks to the Hacktoberfest community for creating a space to experiment with open-source AI, creative coding, and unusual ideas.

lazy-files

shanaldo7 — Tue, 20 Oct 2026 10:37:07 +0000

LazyFiles: A Privacy-First AI File Organizer That Does the Boring Work for You

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Have you ever opened your Downloads folder and found hundreds of files scattered everywhere—duplicate documents, confusing filenames, screenshots, and files you forgot even existed?

I built LazyFiles, a privacy-first, AI-powered file organizer designed to make file management less tedious.

Instead of manually inspecting every file, deciding where it belongs, and renaming it one by one, LazyFiles helps automate the repetitive parts while keeping the user in control.

Here’s what it can do:

Scan folders: Build a file inventory with useful metadata.
Find duplicates: Use SHA-256 hashes to identify files with identical content.
Suggest categories: Use a locally running AI model to propose sensible file categories and filenames.
Preview changes: Review proposed operations before applying them.
Move files safely: Use collision-safe file operations and dry-run simulation.
Keep an audit trail: Record operations in JSON logs and provide a rollback option.

The central idea is simple: let AI handle the tedious suggestions, but let the user make the final decisions.

LazyFiles is built for people who want a more organized computer without handing control of their files to an external service.

The demo will show the folder scanner, duplicate inspector, AI-generated suggestions, operation preview, and rollback workflow.

Code

GitHub repository: [https://github.com/shanaldo7/lazy-files]

The project includes a Streamlit interface, modular Python components, setup instructions, and tests.

How I Built It

I built LazyFiles with Python and Streamlit, using open-source tools and local AI inference.

The main components are:

Python and pathlib for folder traversal and file management.
SHA-256 hashing for content-based duplicate detection.
Ollama to run an AI model locally.
Streamlit for the interactive dashboard.
JSON audit logs to record file operations.
Pytest for testing core functionality.

The AI component integrates with Ollama and supports local model options such as qwen2.5:0.5b, llama3.2:1b, and phi3:mini, depending on the model installed and available system resources.

The application separates scanning, duplicate detection, categorization, and file operations into individual modules. This makes the project easier to maintain and test.

I also designed it with modest hardware in mind. My development environment uses Windows 10, an Intel Core i5-8500, 8 GB of RAM, and integrated graphics, so lightweight local inference matters.

Safety was an important design goal. LazyFiles provides dry-run simulation, previews proposed changes, uses collision-safe moves, and maintains operation logs with rollback support. It is intended to assist with organization rather than silently make destructive decisions.

Why Does Open Innovation Matter?

Open innovation made it possible for me to build an AI-assisted tool around local inference rather than depending on a paid, cloud-hosted AI API.

Using open-source software and open-weight models gives developers more flexibility over model selection, hardware requirements, and how AI fits into an application.

For a tool that works with personal files, local inference is especially useful because file contents do not need to be sent to a third-party AI API for the categorization workflow described here.

Running locally is not, by itself, proof that an application makes no network connections, so network behavior should be verified separately before making absolute privacy claims.

Open innovation also makes projects like LazyFiles easier to experiment with, inspect, adapt, and improve. Developers can build useful AI features without necessarily needing an expensive GPU or a commercial API subscription.

My Agent Session

[Optional: Add your DevRelay agent session link here.]

I can use this section to show how the project was developed, including the implementation process, debugging, and decisions made along the way.

The Lazy Payoff

The goal of LazyFiles is to reduce the repetitive work involved in organizing files.

Instead of manually checking every file, comparing possible duplicates, and thinking up filenames, users can start with a scan, review AI suggestions, and approve the changes they want.

I have implemented the core workflow, including scanning, duplicate detection, categorization suggestions, safe file operations, and rollback support.

I have not included a measured time-saving figure here because I have not established a reliable before-and-after benchmark yet. A useful next step would be to compare the time required to organize the same sample folder manually and with LazyFiles.

What's Next?

I want to keep improving LazyFiles with better categorization, more comprehensive tests, clearer operation previews, and stronger safety checks.

My goal is to make local AI practical for everyday tasks—not just impressive demos.

LazyFiles is my attempt to make file organization a little less work, one folder at a time.

StudyBuddy: Level Up — Turning Studying into a Game 🎮📚

shanaldo7 — Wed, 14 Oct 2026 06:50:26 +0000

StudyBuddy: Level Up — Turning Studying into a Game 🎮📚

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

StudyBuddy: Level Up is an AI-powered, gamified study planner designed to help students turn their study goals into an engaging, structured learning experience.

Many students struggle with consistency, procrastination, and tracking their progress. Traditional to-do lists can help organize tasks, but they don't always make studying motivating enough to sustain long-term habits.

StudyBuddy approaches this problem differently by combining study planning with game-inspired progression.

Key features

🎯 Gamified progression: Earn XP, level up, and track your learning progress.
📚 Subject and topic tracking: Organize your syllabus and monitor your progress across subjects.
⚔️ Dungeon Battles and challenges: Make studying more interactive through game-inspired activities.
📊 Progress tracking: Keep track of learning goals and completed work.
🤖 AI-assisted learning: Use AI capabilities to support the learning experience.
🌙 Immersive interface: A dark, futuristic UI with glowing accents, interactive cards, and a gaming-inspired visual identity.

Who is it for?

The primary audience is students who want a more engaging way to organize their studies, maintain consistency, and prepare for exams.

The side-hustle opportunity

StudyBuddy could evolve into a freemium product, with core study-planning features available for free and optional premium features for users who need more advanced AI assistance, analytics, personalized study plans, or additional customization.

The goal is to explore how an open-source AI-powered application can become a useful product that solves a real problem for students.

Demo

🚀 Try the current project:

https://studybuddy-ultimate.ai.studio

This is the available project link. Verify that the deployed version reflects the features described above before submitting.

Code

💻 GitHub repository:

https://github.com/shanaldo7/STUDYBUDDY-LEVEL-UP-SYSTEM

🌐 Live Application ⚔️ Ready to Level Up? 👉 🚀 LAUNCH STUDYBUDDY

https://studybuddy-ultimate.ai.studio/

— NO DOWNLOAD REQUIRED Open your browser. Start studying. Earn XP. Level up.

The project is being developed with an emphasis on maintaining existing functionality while improving the interface, usability, and overall product experience.

How I Built It

StudyBuddy combines a modern web application with AI-assisted learning capabilities and game-inspired study mechanics.

The project builds on my experience experimenting with AI-powered study tools, local inference, and web development.

The technology and design approach includes:

Frontend: A modern web interface built with Vite and a component-based JavaScript framework.
AI experimentation: Open-weight language models, including Qwen2.5 0.5B through Ollama, as part of my local AI development experience.
Gamification: XP, levels, progress tracking, and interactive study challenges.
Product design: A dark, gaming-inspired interface focused on usability and student engagement.

My focus is not simply to add AI to an application. It is to build a coherent study experience where AI can complement planning, practice, and learning.

Why Does Open Innovation Matter?

Open innovation makes it possible to experiment, learn, and build without depending entirely on expensive proprietary AI services.

For a student developer, access to open-source tools and open-weight models creates opportunities to prototype ideas, understand how AI applications work, and improve them incrementally.

Local inference through Ollama also provides an opportunity to experiment with AI without making every development request dependent on a paid inference API.

Open-source development brings additional benefits:

Accessibility: Developers and students can experiment with AI on a limited budget.
Transparency: The application and its integrations can be inspected and improved.
Flexibility: Different models and providers can be evaluated as requirements change.
Community collaboration: Other developers can contribute features, identify problems, and improve the project.

For StudyBuddy, open innovation makes the journey from a personal learning project toward a potentially useful product more accessible.

What's Next?

My next goal is to improve StudyBuddy's reliability, polish the user experience, and strengthen its value as a product students could use regularly.

I also want to explore sustainable ways to support its development without making essential study-planning features inaccessible to students.

Building this project is an opportunity to combine AI development, open-source collaboration, and product thinking while learning from real users.

Human-Powered Treasure Hunt: Turning AI Discovery Into Real-World Adventure 🗺️🌿

shanaldo7 — Sat, 10 Oct 2026 09:49:26 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.[https://dev.to/challenges/hacktoberfest-week1-2026-10-05]

What I Built

I built Human-Powered Treasure Hunt, an AI-powered exploration app designed to get people away from their screens and out into the real world.

Instead of spending hours scrolling through content, users can discover interesting places, explore local history, uncover lesser-known attractions, and turn real-world discoveries into interactive treasure hunts.

The idea is simple: AI should be a guide to the world outside your screen, not another reason to stay glued to it.

The app is designed around a discovery-driven experience, where users can:

🔎 Discover interesting places and lesser-known local stories.

🧭 Use real-world locations as the starting point for treasure hunts.

🗺️ Navigate to places using Google Maps.

🕵️ Use a Google Lens-assisted workflow to investigate objects and clues.

🤖 Use AI-assisted research to help turn discoveries into engaging challenges.

The goal is to encourage curiosity, exploration, and learning through experiences in the physical world.

Demo

🌐 Try the live app: https://human-powered-treasure-hunt.ai.studio/

The application is deployed and accessible online.

Code

GitHub repository: [https://github.com/shanaldo7/human-powered-treasure-hunt]

The live demo is available now. I still need to add my public source-code repository link here so others can explore the implementation and contribute.

How I Built It

I built Human-Powered Treasure Hunt using Google AI Studio's app-building workflow and deployed it to Google Cloud Run.

The application combines a web-based interface with AI-assisted discovery and real-world navigation. Its intended workflow connects research, clues, and physical exploration rather than keeping the entire experience inside a chat window.

Key components include:

AI-assisted discovery: Helps transform research and interesting findings into hunt ideas and clues.

Live web research: Uses a search integration to help find relevant information and sources.

Google Maps: Connects discoveries to real-world locations and navigation.

Google Lens-assisted discovery: Lets users investigate objects and submit their findings for evaluation.

React and a production server: Power the application interface and backend routes.

Google Cloud Run: Hosts the deployed application.

I also worked through a production deployment issue involving frontend asset paths, verified the production build and application routes, and republished the application successfully.

Why Does Open Innovation Matter?

Many people spend hours exploring the digital world but rarely discover the interesting places, hidden histories, and local stories around them.

Human-Powered Treasure Hunt addresses this by using AI to turn online research into real-world exploration. Open innovation makes this approach more accessible by allowing developers to combine AI, mapping tools, and community-driven data sources to create new ways for people to learn and explore.

By making it possible to extend the app with new research sources, locations, and types of clues, open innovation can help more communities discover the world around them.

The goal is simple: use AI to help people spend less time passively scrolling and more time actively exploring.

Prize Categories

I am submitting this project for the Touch Grass challenge theme.

PHOTOS:

[Boost]

shanaldo7 — Sun, 04 Oct 2026 15:42:34 +0000

Hacktoberfest: Maintainer Spotlight

shanaldo7

Oct 4

Studybuddy-level-up-gamified-study-planner

#devchallenge #weekendchallenge #hf26challenge #hacktoberfest

2 min read

Studybuddy-level-up-gamified-study-planner

shanaldo7 — Sun, 04 Oct 2026 15:33:18 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

📚 StudyBuddy: Level Up — An AI-Powered Study Companion 🎮

What I Built

StudyBuddy: Level Up is an AI-powered study companion designed to make learning more interactive, engaging, and productive.

As a student, I understand how challenging it can be to stay motivated, organize study sessions, and understand difficult topics. I wanted to build something that could help students like me and make studying feel less like a chore.

StudyBuddy combines AI-powered learning assistance with gamified elements to create a more engaging study experience.

The project uses Google's open-weight Gemma model through Ollama, allowing AI-powered features to run locally instead of depending entirely on external AI APIs.

My goal is to make learning more accessible, interactive, and rewarding.

Demo

🚀 Live Demo: [https://studybuddy-ultimate.ai.studio/]

Code

💻 GitHub Repository: [https://github.com/shanaldo7/STUDYBUDDY-LEVEL-UP-SYSTEM]

How I Built It

I built StudyBuddy using Python, Streamlit, Ollama, and Gemma.

Here is the technology stack:

Python: Core application logic and AI integration.
Streamlit: Interactive web interface.
Ollama: Local model management and inference.
Gemma: Open-weight AI model powering local AI features.
Streamlit Community Cloud: Deployment of the web application.

One of the biggest challenges was deploying a locally powered AI application to the cloud.

Locally, Ollama runs on my computer and serves Gemma. However, when I deployed the application to Streamlit Community Cloud, the cloud environment could not connect to Ollama running on my personal PC.

This taught me an important lesson about the differences between local inference and cloud deployment.

Why Does Open Innovation Matter?

Open innovation makes AI development more accessible to students and independent developers.

Using Gemma with Ollama gives me the freedom to experiment with open-weight AI models locally without relying entirely on paid, closed APIs.

It also provides more control over model execution and creates opportunities to learn how AI systems work beyond simply sending requests to an external service.

For a student developer working with limited resources, this matters a lot.

Open innovation allows me to experiment, customize, and build real applications while learning about the technology behind them.

My Agent Session

My agent session is optional and is not included yet.

If I record and upload a session using DevRelay or another supported coding agent, I can add it here.

Prize Categories

🏆 Gemma — Best Use of Gemma ($200)

StudyBuddy uses Google's open-weight Gemma model through Ollama for local AI-powered study features.

By running Gemma locally, I can experiment with open-weight inference and build an AI-powered learning application without depending entirely on closed AI services.