DEV Community: Hulesh Sahu

GhostWriter — An Offline AI-Powered Ghost Story Generator

Hulesh Sahu — Tue, 27 Oct 2026 07:47:03 +0000

What if your computer could tell you a ghost story without connecting to the internet?

For this challenge, I explored the idea of GhostWriter, a local AI-powered storytelling tool that generates spooky, atmospheric stories using open-weight language models.

The idea was inspired by the mysterious atmosphere of Halloween and the tradition of remembering the past during Día de los Muertos. Stories have always helped us preserve memories, explore our fears, and imagine worlds beyond our own.

GhostWriter brings that spirit into the world of AI. Users can provide a setting, a character, or a simple idea, and the AI transforms it into an eerie short story filled with suspense, unexpected twists, and supernatural elements.

The goal is simple: make creative AI more private, accessible, customizable, and independent of cloud services.

Demo

🚧 Demo coming soon!

Add your deployed application link, screenshots, or a short video demonstration here.

The demo will showcase how a simple prompt can become a chilling story generated with the help of open-source AI.

Code

🔗 GitHub Repository: [Add your repository link here]

The repository will contain the project source code, setup instructions, and details about running the application locally.

How I Built It

GhostWriter is designed around the idea that AI storytelling should not depend entirely on a remote API.

The project uses an open-weight language model as its storytelling engine, allowing the generation process to run locally when supported by the selected model and hardware.

The core workflow is straightforward:

Prompt input: The user enters a theme, setting, character, or story idea.

Prompt engineering: The application shapes the input into instructions for generating an atmospheric and coherent story.

Local inference: An open-weight model generates the story on the user's machine.

Story output: The generated narrative is presented to the user, ready to read, save, or refine.

Technology Stack

AI model: An open-weight language model compatible with local inference.

Inference runtime: A local model runner such as Ollama (if used in your implementation).

Application: Add your actual frontend and backend technologies here.

Development: Git and GitHub for version control and sharing the project.

The focus is not simply on using AI to generate text. It is on building an experience where the model can be inspected, replaced, customized, and run under the user's control.

Why Does Open Innovation Matter?

This is the most important part of the project.

AI becomes much more interesting when developers can experiment beyond the boundaries of a closed API.

Privacy Comes First

Creative prompts can contain personal experiences, family memories, or ideas that users are not comfortable sharing with an external service.

With local inference, prompts and generated stories can remain on the user's device, provided the application is configured without external data transmission.

No Mandatory Cloud Dependency

A locally running model can generate stories without an internet connection after the model and required dependencies have been downloaded.

That means the experience can remain available even when connectivity is unreliable or unavailable.

Freedom to Experiment

Open-weight models give developers the flexibility to experiment with different model families, prompts, inference settings, and generation strategies.

Instead of being tied to a single provider's API, GhostWriter can evolve as better models and tools become available.

More Control Over Costs

Local inference can reduce recurring API expenses, especially for repeated experimentation and personal use. The trade-off is that users need suitable hardware and must account for electricity, memory, and setup costs.

For a small creative project, that freedom to experiment without paying for every generation can be valuable.

A Project That Can Outlive a Service

Cloud APIs can change their pricing, impose usage limits, or become unavailable. A project built around replaceable models and local tools has more flexibility to adapt.

Open innovation matters because it gives developers ownership over the tools they build with—not just access to someone else's service.

My Agent Session

If an AI coding agent was used during development, add your DevRelay session here.

🔗 Agent Session: [Add your DevRelay session link here]

This section is optional, but sharing the development process can help others understand how the project evolved, which decisions were made, and what challenges came up along the way.

The Spirit of It

Halloween invites us to imagine what might be hiding in the dark. Día de los Muertos reminds us that memories and stories help keep the people and experiences we cherish alive.

GhostWriter sits somewhere between those two ideas.

It uses modern AI to explore an ancient human tradition: telling stories.

A few words can become a haunted house, a forgotten village, or a mysterious voice echoing through an abandoned terminal. The technology is modern, but the feeling is familiar.

And perhaps that is the real ghost in the machine—not a supernatural presence, but the stories, memories, and imagination we bring to it.

Prize Categories

Add the partner prize categories that genuinely apply to your implementation, based on the official challenge rules.

Final Thoughts

Building with open-source AI is about more than choosing a different model. It is about exploring what becomes possible when developers have greater control over their tools.

With GhostWriter, the goal is to combine creative storytelling with local AI, privacy, and freedom to experiment.

The future of AI does not have to live entirely in the cloud. Sometimes, the most interesting ideas emerge when we bring the intelligence back to our own machines.

👻 Have a spooky story idea? Give it a prompt and see what comes out of the machine.

Hacktoberfest #OpenSourceAI #DevChallenge #GhostInTheMachine

LazyDesk: An Offline AI Assistant That Handles the Boring Stuff

Hulesh Sahu — Fri, 23 Oct 2026 09:59:51 +0000

What I Built

Meet LazyDesk — a local-first AI assistant designed to take care of the little digital chores that eat away at our time.

We all have tasks we keep postponing: organizing messy notes, summarizing long documents, extracting action items from meeting notes, and turning scattered thoughts into something useful.

LazyDesk aims to make those tasks effortless. Instead of manually reading, sorting, and rewriting everything, users can give the assistant a task and let a locally running AI model do the heavy lifting.

The goal is simple: spend less time managing information and more time doing what actually matters.

Demo

Live Demo: [Add your demo link here]

Video Demo: [Add your screen recording here]

The demo will showcase how LazyDesk processes everyday tasks using an open-weight model.

Code

GitHub Repository: [Add your GitHub repository link here]

The project is designed around a simple principle: your assistant should work for you, not create another service you need to manage.

How I Built It

LazyDesk is built around the idea of running AI locally instead of depending entirely on remote APIs.

The planned technology stack includes:

Open-weight LLM: A model such as Qwen or Llama, selected according to available hardware and licensing requirements.

Local inference: Ollama to run the model on a personal computer.

Application layer: A lightweight interface for submitting tasks and viewing results.

Task workflows: Focused prompts for summarization, note organization, and action-item extraction.

The workflow is straightforward:

The user provides text or a document.

The application sends the content to the locally running model.

The model processes the information and generates a useful result.

The user reviews the output and decides what to keep.

The aim is to keep the system lightweight, understandable, and easy to adapt instead of building an unnecessarily complicated agent.

Implementation note: Update this section to reflect the model, framework, and features actually used in your working project.

Why Does Open Innovation Matter?

For a project like LazyDesk, open innovation is not just a technical preference. It changes who controls the assistant and how it can be used.

Privacy by design

When inference runs locally, personal notes and documents can stay on the user's machine rather than being sent to a third-party AI API. This depends on the application being configured so that data is not transmitted elsewhere.

Freedom to experiment

Open-weight models make it possible to compare different models, customize prompts, experiment with fine-tuning where supported, and adapt the assistant to specific workflows.

Less dependence on paid APIs

After downloading the model, local inference can avoid per-request API charges. Hardware, electricity, storage, and maintenance still have costs, but there is no mandatory hosted-model fee for each task.

More control over the experience

The application can be modified to change how tasks are processed, what information is retained, and how results are presented. Developers are not limited to the features and policies of a single hosted API.

Resilience without a constant internet connection

Once the model and required dependencies are installed, supported workflows can run offline. That makes the assistant useful even when connectivity is unreliable.

For this project, the biggest advantage is control: control over the data, the model, the workflow, and the future direction of the tool.

My Agent Session

This section can show the development process, including the decisions made while building the project and the experiments used to improve its workflow.

The Lazy Payoff

The best automation is the kind you set up once and benefit from repeatedly.

Imagine turning a long document into a concise summary in seconds, extracting action items without rereading an entire meeting transcript, or cleaning up a collection of notes without manually rewriting each one.

LazyDesk is built around that idea: fewer repetitive steps, less context switching, and more time for meaningful work.

The goal isn't to eliminate human judgment. It's to eliminate the busywork that gets in the way of it.

Once the project is tested, this section can include real measurements, such as average processing time, tasks completed, or minutes saved per week.

Prize Categories

Open-source AI

Local AI and open-weight models

Update these categories to match the challenge's official partner categories and the ones your project qualifies for.

Built with the belief that AI should give people more freedom, not another subscription to manage.

Move slowly. Automate the boring stuff. Keep your time for yourself. 🦥

LocalLedger AI

Hulesh Sahu — Thu, 15 Oct 2026 16:38:30 +0000

Meet LocalLedger AI — a privacy-first invoice and receipt organizer designed for freelancers, independent developers, consultants, and small business owners.

Managing invoices and receipts sounds simple until files start piling up. PDFs end up in random folders, receipt names make no sense, and finding a particular expense becomes a tedious task.

LocalLedger AI aims to make that workflow easier.

Users can upload invoices and receipts, extract useful information, and organize documents by vendor, date, amount, and category. The AI helps identify important details and produces structured records that are easier to review and export.

The goal is simple: spend less time managing paperwork and more time doing paid work.

Who would pay for it?

Freelancers who want to keep their financial documents organized.

Consultants who manage expenses across multiple clients.

Small businesses that need a lightweight alternative to complicated accounting software.

The business model could be a one-time purchase for the desktop app, with paid upgrades for additional workflows and integrations.

Demo

Demo: [Add your live demo link here]

A short demo should show the complete workflow:

Import a sample invoice or receipt.

Let the AI extract the vendor, date, total, and other relevant fields.

Review and correct the extracted information.

Export the organized records to CSV.

Note: Add a working demo or screen recording once the prototype is ready.

Code

GitHub repository: [Add your repository link here]

The project is intended to be open source, so users can inspect how their documents are processed, customize the workflow, and contribute improvements.

How I Built It

The core design revolves around local AI inference rather than depending entirely on a paid, hosted model API.

The planned stack includes:

Python for document processing and application logic.

Ollama for running compatible open-weight language models locally.

Qwen or another suitable open-weight model for extracting and normalizing invoice information.

Pydantic for validating extracted data against a predictable schema.

SQLite for storing document metadata locally.

Streamlit for a simple interface to import, review, and export records.

The workflow is straightforward:

A user imports a document.

Text is extracted from supported PDFs or images using suitable document-processing tools.

The local model identifies the relevant fields and returns structured data.

The application validates the output and flags missing or uncertain values.

The user reviews the result before saving or exporting it.

The important design decision is that the model is a replaceable component. Different open-weight models can be tested against real invoice examples without redesigning the entire application.

This section describes the intended implementation. Update the stack and workflow to reflect the components actually used in your working build.

Why Does Open Innovation Matter?

For this project, open innovation isn't just a technical preference. It directly affects whether the product makes sense for its intended users.

Financial documents deserve privacy.

Invoices and receipts can contain addresses, client details, tax identifiers, and business expenses. Local inference can keep document contents on the user's machine instead of requiring every document to be sent to a third-party AI service.

Predictable costs make a small product viable.

A freelancer might process hundreds of documents without generating enough revenue to justify recurring API charges. With compatible hardware, local inference can avoid per-document model API fees, although hardware, electricity, and maintenance still have costs.

No single model provider controls the product.

If a model becomes too slow, produces inconsistent results, or no longer fits the project's needs, the underlying model can be replaced with another compatible option.

Specialized workflows can improve over time.

Invoice formats vary by country, vendor, and industry. An open approach makes it easier to experiment with prompts, validation rules, specialized models, and eventually fine-tuning where the model license and available data permit it.

The application can work offline.

Once the application, required models, and dependencies are installed, a suitable local setup can process documents without an internet connection. This is particularly useful for people who want control over their data or have unreliable connectivity.

A hosted AI API might be easier to set up and may outperform a small local model on some tasks. But for a tool handling sensitive financial documents, local control, replaceable models, and reduced usage-based costs can be more valuable than outsourcing every decision to a closed service.

That's the advantage I want to explore: making useful AI accessible without making a user's private documents dependent on someone else's infrastructure.

My Agent Session

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

I plan to document the development process, including model selection, extraction failures, validation improvements, and the decisions involved in making local inference practical.

My First User

The first target user is a freelancer who regularly receives invoices and needs a faster way to organize financial records.

The initial validation goal is to ask them to process a small batch of real-world documents, with sensitive information removed where appropriate, and measure:

How many fields are extracted correctly.

How much manual correction is still required.

How long processing takes compared with their current workflow.

Whether they would pay for a local-first tool that saves them time.

I will update this section with actual user feedback and payment results after testing the prototype.

Prize Categories

[Add the applicable partner prize categories after checking the challenge rules.]

The goal of LocalLedger AI is not to build another general-purpose chatbot. It is to build a small, useful product around open AI technology that solves a recurring problem, respects user privacy, and could become a sustainable side hustle.

Open models give the project room to experiment, improve, and remain under the user's control. That's what makes this worth building.

Touch Grass, Not Your Screen: Building an Offline AI Bird Identifier with Open-Source AI

Hulesh Sahu — Sun, 11 Oct 2026 12:05:33 +0000

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

What I Built

Birds in the Wild is a local-first AI bird identifier designed to make outdoor adventures more interactive and educational.

Imagine hiking through a forest, hearing an unfamiliar bird call, and wanting to know which bird is singing. Instead of opening multiple websites or scrolling through social media, you can use this tool to identify bird sounds and learn more about the wildlife around you.

The goal is simple: spend less time looking at a screen and more time observing nature.

The project is designed around three principles:

🐦 Explore: Help hikers, birdwatchers, and curious nature lovers identify birds.
🌿 Disconnect: Make identification possible without depending on a constant internet connection.
🔓 Own your experience: Keep the AI experience transparent, customizable, and privacy-friendly.

Demo

🚧 Demo coming soon!

I'll share a demonstration of the application identifying bird calls during an outdoor walk.

[Add your live demo link or video here.]

Code

💻 The project is built with open-source technology, and the source code will be available on GitHub.

[Add your GitHub repository link here.]

Contributions, suggestions, and improvements are welcome!

How I Built It

The core idea is to make open-source AI an essential part of the application rather than simply connecting to a hosted AI API.

The planned architecture includes:

Open-weight AI: A suitable open-weight audio classification model to recognize bird calls.
Local inference: Run supported inference directly on the user's device, reducing dependence on remote servers.
Open-source tooling: Use community-maintained libraries and frameworks for audio processing and model integration.
Nature-friendly UX: Keep the workflow simple: listen, identify, learn, and get back to exploring.

The focus is on making the AI useful in real-world conditions, especially in places where mobile connectivity is unreliable.

Why Does Open Innovation Matter?

For an outdoor AI tool, open innovation isn't just a technical preference. It can make the experience more practical.

1. Offline access matters

Nature doesn't always come with reliable Wi-Fi or mobile data. Local inference can help users identify bird calls in remote areas, provided the model and its dependencies are available on the device.

2. Privacy should be the default

Outdoor recordings can reveal more than just birds. Processing audio locally can avoid sending recordings to third-party servers.

3. Models should be replaceable

Bird species vary by region, and no single model will be perfect everywhere. Open model weights and flexible tooling make it easier to experiment with specialized models, evaluate accuracy, and improve regional coverage.

4. Experimentation shouldn't require an expensive API

Open-source tools let developers prototype, modify, and test ideas without making every inference request dependent on a paid service. Local hardware still has costs and limitations, but the approach can make experimentation more accessible.

5. The community can make it better

Birdwatchers, developers, and researchers can contribute regional datasets, improve classification, report mistakes, and adapt the project to new environments.

That's the value of open innovation: AI becomes something people can understand, adapt, and build upon—not just something they rent access to.

My Agent Session

Optional: I'll share my development session here if I use an AI coding agent and record the session with DevRelay.

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

Prize Categories

[Add the applicable partner prize categories from the challenge page.]

Final Thoughts

The best technology doesn't always demand more of our attention.

Sometimes, it helps us put the phone away, follow a sound through the trees, and notice something we might otherwise have missed.

That's what I want to explore with this project: using open-source AI to make the real world more interesting, accessible, and worth stepping into.

Build with open AI. Step outside. Touch grass. 🌱🐦

Digital Janitor

Hulesh Sahu — Sun, 04 Oct 2026 13:28:13 +0000

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

What I Built

I built Digital Janitor, a local-first AI tool that helps my friend organize their messy Downloads folder.

It uses AI to classify files, suggest folders, explain its decisions, and safely organize them without permanently deleting anything.

Demo

[ADD DEMO VIDEO LINK]

Code

[ADD GITHUB LINK]

How I Built It

Built with Python + Ollama + Gemma, running locally on Windows.

The AI analyzes file information locally and suggests how files should be organized. The project also includes safe file operations, demo mode, and a Mess Score.

Why Does Open Innovation Matter?

Personal files can contain sensitive information, so I didn't want to upload them to a cloud AI service.

With Ollama and an open-weight model, the AI can run locally, keeping the user's files on their own computer.

It also means I can change or upgrade the model without rebuilding the entire application around a closed API.

My Agent Session

[ADD DEVRELAY LINK IF AVAILABLE]

Prize Categories

Gemma — Best Use of Gemma

Gemma is used as the local AI intelligence behind Digital Janitor.