DEV Community: Aayush Sharma

🔥 Campfire After Dark — A Local AI That Tells Stories in the Dark

Aayush Sharma — Sat, 31 Oct 2026 19:40:34 +0000

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

🏕️ What I Built

Campfire After Dark is a local-first AI horror storytelling app that transforms simple prompts into immersive, narrated horror experiences.

I wanted to recreate the feeling of sitting around a campfire at night, listening to a story that gets more unsettling with every passing minute.

With Campfire After Dark, you can:

Generate short or long AI-powered horror stories.
Choose different fear levels and story endings.
Experience stories organized into chapters.
View visuals that accompany the story scenes.
Listen to AI-generated voice narration.
Experience ambient soundscapes that build the atmosphere.
Encounter timed audio and visual jump scares.
Replay individual chapters or the complete story.
Save and revisit your favorite stories.

The goal was to build more than a basic story generator. I wanted to create an interactive horror experience powered by local AI.

🖥️ A Look Inside the Campfire

🏠 Home Page

📖 Story Player

💾 Saved Stories

🎬 Demo

Watch Campfire After Dark in action:

👉 https://vimeo.com/1241814042?share=copy&fl=sv&fe=ci

The application currently runs locally on the user's machine. The demo video will walk through story generation, narration, the story player, and saved stories.(The demo video also contains a demo story).

💻 Code

🔥 GitHub Repository:

Campfire After Dark — GitHub

The repository contains the frontend, local AI integration, narration server, and setup instructions.

🛠️ How I Built It

The most important part of this project is that its AI capabilities run locally.

AI Story Generation — Ollama + Qwen3

I used Ollama to run the Qwen3 4B Instruct model locally.

The model generates horror stories based on the user's choices. The app creates the full story first and then organizes it into chapters, helping avoid generation pauses between chapters during playback.

AI Voice Narration — Kokoro ONNX

For narration, I integrated Kokoro ONNX through a local FastAPI server.

It converts story text into speech, giving the stories a narrated experience without relying on an external cloud text-to-speech API.

Frontend — React + Vite

The user interface is built with React and Vite. It handles story creation, chapter navigation, visuals, audio playback, ambient sound, and jump-scare timing.

Local Story Storage — IndexedDB

Generated stories are saved in the browser using IndexedDB, allowing users to revisit their stories without needing a hosted database.

Technology Stack

AI model: Qwen3 4B Instruct
Local model runtime: Ollama
Voice generation: Kokoro ONNX
Backend: Python + FastAPI
Frontend: React + Vite
Storage: IndexedDB
Audio experience: Browser audio playback and ambient sound

Why Does Open Innovation Matter?

For Campfire After Dark, open innovation is not just a technology choice. It is part of the project's identity.

I wanted to build an AI experience where users do not have to send their story prompts to an external AI service.

By running the models locally:

Privacy: Story prompts and generation requests stay on the user's machine rather than being sent to a hosted AI inference API.

No per-request API fees: Once the models are installed, local inference does not require paying an external provider for each generated story or narration request.

Freedom to experiment: I can experiment with local models and change the way the storytelling experience works without being tied to a single closed AI API.

Local control: The core AI generation and narration services run on the user's own machine.

There are trade-offs. Users need to download the models, install the required dependencies, and have hardware capable of running them.

But for this project, that trade-off is worthwhile. It gives me greater control over the experience and keeps the core AI workflow local.

I believe open innovation makes AI more accessible to experiment with, customize, and build upon.

🔥 The Spirit of It

Every good horror story begins with a little imagination.

A strange noise outside the window. Footsteps in an empty hallway. A voice coming from somewhere it should not be.

I wanted Campfire After Dark to capture that feeling.

The idea was to combine local AI storytelling with narration, visuals, atmospheric audio, and unexpected scares to create something that feels closer to an interactive campfire story than a traditional chatbot.

And perhaps the best part is this:

The next scary story does not have to come from the internet. It can come from the machine sitting right in front of you.

🌙 Keep the lights on. You might need them.

Built with curiosity, open AI, and a little bit of fear. 🔥

Receipt Raccoon: A Local-First AI for the Receipts We Never Want to Find

Aayush Sharma — Sun, 25 Oct 2026 08:55:39 +0000

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

What I Built

Meet Receipt Raccoon 🦝 — a local-first receipt and warranty organizer built to solve a surprisingly annoying problem: finding the bill you need when you actually need it.

You buy a phone, an appliance, or a computer. You keep the receipt somewhere safe. Months later, you need it for a warranty claim, and suddenly that “safe place” is nowhere to be found.

I built Receipt Raccoon to make that process less painful.

Here's what it can do:

Read receipts with AI: Upload a supported receipt image and use Gemma to extract information such as the product name, seller, purchase date, amount, and warranty expiry date. You can review and correct the results before saving.
Find receipts with natural language: Ask questions such as “Find the refrigerator bill from last year” instead of trying to remember an exact filename.
Track warranties: See which warranties are active, expiring soon, or expired.
Detect potential duplicates: Get a warning when a receipt looks similar to one already saved.
Manage documents: Search, open, and delete receipts, clear the collection, and download or restore backups.

Receipt records and original files are stored in the browser's IndexedDB. The goal is to make keeping track of important purchases easier without requiring a complicated account or a cloud database.

Demo

Live website: Try Receipt Raccoon

Source code: GitHub — Receipt Raccoon

Video walkthrough

The hosted demo lets you explore the document-management interface, warranty tracker, and backup features.

One important detail: AI reading and natural-language search require Ollama running locally with the Gemma model. Those AI features are not enabled on the hosted Vercel demo, so they need to be demonstrated using the local application.

That separation is intentional. I wanted to make the interface accessible online without pretending that my computer's local AI service was available to everyone on the internet.

Code

The project is built with Next.js and TypeScript.

The main parts of the implementation include:

app/api/analyze-receipt/route.ts — handles receipt-image analysis.
app/api/search-receipts/route.ts — handles natural-language receipt search.
lib/receipts.ts — manages receipt records in IndexedDB.
lib/backup.ts — handles backup creation and restoration.
app/page.tsx — brings the receipt-management interface and features together.

Explore the complete implementation in the GitHub repository.

How I Built It

I built Receipt Raccoon with Next.js, React, TypeScript, and CSS. IndexedDB stores receipt information and the original documents locally in the browser.

For the AI features, I used Gemma 3 through Ollama, running on my own computer.

The receipt-reading flow sends a supported receipt image to the local application endpoint, which passes it to Ollama for analysis. The extracted fields are then placed into a form so the user can verify them against the original receipt before saving.

The search feature takes a different approach: it sends receipt metadata to the local Ollama service rather than sending the original bill images. The model helps interpret the user's question and identify matching receipts.

I also added deterministic duplicate-detection rules, warranty-expiry calculations, individual and bulk deletion, and JSON backup and restore.

One lesson from building this was that the AI model is only one part of the experience. The surrounding application needs to handle uncertain extraction results, storage failures, duplicate warnings, and recovery just as carefully.

Why Does Open Innovation Matter?

Receipts can reveal more than a purchase. They can contain names, addresses, transaction details, and information about the products someone owns.

That made local inference an important design choice for this project.

Because Gemma runs locally through Ollama, the local AI workflow can process receipt images on the user's own computer rather than requiring a hosted AI inference API. The natural-language search also uses local inference, with receipt metadata sent to the local service instead of the original images.

Once the model has been downloaded and installed, local inference can work without an internet connection, provided Ollama and the application are running correctly.

This approach also avoids per-request charges from a hosted AI API, although it still uses the computer's hardware and electricity.

Open-weight models give developers the flexibility to run models in their own environment and build around them. That makes experimentation possible without committing every inference request to one external service.

There are trade-offs. Local inference depends on the user's available hardware, and initial installation requires downloading the model. A hosted model may be more convenient on devices that cannot run AI locally.

For Receipt Raccoon, I chose the local approach because control over personal documents is part of the product, not just an implementation detail.

The Lazy Payoff

I haven't measured a specific number of minutes saved, so I won't invent one.

The intended payoff is simple: less time searching drawers, opening random files, typing purchase details manually, and trying to remember warranty dates.

A family could use Receipt Raccoon to keep appliance bills together. Someone replacing a phone could find the purchase details they need. And when a warranty is about to expire, the information is already organized.

The aim is to do a little organizing once and make future searches easier.

That's the kind of laziness I wanted to build for: not avoiding something important, but removing the unnecessary effort around it.

Prize Categories

Best Use of Gemma — Receipt Raccoon uses Gemma 3 for local receipt extraction and natural-language receipt search through Ollama.

Building this project reinforced something I appreciate about open innovation: useful AI doesn't always need to live behind a remote API. Sometimes the best solution is a model running on your own machine, doing a small but genuinely useful job.

Thanks for checking out Receipt Raccoon! 🦝

Highlight Generator: Turn Long Event Videos into Short Highlight Reels with Local AI

Aayush Sharma — Sun, 18 Oct 2026 18:24:48 +0000

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

What I Built

Highlight Generator turns a long event video into a short highlight reel, right on your own computer.

Think about the videos you record at a college fest, a trip, a birthday, or a wedding. The footage can be hours long, nobody wants to sit through all of it, and editing it manually takes time. Highlight Generator helps you turn that footage into a short reel with transitions, effects, and music.

Here’s how it works:

Upload: Add a long video.
Find: The app analyzes audio levels and visual motion to identify candidate moments.
Smart pick: A local AI model reviews a frame from each candidate, writes a caption, rates how exciting the moment looks, and helps select the best clips.
Direct: The AI acts as a director, choosing from predefined effects, transitions, music moods, and sound modes.
Music: Use a built-in track or upload your own.
Export: Download the finished reel as an MP4.

I built it for people who film events but don’t necessarily have the time or skills to edit them, including college fest media teams, small event videographers, and families. I haven’t yet validated whether people would pay for it, so finding out whether this solves a problem people are willing to pay to fix is still part of the journey.

The AI only sees one frame from each candidate moment and doesn’t hear the video, so its captions and excitement scores are suggestions rather than definitive judgments. You can adjust the music, sound mode, and reel length before exporting.

Demo

Watch the demo to see how Highlight Generator works, from uploading an event video to selecting highlights, choosing music and sound settings, and exporting the final MP4 reel.

Download the Highlight Generator Demo Video (MP4)

There is no live web link, and that is intentional. Highlight Generator runs on your own computer, so your footage doesn't need to be uploaded to a remote server for AI processing. The repository includes instructions to run it yourself.

Code

Aayush264 / highlight-generator

🎬 Highlight Generator

Turn a long video into a short highlight reel, privately, on your own computer.

Upload footage from a party, trip, college fest or wedding. The app finds the best moments, a local AI model reviews them, and your reel is cut and mixed with music. Nothing is uploaded to any server, and nothing costs money per video.

Built for the Hacktoberfest Open-Source AI Challenge, Week 2: Side Hustle.

Demo / How to Use

Watch the demo to see Highlight Generator in action.

Download the Highlight Generator Demo

How it works

Find. FFmpeg and some simple maths score every second of the video by loudness and motion, then pick the strongest 6-second moments.
Review. A local vision model (Gemma 3 4B, through Ollama) looks at one frame from each moment, writes a short caption and rates how exciting it is. Smart pick uses these ratings to choose better…

View on GitHub

How I Built It

I built Highlight Generator with Node.js, Express, plain HTML, CSS and JavaScript, FFmpeg, and Gemma 3 4B running locally through Ollama.

FFmpeg does the heavy work. It measures audio levels per second, compares frames to estimate visual motion, cuts clips, applies effects and transitions, and mixes the audio.
Gemma does the judging. For each candidate moment, the model receives a frame and returns JSON containing a short caption, an excitement score from 1 to 10, and a reason for its score.
The AI is the director; FFmpeg is the crew. Instead of letting a small model generate arbitrary video-editing commands, I restrict its creative choices to predefined menus: 6 effects, 8 transitions, 5 music moods, and 3 sound modes. The server validates the model’s responses and replaces invalid choices with safe defaults.
Smart pick narrows things down. It finds twice as many candidates as the reel needs, asks Gemma to rate them, removes lower-scoring moments, and keeps the best-scoring clips.
The built-in music is original. I wrote a script to generate 10 simple original tracks, with 2 for each mood. Users can also upload their own music.

One issue I encountered was uneven volume between clips taken from different parts of a source video. It made the reel sound inconsistent, so I added loudness leveling for individual clips and an option to mix music with the original sound.

Why Does Open Innovation Matter?

Event footage can be deeply personal. Weddings, family gatherings, trips, and college events aren’t necessarily the kind of videos people want to upload to a service they don’t control.

Using an open-weight model locally gives Highlight Generator a few important advantages:

Privacy: Video processing and AI inference can happen on the user’s own computer, without sending footage to a remote AI API.
No per-video AI API fee: There’s no cloud inference charge for every video processed, although the app still uses the computer’s resources and electricity.
Flexibility: The model can be changed to another compatible vision model that supports the expected input and output format.
Offline use: After the required dependencies and model have been installed, the processing workflow can run without an internet connection.

I haven’t benchmarked Highlight Generator against a paid cloud API, so I can’t honestly claim that local inference is faster, cheaper overall, or more accurate in a measured comparison.

What I can say is that local inference gives users more control over where their footage is processed and avoids a per-video model API bill. The trade-off is that processing speed depends on the user’s hardware, and a small model’s excitement scores can be rough. Testing it on more footage and measuring performance on different machines are still on my to-do list.

Prize Categories

Best Use of Gemma: Highlight Generator uses Gemma 3 4B locally through Ollama to caption and score candidate moments and help guide the creative direction of the final reel.

What’s Next

I’d like to add subtitles using a local speech model, a vertical video format for Reels and Shorts, and test Highlight Generator with more real event footage.

I also want to learn whether the people this tool is built for would use it regularly and whether the time it saves is valuable enough that they would pay for it.

Step back from editing. Let the best moments find you. 🎬

Lifeform 🌿 — Turning Outdoor Exploration Into a Nature Discovery Game

Aayush Sharma — Sun, 11 Oct 2026 09:08:44 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

🌿 Lifeform — Explore. Discover. Build.

What I Built

Lifeform is a nature-exploration game that encourages people to step outside, discover living things, and build a digital collection of their discoveries.

The idea is simple: instead of spending more time scrolling, go outside and notice the living world around you.

With Lifeform, you can photograph a plant, bird, insect, fungus, or other animal and ask an AI naturalist to identify it.

Here's how the experience works:

Explore: Head outdoors and find something interesting.
Discover: Upload a photo and receive an AI-generated identification, confidence level, and description.
Collect: Add new discoveries to your collection.
Build: Earn XP, level up, complete daily missions, and track your progress.
Reflect: Record observations in your Field Journal and build exploration streaks.

Lifeform combines nature discovery with game mechanics to make outdoor exploration feel rewarding.

I'm building this as a learning project to explore how open-weight AI can support a real-world activity rather than simply keep people on a screen.

AI identifications can be wrong, so results should be treated as suggestions rather than scientific confirmation.

Demo

🌐 Live demo: https://lifeform.onrender.com

The deployed app lets you try the image-scanning experience and explore the main features.

Code

💻 GitHub repository: https://github.com/Aayush264/lifeform/tree/deploy

How I Built It

I built Lifeform using HTML, CSS, JavaScript, Node.js, Express, MongoDB, and open-weight Gemma models.

The frontend provides the discovery interface, collection, missions, and Field Journal. The Express backend handles API requests and image uploads, while MongoDB Atlas stores player data.

AI identification was the most interesting part of the project.

During local development, I used Gemma 3 4B through Ollama. This allowed me to experiment with image analysis on my own computer.

For the hosted version, I integrated Gemma 4 through Google's GenAI API. Since my free web-hosting instance doesn't have enough memory to run the local model itself, hosted inference made it possible to offer AI scanning in the deployed app.

I deployed the web application on Render and connected it to MongoDB Atlas.

Getting everything working taught me about API integration, environment variables, database authentication, network access, and debugging deployment failures.

Why Does Open Innovation Matter?

Open-weight AI gave me an opportunity to experiment with a vision model without having to build an AI model from scratch.

Using Gemma locally through Ollama let me test prompts, learn how image analysis behaves, and build my application around the model's capabilities.

For deployment, I chose hosted Gemma inference so that the public demo could run without requiring every visitor to install a local model.

This taught me that open-weight models offer flexibility: developers can experiment locally, change models, and choose how to run inference based on their resources.

The deployed version still requires an internet connection and uses a hosted API, so it isn't completely offline. I'd like to explore more local-first options in the future.

For me, open innovation made this project possible as a learner: I could start small, build a real application around an open-weight model, and learn how to take it from local development to a working online demo.

Prize Categories

Best Use of Gemma: Gemma powers Lifeform's image-identification feature, using Gemma 3 4B locally and Gemma 4 through a hosted API.
Best Use of MongoDB Atlas: Atlas serves as the database for player data in an application built around open-weight AI.

What's Next?

I'd like to continue improving identification results, outdoor missions, and the discovery experience.

The goal is to make the app useful for encouraging people to look more closely at the nature around them — and then put their phones away and enjoy it.

Step outside. Notice more. Discover something new. 🌱