DEV Community: Aditri

👻 Echoes: Ghost in the Machine — Giving Forgotten Stories a Voice with Local AI

Aditri — Fri, 30 Oct 2026 08:51:55 +0000

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

What I Built

The inspiration came from the idea that machines can preserve fragments of forgotten memories, places and stories. I wanted to explore this concept by building something creative rather than another conventional AI chatbot.

Echoes allows users to create atmospheric ghost stories by choosing:

Six different storytelling themes.
Five different moods.
A custom setting.
Three story lengths: Flash, Short and Long.
An optional detail or memory to incorporate into the story. The application transforms these inputs into a structured prompt, sends it to a locally running AI model and generates an original story that users can download as a Markdown file.

The idea behind Echoes is simple: What if a machine could give forgotten stories another voice?

Demo

https://echoes-ghost-in-the-machine.onrender.com/

Code

https://github.com/aditric7/echoes-ghost-in-the-machine

How I Built It

Echoes is built using Python, Streamlit, Ollama and Gemma 3 1B.

Technology Stack

Python — Application logic and prompt construction.
Streamlit — Interactive web interface.
Ollama — Local model serving and inference.
Gemma 3 1B — Open-weight language model for story generation.
Requests — Communication with Ollama's local API.

How the application works?

The user selects a theme, mood, setting and story length.
Python combines the selections into a structured storytelling prompt.
The application sends the prompt to the Ollama API running locally.
Gemma 3 1B processes the prompt and generates an original story.
Streamlit displays the generated story and provides a Markdown download option.
The application is designed to run locally without requiring a paid hosted AI API.

Why Does Open Innovation Matter?

I chose open-weight AI because I wanted to explore what becomes possible when developers have greater control over the models they use.

With Echoes, the model runs on the user's own machine through Ollama. This creates several advantages:

Privacy and local inference
Story prompts can remain on the user's machine instead of being sent to an external hosted AI API.
Model flexibility
Users can experiment with different Ollama-supported models by changing the model tag without rebuilding the entire application.
Accessibility
There is no requirement for a paid hosted-model API key. After the initial setup and model download, generation can work offline.
Developer independence
Using an open-weight model makes it possible to inspect the application workflow, experiment with model behaviour and understand how AI inference works beyond simply calling a commercial API.

Of course, local inference also has trade-offs. Users need to install Ollama, download the model and have sufficient hardware resources.

For me, this project demonstrates that useful AI experiences can be built without making every interaction dependent on an external AI service.

The Spirit of It-

Every forgotten place has a story. Every old machine has a history. Every memory carries something worth preserving.
With Echoes, I wanted to explore the connection between technology, memory and storytelling.
The project takes inspiration from the idea that even something as ordinary as an abandoned computer, an old terminal or a forgotten digital space could become the starting point for a story.
Perhaps the most interesting ghost isn't supernatural at all.
Perhaps it's a story waiting to be remembered.

Prize Categories

Best Use of Gemma

Built independently for Hacktoberfest 2026.

THANK YOU FOR READING!!

FiloSort AI: Building an AI-Powered File Organization Assistant 🤖📁

Aditri — Mon, 26 Oct 2026 06:13:44 +0000

Have you ever spent too much time searching through a cluttered Downloads folder, trying to remember where you saved a particular file?

That problem inspired me to build FiloSort AI, an AI-assisted file organization project developed for the Hacktoberfest 2026 DEV Challenge.

The idea

FiloSort AI aims to make file organization simpler by helping users identify suitable categories and suggesting where their files could belong.
Instead of manually deciding how to organize every file, users can explore organization suggestions through a dedicated web interface.

What I've built

Dashboard: An overview of the application's organization features.
File categories: Separate sections for documents, images, audio, and video.
AI Organiser: An interface for generating and reviewing file organization suggestions.
Suggested organization: Recommendations for categories and destinations based on file information.
Backend API: A FastAPI backend that processes requests from the frontend.
Deployed web application: A live frontend and backend that make the current prototype accessible online.

Tech stack

Frontend: React, Vite, CSS
Backend: Python, FastAPI
AI experimentation: Ollama with Gemma 3 (1B) during local development
Deployment: Render
Version control: Git and GitHub

Demo

Try the live application:
Live Demo:-- https://filosort-ai-1.onrender.com
Backend API:-- https://filosort-ai.onrender.com/docs

FiloSort AI is a web-based prototype that helps users explore file categories and organization suggestions through a dedicated interface.

Code

GitHub Repository: https://github.com/aditric7/FiloSort-AI
The project uses a React frontend and a Python FastAPI backend. The repository contains the source code for the application.

How I Built It?

I built FiloSort AI to explore how AI-assisted organization could make managing digital files easier.
The application includes a dashboard, file-category sections, an AI Organiser interface, and a backend endpoint for generating organization suggestions.
During local development, I experimented with Gemma 3 (1B) through Ollama. One important lesson was that a model running locally on my computer is not automatically accessible to a cloud deployment. The current deployed version uses fallback suggestions when the local model is unavailable.
At this stage, the application focuses on organization suggestions rather than automatically moving files on a user's computer. Connecting hosted model inference and supporting actual file-content analysis are planned improvements.

Why Does Open Innovation Matter?

Open innovation made this project a valuable learning experience because I could explore open-weight AI models, experiment with local inference, and build on accessible development frameworks.
Using Gemma through Ollama gave me an opportunity to understand how a model can be integrated into an application without relying entirely on a closed, hosted AI API during local development.
Open-source tools such as React, FastAPI, and Ollama also helped me learn by building and debugging a complete application, from its interface to its backend and deployment.
For me, open innovation is about being able to experiment, inspect how tools fit together, learn from the community, and improve a project incrementally.

Prize Categories

Best Use of Gemma
Best Use of Render

This project was developed as an individual submission.

THANK YOU ALL FOR READING !!

🌿 OuttaDoor: Turning Everyday Life Into an Adventure

Aditri — Sat, 10 Oct 2026 19:15:00 +0000

What I Built:-

🌿** OuttaDoor **— Turning Everyday Moments Into Outdoor Adventures

What if technology encouraged us to spend less time on screens and more time experiencing the world around us?

That idea inspired OuttaDoor, a web application designed to turn ordinary moments into opportunities for outdoor adventures.

Users can choose an outdoor vibe, such as Nature, Walking, Photography, or Friends, select their available time and mood, and generate a quest to help them get outside and try something different.

The idea is simple: make the screen the starting point, not the destination.

I built OuttaDoor for people who sometimes need a little inspiration to break their routine, explore their surroundings, or enjoy a small outdoor activity.

Demo
🌐 Live Website: https://outtadoor-1.onrender.com/

The application is deployed on Render, and I've tested the live website independently of my laptop.

Code
💻 GitHub Repository: https://github.com/aditric7/OuttaDoor

The repository contains the frontend, backend, and project documentation.

Tech stack:

1:HTML, CSS, and JavaScript for the frontend
2:Python, FastAPI, and Pydantic for the backend
3:Gemma 3 1B through Ollama for the local AI setup
4:Render for deployment

How I Built It

I worked on setting up the project structure, connecting the frontend to the FastAPI backend, configuring deployment, troubleshooting issues, updating the README, and testing the live application.
For the AI component, I explored using Gemma 3 1B through Ollama, allowing the model to run locally in my development setup.
The backend attempts to use the configured Ollama service to generate quests. I also implemented a fallback mechanism so the application can return predefined quests when the AI service is unavailable.

**One important limitation in the current deployment **is that the Render backend cannot automatically access the Ollama model running on my laptop. Consequently, the deployed website may return fallback quests rather than generating them through Gemma.

I also used AI assistance during development. While working through the project setup, integration, configuration, debugging, deployment, and testing process myself. This project helped me understand how the different parts of a deployed web application fit together.

Why Does Open Innovation Matter?

Open-weight models offer developers an opportunity to experiment with AI beyond simply calling a closed, hosted API.

By exploring Gemma 3 1B with Ollama, I could learn about local inference, experiment with the model in my own environment, and understand the practical trade-offs involved in running AI locally.

A locally running model can offer more control over where inference happens and reduce dependence on a remote inference service when configured appropriately. It also provides flexibility to experiment with different models and deployment approaches.

However, local inference requires suitable hardware and a running model service. In my current deployment, the local model is not automatically available to the hosted backend, which is why the fallback mechanism matters.

For me, open innovation made the AI implementation a learning experience—not just about using a model, but also about understanding how it runs, how the application connects to it, and what happens when the model is unavailable.

My Agent Session:
I don't currently have a DevRelay agent session to share. I developed the project with AI assistance and hands-on configuration, integration, debugging, deployment, and testing.I'll make one soon.

Prize Categories:
Potential category to consider: Gemma — Best Use of Gemma.

Prize Categories
I'm interested in the Gemma category because I explored Gemma 3 1B through Ollama for local quest generation. I'll make sure my submission accurately reflects how the model is implemented and used in the project.

✨ What Works Today?

1: A web interface for generating quests
2: A FastAPI backend connected to the frontend
3: A fallback mechanism for when the local AI service is unavailable
4: A deployed website that I tested independently of my laptop

🚀 ** What I'd Improve Next**

I'd like to make model inference available in the deployed version, improve quest personalization, and explore ways to make the experience more useful for different outdoor activities.
Building OuttaDoor has been a learning experience in turning an idea into a working, deployed application—not just writing code, but connecting components, debugging, and testing the result.
Try OuttaDoor: https://outtadoor-1.onrender.com/

*If you try it, I'd delighted to hear what you think! *🌿

🌿 OuttaDoor: Turning Everyday Life Into an Adventure

Aditri — Sat, 10 Oct 2026 19:00:24 +0000

We use technology for almost everything, but what if we built something that encouraged us to step away from our screens?

That question inspired 🌱OuttaDoor, a quest-generation web application designed to turn ordinary moments into opportunities for real-world adventure.

🔗 Live Demo: https://outtadoor-1.onrender.com/
💻 Source Code: https://github.com/aditric7/OuttaDoor

🌱 The Idea Behind OuttaDoor

Sometimes, all we need is a small idea to break our routine: explore somewhere new, try an outdoor activity, or spend time doing something different.

OuttaDoor is designed to make that first step easier by generating quests that encourage users to engage with the world around them.

The idea fits the Hacktoberfest Week 1 theme, “Touch Grass,” by making the screen a starting point rather than the destination.

🛠️** How I Built it:--**

I built the application using:

1:HTML, CSS and JavaScript for the frontend
2:Python, FastAPI and Pydantic for the backend
3:Gemma 3 1B with Ollama for the local AI setup
4:Render for deployment

I worked on setting up the project structure, connecting the frontend and backend, configuring deployment, troubleshooting issues, updating documentation, and testing the live application.

I also used AI assistance during development. Along the way, I worked through the integration and deployment process to understand how the different parts fit together.

🤖 Why Open-Weight AI?

I explored running Gemma 3 1B locally through Ollama. This gave me an opportunity to learn about local inference and the flexibility of working with open-weight models.

A local model can offer more control over where inference happens and can reduce dependence on a remote model API when it is running on your own machine.

I also deployed the application on Render and implemented fallback quest generation so the website remains usable when the local AI service is unavailable.

There is an important limitation in my current deployment:
But the Render backend cannot automatically access the Ollama model running on my laptop. When that model is unavailable, the application falls back to predefined quests. So the live demo does not always perform AI inference.

✨ What Works Today?

1: A web interface for generating quests

2: A FastAPI backend connected to the frontend

3: A fallback mechanism for when the local AI service is unavailable

4: A deployed website that I tested independently of my laptop

🚀 ** What I'd Improve Next**

I'd like to make model inference available in the deployed version, improve quest personalization, and explore ways to make the experience more useful for different outdoor activities.
Building OuttaDoor has been a learning experience in turning an idea into a working, deployed application—not just writing code, but connecting components, debugging, and testing the result.
Try OuttaDoor: https://outtadoor-1.onrender.com/

*If you try it, I'd delighted to hear what you think! *🌿