DEV Community: Sambhav Bohra

AfterLight(Ghost in the Machine)

Sambhav Bohra — Thu, 29 Oct 2026 21:35:31 +0000

What I Built

AFTERLIGHT: Stories Beyond the Veil is a haunted storytelling website where [short description: ghost stories / AI-narrated tales / interactive hauntings] meet an immersive web experience. Before you read a single word, the site pulls you in: you see a first-person view of walking toward a weathered stone arch, and you pass through the gate into the world of the stories.

For the “Ghost in the Machine” theme, I took it literally. The machine is the website itself, and the ghosts live inside it. [One line on how AI acts as the ghost: for example, it narrates, generates, or haunts the reader.] I wanted people to feel like they were entering a haunted house, not just opening a web page.

Demo
Live app: https://dev-4-challenge-pa3j.vercel.app/

Code

[GitHub repo link, https://github.com/Sambhav-17/DEV-4-Challenge ]

How I Built It
Frontend: React + Vite
3D entrance: Three.js renders the haunted-gate animation on load, with a first-person camera moving through the stone arch
Prototyping: [Google AI Studio, and what you used it for]
AI layer: [Model name, what it generates, and how it connects to the site]
Hosting:

[Add 2–3 sentences on a hard part you solved, such as the camera path, fog and lighting, load-time performance, or getting the AI output to fit the story.]

Why Does Open Innovation Matter?

[Fill this in once I know which open tools you used. Points you can use if they apply: open libraries like Three.js and React made the immersive part possible without a studio budget. Open-weight models can run locally, so stories aren’t tied to one company’s API or pricing. Anyone can fork, remix, and add their own ghosts.]

The Spirit of It

Horror works best when it’s atmosphere rather than shock. The moment I saw the gate fade into fog and the first story appear, it felt like the site had a presence of its own. [Add a real moment, such as a friend’s reaction, a memory the project brought back, or a story you wanted to keep alive. Delete this section if you have nothing true to put here.]

To finish it, I need:

Which AI model or tool powers the project, and what it does for readers
Your deployed link and GitHub repo
Which prize categories you’re entering

Which AI Models & Tools Power AFTERLIGHT
AFTERLIGHT is built around an open-weight, sovereign AI architecture designed for private, local execution:

Primary Default Model — Qwen 2.5 (7B Instruct):
License: Apache 2.0 (OSI-compliant, true open source).
Role: Selected as the premier storytelling model for its emotional resonance, multilingual literary sensitivity, and atmospheric dialogue.
Open-Weight Model Family (User-Selectable in the AI Lab):
Mistral 7B Instruct v0.3 (Apache 2.0) — High-coherence narrative pacing and sliding-window attention.
DeepSeek R1 Distill 8B (MIT License) — Intricate narrative arcs, plot depth, and philosophical reflection.
Llama 3.2 3B (Open Weights) — Compact edge inference for low-spec laptops.
Phi-3.5 Mini 3.8B (MIT License) — Lightweight high-context reasoning.

Inference Runtime Tools:

Ollama (localhost:11434) / OpenAI-Compatible Runtimes: Runs models directly on the user's hardware so personal memories and stories are processed locally without cloud data surrender.
Google Gemini 3.8 Flash (@google/genai): Server-side fallback for cloud previews, web
demonstrations, or machines without dedicated GPU VRAM.
Veil Archive Sanctuary (Autonomous Fallback): Built-in procedural story generator ensuring seamless reading even if all inference backends are offline.

What It Does for Readers
For readers and visitors, AFTERLIGHT transforms traditional reading into an interactive, multi-sensory remembrance experience:

Summons Cinematic Literary Ghost Stories:
Rather than generic AI chatbot replies, readers can select narrative parameters (mood, setting like an abandoned observatory or fog-drenched lighthouse, pacing, and ending tone) and pair them with real inspirations (an antique key, an old melody, or a family heirloom).
The AI crafts literary tales inspired by Shirley Jackson, Edgar Allan Poe, and Guillermo del Toro—where supernatural presences represent love, memory, and unresolved promises rather than cheap horror.
Readers can export stories as Markdown, copy them, or preserve them in the archive.
The 3D Veil Garden:
A real-time Three.js WebGL sanctuary where readers explore an ancient megalithic gate, floating spectral orbs, and light memorial beeswax candles with custom dedication messages that persist in 3D space.
The Ofrenda of Remembrance:
Inspired by Día de los Muertos, readers can create memorial tiers honoring loved ones with vintage photographs, favorite songs, traditional foods, voice memos, and a Constellation Mode that maps memories into interconnected star nodes.
The Ghost Terminal:
Readers can interact with the archive through an amber-green CRT terminal using safe commands (summon, whisper , memories, status) to receive ethereal responses directly from the model.
Local-First Privacy ("Zero Remote Surrender"):
All written memories, letters, and voice memos are stored in the reader's browser sandboxed IndexedDB vault. Readers can back up or export their entire memory archive to standard JSON at any time.

https://github.com/Sambhav-17/DEV-4-Challenge

That’s a strong open-source story. Here is the full post, ready to paste into dev.to. Only the demo link, agent session, and prize categories are left for you to fill in.

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

What I Built

AFTERLIGHT: Stories Beyond the Veil is a local-first haunted sanctuary where open-weight AI writes ghost stories about love, memory, and unfinished promises instead of cheap scares.

I took “Ghost in the Machine” literally. The ghost is a language model running on your own hardware, and the machine is a 3D world built to hold your memories. Readers can:

Summon cinematic ghost stories. Pick a mood, a setting (an abandoned observatory, a fog-drenched lighthouse), the pacing, and the tone of the ending. Then add a real inspiration, such as an antique key, an old melody, or a family heirloom. The model writes in the spirit of Shirley Jackson, Edgar Allan Poe, and Guillermo del Toro. Stories can be exported as Markdown, copied, or kept in the archive.
Explore the 3D Veil Garden. This is a real-time Three.js sanctuary with an ancient megalithic gate and floating spectral orbs. You can light memorial beeswax candles with your own dedication messages, and they persist in 3D space.
Build an Ofrenda of Remembrance. Inspired by Día de los Muertos, readers create memorial tiers for loved ones with photographs, songs, foods, and voice memos. A Constellation Mode maps those memories into connected star nodes.
Talk to the Ghost Terminal. It is an amber-green CRT interface with safe commands (summon, whisper , memories, status) that returns ethereal replies straight from the model.

The idea behind it: grief and memory are some of the most private things a person has, so the AI that touches them shouldn’t send them to someone else’s server.

Sambhav-17 / DEV-4-Challenge

DEV4

AFTERLIGHT — Stories Beyond The Veil

“Some things deserve to live forever.”
Hacktoberfest 2026 Open-Source AI Challenge Week 4: “Ghost in the Machine”

AFTERLIGHT is an immersive 3D digital remembrance experience where human memories become light, stories awaken, and open-weight AI preserves heritage without requiring users to surrender their most private moments to remote cloud monopolies.

✦ System Architecture

USER INTERFACE (React + Three.js + Web Audio)
       │
       ▼
LOCAL-FIRST VAULT (Client-Side IndexedDB)
       │
       ▼
MODEL ADAPTER (/api/ai/generate & /api/status)
       │
       ▼
LOCAL INFERENCE ENGINE (Ollama / vLLM / LM Studio)
       │
       ▼
OPEN-WEIGHT LANGUAGE MODEL (Qwen 2.5 7B / Mistral 7B)

✦ Core Features

The Veil Gate (3D Memorial Garden)
- Real-time Three.js WebGL environment featuring the ancient megalithic Veil Gate.
- Floating translucent spectral orb responsive to cursor proximity.
- Instanced procedural drifting particles and golden marigold pollen.
- Flickering beeswax candles and reflective slate stone floor.
- Procedural Web Audio API soundscape…

View on GitHub

How I Built It

Stack: React + Vite for the app, Three.js (WebGL) for the Veil Garden and the haunted-gate entrance, and IndexedDB for the memory vault.

Open-weight models. The default storyteller is Qwen 2.5 (7B Instruct) under Apache 2.0, chosen for its emotional resonance and atmospheric dialogue. Readers can switch models in the in-app AI Lab:

Model License Why it’s there
Qwen 2.5 7B Instruct (default) Apache 2.0 Literary sensitivity, multilingual, atmospheric
Mistral 7B Instruct v0.3 Apache 2.0 Coherent pacing, sliding-window attention
DeepSeek R1 Distill 8B MIT Intricate plots and philosophical depth
Llama 3.2 3B Open weights Compact inference for low-spec laptops
Phi-3.5 Mini 3.8B MIT Lightweight, high-context reasoning

Inference runtime. Models run through Ollama (localhost:11434) or any OpenAI-compatible runtime, so stories are generated on the reader’s own machine.

A three-layer fallback, so the experience never breaks:

Local models via Ollama are the primary path.
Gemini Flash (@google/genai) is a server-side fallback used only for cloud previews and demos, or for machines without enough GPU VRAM.
Veil Archive Sanctuary is a built-in procedural story generator that keeps the site readable even when every inference backend is offline.

Local-first privacy (“Zero Remote Surrender”). Memories, letters, and voice memos live in the browser’s sandboxed IndexedDB vault. Readers can export the whole archive to standard JSON whenever they like.

Why Does Open Innovation Matter?

A memorial site is about the most sensitive thing you can ask an AI to touch. People write letters to the dead, upload photos of loved ones, and record voice memos. With a closed API, all of that would have to travel to a third party’s servers.

Open-weight models changed what I could build:

Privacy by architecture. Because Qwen, Mistral, and the others run locally through Ollama, nothing a reader writes has to leave their device.
Choice. The AI Lab lets readers pick the model that suits their taste or their hardware, from a 3B model on a modest laptop to an 8B reasoning model. A closed API would have chosen for them.
Resilience. The site still works offline and doesn’t depend on a vendor’s pricing, rate limits, or deprecations. A story archive should outlast a company’s roadmap.
Remixability. Anyone can fork the repo, swap in a model, or add new ghosts.

The cloud fallback exists only so people without a GPU can still step through the gate. It is the exception and not the architecture.

My Agent Session

[

LazyFlow AI — Let AI Handle the Repetitive Work

Sambhav Bohra — Tue, 20 Oct 2026 19:45:17 +0000

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

What I Built

I built LazyFlow AI, a project focused on making everyday digital tasks simpler, smarter, and less time-consuming with the help of artificial intelligence.

The idea behind LazyFlow AI is simple: people spend too much time on repetitive tasks that could be completed more efficiently with the right AI-powered tools. Whether it is organizing information, simplifying workflows, or helping users get things done with less manual effort, AI can make technology more accessible and productive.

LazyFlow AI aims to reduce unnecessary effort so students, developers, creators, and everyday users can spend less time on repetitive work and more time learning, building, and creating.

Instead of treating AI as just another chatbot, the goal is to build a useful experience around AI that helps people accomplish tasks more efficiently.

Demo

🌐 Live Website: [Add your deployed website URL here]

🎥 Video Demo: [Add your demo video link here, if available]

The demo showcases the website's interface and the experience users get when interacting with the project.

Code

💻 GitHub Repository: [Add your GitHub repository URL here]

The source code will allow other developers to explore the implementation, understand how the project works, contribute improvements, and build upon the idea.

I believe open-source projects become more valuable when developers can learn from them, experiment with them, and contribute their own ideas.

How I Built It

I built LazyFlow AI with the goal of combining a user-friendly web experience with open-source artificial intelligence.

The project brings together a web interface, application logic, and an AI component to create a more efficient way for users to interact with AI-powered functionality.

The main development process involved:

Frontend: Building a clear and accessible user interface for interacting with the application.

Application logic: Connecting the user interface to the functionality needed to process user requests.

AI integration: Using an open-source or open-weight AI model to power the project's core functionality.

User experience: Keeping the interaction straightforward so users can focus on their tasks instead of dealing with unnecessary complexity.

Deployment: Making the application accessible through a web-based interface.

Open-source AI used: [Insert the actual model or framework, such as an open-weight model, Ollama, or another project dependency.]

The AI model and framework are important parts of the project because the goal is to build on openly available technology rather than depend entirely on a proprietary AI service.

Why Does Open Innovation Matter?

Open innovation matters because AI should not be limited to people and organizations that can afford expensive APIs or proprietary infrastructure.

Building with open-source AI creates opportunities for developers to experiment, learn, customize models, and build applications that meet their own needs.

For LazyFlow AI, open innovation represents three important principles:

More control over technology

Open models and tools can give developers greater control over how their applications work. Depending on the model and deployment setup, developers may also be able to run inference locally and keep sensitive information on their own devices.

Freedom to experiment and improve

Open-source ecosystems make it easier to explore different models, customize implementations, inspect code, and improve a project as new ideas emerge.

AI that more people can build with

Students, independent developers, and small teams should have the opportunity to create useful AI applications without needing access to expensive proprietary infrastructure.

I believe open innovation is about more than making code available. It is about giving people the freedom to understand, modify, and improve the technology they use.

By building LazyFlow AI around open AI technology, I want to explore how accessible AI can make everyday digital work more efficient while giving developers the freedom to keep experimenting.

My Agent Session

[Add your DevRelay agent session link here, if available.]

This section can document the development process, including how an AI coding agent helped explore ideas, implement features, troubleshoot issues, or improve the application.

Sharing an agent session can also help other developers understand the decisions and experiments behind the project.

The Lazy Payoff

The real goal of LazyFlow AI is to reduce the amount of effort required to complete everyday digital tasks.

Instead of spending unnecessary time on repetitive work, users should be able to focus on activities that require creativity, learning, and human judgment.

The potential benefits include:

Less repetitive manual work.

A simpler experience for interacting with AI.

More time for learning, development, and creative projects.

An opportunity for developers to experiment with open AI technology.

The long-term vision is simple: make technology work harder so people don't have to.

The project is an exploration of how open-source AI can make useful tools more accessible and practical.

Prize Categories

Challenge: Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady

Partner categories: [Add the applicable partner categories listed on the official challenge page, or remove this section if none apply.]

Final Thoughts

LazyFlow AI is built around a simple belief: useful AI should help people spend less time on repetitive work and more time doing what matters.

Through this project, I want to explore the possibilities of open-source AI, learn by building, and contribute to an ecosystem where developers can create, share, and improve technology together.

Open innovation makes that possible by giving builders the freedom to experiment beyond the limitations of closed systems.

Build openly. Automate thoughtfully. Spend your time on what matters. 🚀

dev-3-two.vercel.app

HustleAI Studio: Helping My Artisan Friend Automate Her Etsy Hustle with Open-Source AI

Sambhav Bohra — Sun, 18 Oct 2026 16:47:39 +0000

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

What I Built

I built HustleAI Studio for my friend Sarah, a solo ceramic artist and maker who runs Terra & Tallow Handmade Goods.

Sarah crafts wheel-thrown mugs, matcha bowls, and stoneware planters from her small studio, selling them on Etsy, Shopify, and local weekend markets. While she loves throwing clay, she dreads the exhausting "business admin" that follows every collection drop:

Writing Listings: Spending hours formulating 140-character SEO titles, 13 exact Etsy tags, and bulleted specifications for 30+ unique pieces every weekend.
Shoebox of Receipts: Dreading tax season because shipping slips, kiln element invoices, and glaze receipts were scattered across paper bags and photos.
Marketing Burnout: Staring at a blank screen trying to come up with catchy Instagram hooks, newsletters, and promotional captions.
Subscription Fatigue: Paying $20–$40/month for proprietary SaaS tools and closed AI writing apps was directly eating into her modest handmade margins.

HustleAI Studio is an all-in-one, privacy-first productivity suite built to automate those repetitive small business tasks using open-weight AI models:

AI Listing Writer: Generates marketplace-compliant titles, descriptions, and 13-tag clusters tailored specifically to Etsy, eBay, and Shopify algorithms with 1-click export to TXT and CSV.
Invoice & Receipt Organizer: Turns snapshots of paper receipts into structured, categorized expense ledgers with tax calculations, uncertain-field verification, and CSV exports for bookkeeping.
Marketing Studio: Drafts platform-specific Instagram captions, promotional email blasts, and split-test hooks.
Smart Translator: Localizes product descriptions and cafe menus into Spanish, French, German, Hindi, and Japanese while strictly preserving measurements (e.g., 14oz (415ml)) and brand trademarks.

Demo

🔗 Live Application: https://hustleaistudio-sigma.vercel.app/

(You can explore the interactive landing page, launch the studio workspace directly, test the pre-loaded artisan presets, scan sample receipts, and experiment with the open-weight model switcher.)

Code

🔗 GitHub Repository: https://github.com/Sambhav-17/HustleAIStudio

How I Built It

HustleAI Studio is architected around an interchangeable, open-weight AI provider system:

1. Open-Source AI Architecture

Local Inference with Ollama: Integrates directly with Ollama's REST API (http://localhost:11434) running compact, highly efficient open-weight models:
- Qwen 2.5 (3B / 7B): Chosen for its exceptional structured JSON adherence, e-commerce categorization, and multi-language translation capabilities.
- Llama 3.2 (3B): Powers creative copy generation, tone modulation, and engagement hooks in the Marketing Studio.
Live Model Diagnostics: Built-in connection prober tests local model health, reports round-trip latency (ms), and detects all downloaded weights on the user's host.
Hybrid Cloud Fallback: For users on machines without a GPU or when away from their primary workstation, the server provides an accelerated fallback powered by @google/genai (gemini-3.8-flash) with multimodal vision OCR.
Strict Privacy Controls: Users can toggle between Air-Gapped / Strictly Local (guaranteeing zero outbound data transfer), Hybrid Safe Mode, and Cloud Accelerated.

2. Full-Stack Implementation

Frontend: Built with React 19, TypeScript, Vite, and styled with Tailwind CSS. It follows high-density SaaS design principles: tabular numerals (tabular-nums) to avoid layout jitter, zero-pill metadata discipline, and full light/dark mode support.
Backend: Express with modular API endpoints for structured output validation, persistent document stores with /tmp serverless compatibility, and streaming CSV generators.
Deployment: Seamlessly configured for Vercel with dedicated Serverless Functions in /api and optimized npm peer-dependency resolution.

Why Does Open Innovation Matter?

For solo founders, freelancers, and indie makers like Sarah, open innovation is a game-changer for two fundamental reasons:

Eliminating the Micro-Business Tax:
Closed proprietary AI APIs charge recurring monthly fees and per-token meter rates that penalize creators generating hundreds of long-tail listings or scanning daily postage receipts. Open-weight models like Qwen 2.5 and Llama 3.2 run locally on a standard MacBook Air at $0 marginal cost, democratizing enterprise-grade productivity for indie hustlers.
Total Data Sovereignty & Commercial Confidentiality:
Business invoices, supplier negotiations, wholesale pricing, and unreleased product sketches are sensitive commercial assets. By executing inference locally through Ollama, Sarah’s financial receipts and customer delivery slips never leak into third-party training corpuses or external corporate clouds.

Open source gave us the freedom to build a tool that Sarah truly owns forever.

My Agent Session

Built collaboratively using Google AI Studio Build with full-stack agent orchestration, automated Vercel deployment resolution, and end-to-end TypeScript verification.

Prize Categories

Hacktoberfest: Build for a Friend
Open-Source AI Challenge: Week 2 — Side Hustle
Best Use of Open-Weight Models & Local Inference

🌱 Touch Grass — Hacktoberfest Open-Source AI Challenge

Sambhav Bohra — Thu, 08 Oct 2026 17:56:21 +0000

What I Built

I built Touch Grass, a web application designed to encourage people to step away from their screens and spend more time in the real world.

The idea is simple: instead of spending all our free time scrolling, gaming, or sitting in front of a screen, the app encourages users to take small, meaningful breaks and actually touch grass 🌱.

The project is aimed at students, developers, remote workers, and anyone who spends a lot of time online.

The goal isn't to completely eliminate screen time. It's to create a healthier balance between the digital world and real-world activities.🌱 Touch Grass — Hacktoberfest Open-Source AI Challenge

Demo

🚀 Live Demo:

You can try the project directly through the deployed application and experience the idea behind the challenge.

Code

The project is open source and available on GitHub:

GitHub Repository: [ADD YOUR GITHUB REPOSITORY LINK HERE]

I built the project with the goal of keeping it simple, accessible, and easy for other developers to contribute to and improve.

How I Built It

Touch Grass is a web-based application built around the idea of using technology to encourage people to spend less time using technology.

The project uses modern web development tools to create an interactive experience where users can discover and take part in activities away from their screens.

For the AI component, I explored open-source AI tools/models as part of the development process rather than relying entirely on a closed AI API.

The overall workflow is:

User → Web App → AI-powered experience → Real-world activity → Less screen time 🌱

The most important part of the project is that AI isn't the final destination. It acts as a tool to help the user move from the digital environment into a real-world activity.

Why Does Open Innovation Matter?

Open innovation matters because developers should be able to experiment, learn, modify, and build on technology without being locked into a single closed platform.

Using open-source AI makes it possible to understand more about how the technology works, experiment with different models and tools, and adapt the experience to the needs of the project.

For a project like Touch Grass, this is especially important because the goal is not simply to build another AI application that keeps people online.

Instead, open technology helped me explore how AI can be used in a way that ultimately encourages people to close the laptop, leave the room, and interact with the real world.

That's the idea behind Touch Grass. 🌱

My Agent Session

I used an AI-assisted development workflow while building this project.

Agent Session: [ADD YOUR DEVRELAY AGENT SESSION LINK HERE]

This session shows how AI-assisted development contributed to the project.

Prize Categories

Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass

Open Innovation / Open-Source AI

Final Thoughts

Building Touch Grass was a fun experiment in thinking about what AI applications should actually accomplish.

AI is becoming increasingly good at keeping us engaged with screens. I wanted to explore the opposite idea:

What if we use technology to help people spend more time away from technology?

Sometimes the best interaction with an app is knowing when to close it.

🌱 Touch Grass.