DEV Community: Prarthana Sharma

GhostMind AI: Bringing Spooky Stories to Life with Open-Source AI

Prarthana Sharma — Sat, 31 Oct 2026 15:48:54 +0000

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

What I Built

I built GhostMind AI, an AI-powered spooky storytelling project inspired by the theme "Ghost in the Machine."

The idea behind this project is to create an AI experience where users can explore mysterious stories, generate spooky conversations, and enjoy a little bit of Halloween atmosphere through technology.

I wanted to build something creative that combines artificial intelligence with the mysterious feeling of ghost stories.

Demo

I am currently working on the project and will share a demo once it is ready.

Code

GitHub Repository: https://github.com/prarthanas9917/ghostmind-ai

The source code is available in my GitHub repository.

How I Built It

I planned GhostMind AI around open-source AI so that the project can be developed with more flexibility and control.

My goal is to use an open-weight language model for generating spooky stories and responses. I also want to keep the project simple and beginner-friendly while exploring how AI can be used creatively.

The main focus is to make the AI experience more independent and customizable.

Why Does Open Innovation Matter?

I believe open innovation is important because it gives developers the freedom to experiment, learn, and build without depending completely on closed AI services.

Using open-source AI makes it possible to explore different models, customize the experience, and have more control over how the application works.

It also encourages students and beginners like me to understand how AI works behind the scenes instead of only using ready-made tools.

The Spirit of It

Halloween is a perfect time to explore mysterious ideas and bring imagination into technology.

With GhostMind AI, I wanted to create something that makes storytelling more interactive and gives traditional ghost stories a modern AI-powered experience.

This project is also a learning experience for me, as I continue exploring open-source AI and building creative applications.

Prize Categories

Open-Source AI Challenge

LazyDesk AI: A Local AI Assistant That Does the Planning for You

Prarthana Sharma — Sun, 25 Oct 2026 12:33:58 +0000

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

What I Built

I built LazyDesk AI, a local AI assistant that does the planning for you.

As a college student, I deal with assignments, notes and daily tasks all at once, and half the effort goes into just deciding what to do first. LazyDesk AI takes away that part. You give it your to do list and it turns it into a simple daily plan. You give it your notes and it shrinks them into short, useful points.

It is for anyone who would rather spend time getting things done than organizing them. That includes me.

Demo

LazyDesk AI runs locally on your own machine, so there is no hosted link. You can try it by cloning the repo below and following the setup steps in the README.

Code

prarthanas9917 / lazydesk-ai

LazyDesk AI

Less planning. More living. LazyDesk AI turns a messy task list into a realistic daily plan or condenses long notes into five useful bullets. It runs through Ollama with an open-weight model, so there is no hosted AI account or per-request API bill.

Run It Locally

Requirements: Python 3.10+ and Ollama.

git clone https://github.com/prarthanas9917/lazydesk-ai.git
cd lazydesk-ai
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
ollama pull llama3.2:1b
streamlit run app.py

Open the local URL printed by Streamlit. Ollama must be running on the same machine. Choose Smart Task Planner or Summarize Notes, paste your text, and select Make it easy. Results can be downloaded as text.

Configure

The sidebar lets you change the Ollama URL and model. Defaults are http://localhost:11434 and llama3.2:1b. You can also set defaults before starting the app:

export OLLAMA_BASE_URL=http://localhost:11434
export OLLAMA_MODEL=llama3.2:1b

For fully offline use, download the model…

View on GitHub

How I Built It

LazyDesk AI is written in [language and framework you used] and runs on [name of the open model or tool you used, for example Ollama with a specific model].

The app sends your tasks or notes to the local model with a prompt for each job. One prompt asks it to arrange tasks into a realistic plan for the day, and the other asks it to pull the key points out of long notes. Everything stays on your computer, so nothing you write leaves your machine.

Why Does Open Innovation Matter?

My tasks and notes are personal. They include coursework, deadlines and things I would not want to send to someone else's server. Because I could use an open model and run it locally, I did not have to worry about privacy, API keys or usage limits.

It also meant I could build this as a student with no budget. I could try ideas, break things and fix them without paying for every request. A closed API would have made this much harder to build and share.

The Lazy Payoff

Planning my day used to take me a good chunk of time every morning. With LazyDesk AI, I paste in my list and get a plan in a few seconds, and I can spend that time actually starting the work.

LazyDesk AI: A Local AI Assistant That Does the Planning for You

Prarthana Sharma — Sun, 25 Oct 2026 12:24:31 +0000

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

What I Built

I built LazyDesk AI, a simple AI productivity assistant that helps people save time on everyday tasks.

As a college student, managing assignments, notes, and daily tasks can sometimes feel overwhelming. I wanted to build something that could make planning easier and help me focus on the work that actually matters.

LazyDesk AI helps organize a to-do list into a daily plan and summarize notes into short, useful points.

The idea is simple: spend less time planning and more time getting things done.

Demo

I'm currently testing the application locally on my Ubuntu system. I'll add a demo video here once I finish testing all the features.

Code

GitHub Repository: https://github.com/prarthanas9917/lazydesk-ai

The project is built with Python and Streamlit, with Ollama providing local AI inference.

How I Built It

I used Python to build the application and Streamlit to create a simple, interactive interface.

For the AI part, I chose Ollama so I could experiment with open-weight models on my own computer. I'm working with the Llama 3.2 model to generate task plans and summarize notes.

I developed the project using VS Code on Ubuntu. Setting everything up and getting the local model working has been a learning experience, but that's part of building something new.

Why Does Open Innovation Matter?

For me, open-source AI means having more control over the tools I build.

By running a model locally, I can experiment without depending on a paid, hosted AI API. When local inference is configured correctly, my prompts can stay on my own computer instead of being sent to an external AI provider.

I can also try different models and change how the application works as I learn more.

That's what I like about open innovation: it gives developers the freedom to experiment, learn, and build without being locked into one service.

My Agent Session

I used AI coding assistance while developing LazyDesk AI, especially for improving the code and troubleshooting issues.

I haven't added a DevRelay session yet.

The Lazy Payoff

The goal of LazyDesk AI is to make everyday planning less tiring.

Instead of spending time figuring out where to start, users can enter their tasks and get a suggested plan. They can also turn long notes into shorter summaries.

I'm still testing and improving the application, and I hope to add more features as I learn.

Sometimes, being productive isn't about doing more. It's about making things simpler.

Prize Categories

Open-Source AI

Thanks for checking out my project. I'm excited to keep learning and improving LazyDesk AI.

InvoiceMate AI: a private expense organizer that runs on a local open model

Prarthana Sharma — Sun, 18 Oct 2026 13:01:45 +0000

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

What I Built

InvoiceMate AI is a small expense organizer for freelancers and tiny businesses. If you have a pile of invoices and receipts and your accountant keeps asking for a clean spreadsheet, this is for you.

You upload a PDF or a text file, or just paste the invoice text. A local AI model reads it and pulls out the vendor, date, amount, category and a short description. You check the result in an editable form, fix anything that is wrong, and save it. Everything then shows up on a dashboard with a running total, a table of saved expenses, a spend by category chart, and a CSV download you can hand to your accountant.

The people who would pay for something like this are the ones who do their own bookkeeping and dread it at tax time. Invoices also contain client names and amounts, and a lot of people are not comfortable sending those to a hosted AI service. This keeps everything on your own computer.

Demo

The app runs locally on your machine, so there is no hosted link to click. The README in the repo has screenshots of each step: pasting an invoice, the extracted details ready for review, and the expense dashboard.

The flow is simple. Paste an invoice, click extract, review the fields, save, and open the dashboard to see your totals and download the CSV.

Code

prarthanas9917 / invoicemate-ai

InvoiceMate AI

InvoiceMate AI helps freelancers and small businesses turn invoice or receipt text into editable expense records. Review the extracted vendor, date, amount category, and description, then view totals and export the records as CSV.

Why local AI?

Invoice text can contain client names, addresses, and transaction details. InvoiceMate sends the text only to Ollama at localhost, not to a hosted AI API. Once the model has been downloaded, inference can run without an internet connection. You can swap the model in invoice_utils.py without changing the expense review and export flow.

This is an early MVP, not a secure accounting system. Expenses are held only in Streamlit's current browser session; they are not saved to disk. Do not deploy this app to a server if your goal is to keep documents on your own computer. The current PDF reader supports selectable text, not scanned-image OCR. Always verify AI…

View on GitHub

How I Built It

The interface is built with Streamlit. The AI part runs through Ollama using the open weight Qwen 2.5 3B model, so there is no API key and no hosted AI service involved. The app sends the invoice text to the model running on localhost and asks for structured fields back.

The rest is plain Python. pypdf reads text from PDF files, pandas handles the expense table, totals and CSV export, and requests talks to the local Ollama endpoint.

I kept a review step on purpose. A 3 billion parameter model is good enough to fill in most fields correctly, but it will sometimes get a date or a category wrong, so nothing is saved until a person has looked at it. The repo also has a small set of tests.

My first real run failed with a 404 from Ollama. I had pulled a different model than the one the app was asking for. Pulling the right one fixed it, and it reminded me to make the model requirement clear in the README.

Current limits, to be upfront about them: PDFs must contain selectable text because scanned images are not supported yet, and saved expenses only live in the browser session, so they are cleared when the session ends.

Why Does Open Innovation Matter?

For an app that handles financial documents, privacy is the whole point. Because the model is open weight and runs locally, the invoice text never leaves the computer. A closed API would have meant sending client names and amounts to someone else's server.

It also changes the cost. There is no charge per invoice, so a freelancer can process as many documents as they like without a bill growing in the background. And since Ollama serves models through the same local endpoint, trying a different model mostly comes down to changing the model name.

TrailBuddy: less scrolling, more fresh air

Prarthana Sharma — Sun, 11 Oct 2026 09:10:29 +0000

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

What I Built

I had a simple idea for this challenge: if I have a free hour and want to get outside, why does deciding what to do sometimes take longer than the walk?

TrailBuddy is a small web app that fixes that. You tell it where you are (even just "nearby"), how much time you have, and what you feel like doing, such as birds, a run, gardening or a slow walk. It gives you three outdoor ideas that fit your hour. Then you close the tab and go.

It is made for students, busy people, and anyone who keeps meaning to go outside but loses the time to scrolling.

Demo

TrailBuddy runs locally on your own machine, so there is no hosted link.

[Add your screenshots or a short screen recording here]

Code

prarthanas9917 / trailbuddy-ai

TrailBuddy

TrailBuddy turns a little free time into a reason to step outside. Share a neighborhood, your mood, and how long you have; it suggests three low-fuss activities and what to bring. Pick one, put the phone away, and go.

Built for the Hacktoberfest Week 1 “Touch Grass” challenge. Read the DEV post.

Why open AI?

TrailBuddy uses Qwen 2.5 3B through Ollama, so suggestions are generated on your own device instead of being sent to a hosted AI service. The model can be swapped with the TRAILBUDDY_MODEL setting, and its prompt is part of the source code. That keeps the experience inspectable and adaptable, with no API key or per-request AI bill.

After Python packages and the model have been downloaded, the app and model can run without an internet connection. If Ollama is not installed or running TrailBuddy clearly switches to a small set of built-in…

View on GitHub

How I Built It

Backend: FastAPI (Python)
Frontend: plain HTML, CSS and JavaScript, with a simple form and result cards
Open model: Qwen 2.5 (3B) running locally through Ollama
Offline fallback: if Ollama is not running, the app shows a set of built in ideas instead of failing, and labels them "Offline ideas"

When you press Find my outside hour, the app builds a short prompt from your location, time and mood, sends it to the local model, and asks for the answer as JSON. The page then turns that JSON into three cards with a title, a short description, a duration and what to bring.

Things I learned along the way:

Small models sometimes return messy JSON, so the app needs to handle bad output without breaking.
The first request is slow because the model has to load into memory. After that it is much faster.
A fallback is worth building early. It made testing much easier.

Why Does Open Innovation Matter?

Because the model runs on my laptop:

Your location and interests never go to a server you do not control.
There is no API key and no cost per request.
It keeps working after setup even with weak or no signal, which is useful when you are heading outside.
I can read and change the prompt, and swap the model for a different one by editing a single line.

I am not claiming a 3B model beats a big hosted one on answer quality. For a small "what should I do with my hour" tool, though, local and open was the better fit.

Limitations

TrailBuddy does not use live maps or weather, and its ideas are not verified trail recommendations. Check local conditions before you head out.

Field Test

[Write 2 to 4 honest sentences here after you try it: what you asked, what the model suggested, what you actually did outside, and what worked or did not.]

TrailBuddy: less scrolling, more fresh air

Prarthana Sharma — Sun, 11 Oct 2026 09:01:10 +0000

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

What I Built

I had a simple idea for this challenge: if I have a free hour and want to get outside, why does deciding what to do sometimes take longer than the walk?

It is made for students, busy people, and anyone who keeps meaning to go outside but loses the time to scrolling.

Demo

TrailBuddy runs locally on your own machine, so there is no hosted link.

[Add your screenshots or a short screen recording here]

Code

prarthanas9917 / trailbuddy-ai

TrailBuddy

Built for the Hacktoberfest Week 1 “Touch Grass” challenge. Read the DEV post.

Why open AI?

View on GitHub

How I Built It

Backend: FastAPI (Python)
Frontend: plain HTML, CSS and JavaScript, with a simple form and result cards
Open model: Qwen 2.5 (3B) running locally through Ollama
Offline fallback: if Ollama is not running, the app shows a set of built in ideas instead of failing, and labels them "Offline ideas"

Things I learned along the way:

Small models sometimes return messy JSON, so the app needs to handle bad output without breaking.
The first request is slow because the model has to load into memory. After that it is much faster.
A fallback is worth building early. It made testing much easier.

Why Does Open Innovation Matter?

Because the model runs on my laptop:

Your location and interests never go to a server you do not control.
There is no API key and no cost per request.
It keeps working after setup even with weak or no signal, which is useful when you are heading outside.
I can read and change the prompt, and swap the model for a different one by editing a single line.

I am not claiming a 3B model beats a big hosted one on answer quality. For a small "what should I do with my hour" tool, though, local and open was the better fit.

Limitations

TrailBuddy does not use live maps or weather, and its ideas are not verified trail recommendations. Check local conditions before you head out.

Field Test

[Write 2 to 4 honest sentences here after you try it: what you asked, what the model suggested, what you actually did outside, and what worked or did not.]

TrailBuddy: less scrolling, more fresh air

Prarthana Sharma — Sun, 11 Oct 2026 08:51:44 +0000

I had a pretty simple idea for this challenge: if I have a free hour and want to get outside, why does deciding what to do sometimes take longer than the walk?

So I made TrailBuddy. You put in a starting area, how much time you have, and what you feel like doing. It gives you three ideas, a rough duration, and one thing to bring. The aim is to pick one and close the tab — not spend the afternoon planning.

Why run the AI locally?

TrailBuddy is set up to use Qwen 2.5 3B through Ollama on your own machine. With the model downloaded and Ollama running, your request goes to the local Ollama endpoint rather than a hosted AI API. That means no API key or per-request model bill, and your location and interests stay on your machine with the default setup. The prompt is in the repo, and you can switch to another compatible Ollama model with an environment variable.

There is one important catch: the model and Python packages need to be downloaded first. After that, the app can work without an internet connection. If Ollama isn't running, TrailBuddy falls back to a few built-in ideas and labels them as offline — those aren't AI-generated.

A work in progress

I built the app with FastAPI and plain HTML, CSS, and JavaScript. It doesn't fetch maps, weather, or trail conditions, so the suggestions are ideas, not verified local recommendations. Please check conditions before you go.

I ran seven tests and tried the browser flow. In my test setup, the local Ollama model wasn't available, so I verified the offline fallback — not actual Qwen generation. I also haven't taken it outside yet. That's the next test I want to do, and I'll update this post if I get a chance to try it on a real walk.

Code: https://github.com/prarthanas9917/trailbuddy-ai

Built for the Hacktoberfest Week 1 “Touch Grass” challenge.

Building StudyBuddy AI: An AI Assistant for Students

Prarthana Sharma — Sun, 04 Oct 2026 14:48:39 +0000

StudyBuddy AI: An AI Study Assistant

As a college student, I often have study material in different places — PDFs, notes, assignments, and other resources. The difficult part is not always finding the material, but knowing what to study and how to revise it.

That is why I decided to build StudyBuddy AI.

GitHub: https://github.com/prarthanas9917/studybuddy-ai

What is StudyBuddy AI?

StudyBuddy AI is an AI-powered study assistant designed to help students understand and organize their study material.

The basic idea is:

Study material → Explanation → Practice → Revision

It can help students with simple explanations, generate practice questions, and support them while preparing a revision plan.

Why did I build it?

There are already many AI tools available, but I wanted to build something focused specifically on students and their everyday study problems.

The goal is not to replace studying. It is to make studying more organized and easier to manage.

What I learned

While working on this project, I learned more about building AI-based applications, working with GitHub, organizing a project, and thinking about how a technical idea can solve a real problem.

It also helped me understand that building a project is not just about writing code. You also need to think about the people who will actually use it.

What's next?

I would like to improve StudyBuddy AI by adding better document processing, study progress tracking, personalized revision plans, weak-topic detection, and more practice features.

The project is still a work in progress, and I hope to keep improving it with feedback and contributions from other developers.

You can check out the project here:

https://github.com/prarthanas9917/studybuddy-ai

devchallenges #weekendchallenge #hf26challenge