DEV Community: Tarun D Hullur

Ghost_In_The_Machine

Tarun D Hullur — Wed, 28 Oct 2026 13:44:16 +0000

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

🌼 Still Here — A Private AI Memory Garden

Some people leave our lives, but the little things that remind us of them never really disappear.

A favorite song. A familiar voice. A small moment that stays with us for years.

I built Still Here, a private AI memory garden designed to help people preserve the stories, memories, and little details that make someone unforgettable.

Inspired by the Hacktoberfest Open-Source AI Challenge theme, Ghost in the Machine, this project explores how AI can help us keep memories alive without handing our most personal stories over to an online service.

Instead of building another chatbot, I wanted to create something more personal: a quiet space where memories can become letters, vignettes, and poems.

💡 What I Built

Still Here is a browser-based memory archive with AI-powered writing tools.

Users can write down a memory, optionally attach a photograph, and use an open-weight language model to transform their own details into a more expressive piece of writing.

The idea is simple: technology should help us tell our stories without taking ownership of them.

✨ Key Features

🌼 Personal Memory Archive: Write and preserve meaningful memories in one place.

📷 Photo Attachments: Add photographs to make a memory more personal.

✍️ AI-Powered Writing: Transform your notes into letters, short vignettes, or poems.

🔒 Privacy by Design: Memories and attached photos are stored in your browser's local storage rather than uploaded to a backend.

🤖 On-Device AI: Run an open-weight language model directly in the browser.

📴 Local-First Experience: Once the model assets are downloaded and cached, generation can run on your device without sending prompts to a remote inference API.

🛠️ How I Built It

I built Still Here as a lightweight web application using HTML, CSS, and JavaScript.

The application uses:

HTML for the application structure.

CSS for the user interface and visual styling.

JavaScript for application logic and interactions.

Transformers.js to run the language model in the browser.

SmolLM2-360M-Instruct as the open-weight model powering the writing experience.

Browser local storage to preserve memories and attached photographs locally.

There is no application backend or remote inference API.

The model is downloaded when the user chooses to load it. After that, text generation runs on the user's device.

👻 Why This Fits Ghost in the Machine

The theme made me think about the relationship between memory, technology, and the things we leave behind.

A machine cannot replace a person, recreate a life, or truly understand the meaning of every memory. But it can help someone find words for a moment they want to preserve.

Still Here brings together two ideas:

The ghost: The memories, stories, and small details of people who remain important to us.

The machine: An open-weight language model that helps shape those memories into written keepsakes.

The AI does not create the underlying memories. It works with the details the user provides, helping turn personal notes into something they can revisit and keep.

🔓 Why Open Innovation Matters

Memories can be deeply personal. I didn't want the core writing experience to depend on sending those memories to a third-party AI service.

Using an open-weight model makes a different approach possible.

Privacy: Personal memories and photos remain in browser storage, and prompts do not need to be sent to a remote inference API.

Control: The writing model can be inspected, replaced, or adapted rather than being permanently tied to one proprietary AI provider.

Accessibility: Once the required assets have been downloaded, users can generate writing on their own device without an inference account or per-message API fee.

Independence: The application has no backend service that must store or process a user's personal stories.

There are trade-offs. The model is deliberately small, so its writing capabilities may be more limited than those of a larger hosted model. The first model download also requires an internet connection, and a fully disconnected setup requires the assets to be available locally.

For this project, I believe that trade-off is worthwhile. When someone is preserving a personal memory, control over where that information goes matters.

🧩 Challenges and Learnings

One of the interesting parts of this project was bringing AI into the browser rather than relying on a conventional cloud-based inference API.

This approach requires thinking about model downloads, local execution, browser storage, and the balance between model size and writing quality.

It also reinforced an important lesson: AI applications do not always need a large backend or a complicated infrastructure to be useful.

Sometimes, a focused idea and a small open model can create a more personal experience.

🚀 Try It and Explore the Code

GitHub Repository: https://github.com/TarunHullur/Ghost_In_The_Machine.git

The repository includes the application code and instructions for running it locally.

To start the application, clone the repository and run:

git clone https://github.com/TarunHullur/Ghost_In_The_Machine.git
cd Ghost_In_The_Machine
python3 -m http.server 8000

Then open http://localhost:8000 in your browser.

Choose the option to load the open model. The initial download requires an internet connection.

Live Demo: https://stillhere11.netlify.app/

🌼 The Spirit of Still Here

We build technology to solve problems, automate tasks, and make life easier.

But technology can also help us preserve the things that make life meaningful.

Still Here is my exploration of that idea: a small, private place for memories, powered by open-source tools and designed around the belief that personal stories deserve care.

Because sometimes, the most meaningful thing a machine can do is help us remember.

Thanks for checking out my project!

I'd love to hear your thoughts, feedback, and ideas for making Still Here better.

OpenSource #AI #Hacktoberfest #GhostInTheMachine

Slow_and_Steady

Tarun D Hullur — Wed, 21 Oct 2026 16:28:25 +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 privacy-first AI assistant designed to make everyday computer tasks easier without depending entirely on cloud-based AI services.

We all spend too much time organizing files, summarizing notes, sorting information, and repeating small tasks. LazyFlow AI aims to reduce that busywork by combining local AI with simple automation tools.

The project is designed around one idea: let AI handle the repetitive work while you stay in control.

Key features include:

Smart File Organizer: Organize files by type or category, with a preview before making changes.
AI Text Summarizer: Turn long notes and text into concise summaries.
Daily Digest: Convert notes and conversation exports into a useful daily overview.
Focus Mode: Generate calming messages and simple relaxation exercises.
Automation Rules: Create reusable rules for repetitive tasks.
Activity Log: Review actions and track changes.
Privacy-First Design: Keep personal files under the user's control and request confirmation before modifying them.
Offline-Friendly Utilities: Keep essential file-management features useful even without an internet connection.

The planned local AI integration uses Ollama with a compatible open-weight model, such as Gemma or Llama.

Why I Built It

I wanted to explore how open-source AI can make automation more accessible, private, and customizable.

Cloud AI services can be useful, but sending personal notes and files to external services is not always desirable. Local models provide another option: users can run AI on their own machines, choose their preferred models, and retain greater control over their data.

LazyFlow AI explores how local intelligence and traditional automation can work together. Not every task needs a powerful AI model. Simple file operations can run locally using ordinary code, while an AI model can help with summarization and natural-language tasks.

That combination is what makes the project interesting to me.

Demo

**Project status: https://slowsteady02.netlify.app/

Live demo: https://slowsteady02.netlify.app/
GitHub repository: https://github.com/tarundhullur/Slow_and_steady.git

The demo should show the dashboard, a file organization preview, text summarization, and the local AI status.

Code

**GitHub repository: https://github.com/tarundhullur/Slow_and_steady.git
The project is intended to use React, TypeScript, Tailwind CSS, Python, FastAPI, SQLite, and Ollama.

The architecture separates the user interface, backend API, local AI integration, and file-management utilities so that each component can be maintained and improved independently.

Safety is important: file changes should require user confirmation, file operations should be restricted to explicitly selected directories, and the application should never blindly execute commands generated by an AI model.

The Lazy Payoff

The goal is to spend less time on repetitive digital chores.

Instead of manually sorting a folder, rewriting long notes into short summaries, or repeating the same small organizational tasks, users can delegate suitable work to LazyFlow AI.

The biggest benefit is not simply speed. It is reducing mental overhead and making small tasks easier to finish.

I will measure the actual time saved by testing common workflows before and after automation rather than claiming unverified performance numbers.

Why Open Innovation Matters

Open-source AI gives developers the freedom to inspect, customize, and improve their tools.

With a local model, users can experiment with different models, work toward offline functionality, and avoid making every workflow dependent on a single closed AI provider.

It also encourages community contributions. Developers can add new automation rules, improve the interface, introduce additional model integrations, and strengthen privacy and safety features.

For a project like LazyFlow AI, openness is not just a development choice. It is part of the product's purpose.

Prize Categories

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

Potential partner categories: I will select any additional categories only after confirming that the finished project satisfies their specific requirements.

What's Next?

My next priorities are to complete the local AI integration, test the main workflows, improve error handling, and document how to run the application locally.

I also want to make it easy for contributors to add new automation features without compromising user privacy.

The long-term goal is simple: an assistant that takes care of the small digital chores, runs as locally as possible, and leaves the user in control.

Thanks for checking out LazyFlow AI!

Slide_Hustle

Tarun D Hullur — Tue, 13 Oct 2026 16:40:41 +0000

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

What I Built

Meet Slipstream, a receipt management and expense-tracking tool built for freelancers, independent workers, and small business owners who want to spend less time on paperwork and more time on meaningful work.

Managing business expenses can quickly become messy. Receipts get lost, important totals are forgotten, and organizing expenses manually takes valuable time. Slipstream aims to make this process simpler with a clean, easy-to-use receipt inbox and AI-assisted receipt scanning.

Key Features

AI-powered receipt scanning: Upload receipt photos and use a local vision model to extract information.

Expense tracking: Keep track of business spending and view monthly expenses.

Receipt organization: Organize expenses by categories such as meals, travel, and office supplies.

Search and review: Find receipts and identify entries that need attention, such as missing dates or totals.

Manual expense entry: Add expenses yourself whenever you prefer.

Privacy-focused AI: Use a locally configured Ollama vision model instead of relying on a hosted AI API.

Local data storage: Receipt records are stored on your device, helping keep your business information under your control.

The goal is to make expense tracking less frustrating while giving users more control over their financial information.

Demo

https://slidehustle.netlify.app/

Code

https://github.com/tarundhullur/Side_Hustle.git

How I Built It

Slipstream combines an expense-management interface with an AI-assisted receipt-processing workflow.

Receipt management

The application provides a central receipt inbox where users can view their records, search for expenses, filter by category, and identify entries that require review.

AI-powered extraction

For receipt scanning, Slipstream uses an open vision model through Ollama. The application suggests the gemma3:4b model as an option.

The intended workflow is to submit a receipt image to the configured local model and use its analysis to help organize the expense information.

Privacy by design

One of the main ideas behind Slipstream is that financial records can contain sensitive information.

Rather than depending on a hosted AI API, the receipt-scanning workflow can use a vision model running on a machine controlled by the user. The application also states that original receipt images are not saved after analysis.

Manual entry and expense review

AI is not required for every task. Users can enter expenses manually, select categories, record totals and optional tax amounts, and add payment notes.

This provides a practical alternative when local AI scanning is unavailable or a receipt needs to be entered by hand.

A simple, focused experience

The interface focuses on the tasks that matter most: adding receipts, reviewing expenses, tracking monthly spending, and keeping business records organized.

Technology to highlight: Ollama and the gemma3:4b vision model are identified by the application. Add your actual frontend framework, programming languages, database or storage approach, and other libraries here.

Why Does Open Innovation Matter?

Open innovation is at the core of Touch Grass because offline privacy, complete system transparency, and low-latency execution were non-negotiable for an interactive trail and outdoor companion.

Relying on closed proprietary APIs creates several bottlenecks:

Connectivity Restrictions: Closed models require constant, active internet access—making them completely unusable on remote outdoor trails or off-grid locations where network connectivity is spotty or nonexistent.
Data Privacy & Ownership: Users exploring local trails or personal routes shouldn't have their location telemetry, activity logs, or environmental data harvested or locked into proprietary cloud servers.
Cost & Vendor Lock-in: Proprietary APIs incur per-request token costs that limit iteration, scaling, and long-term maintenance. Open-source models allow complete flexibility to fine-tune locally, swap lightweight weights, and deploy on cost-effective infrastructure like Render without unpredictable billing spikes.

By using an open-source approach, Touch Grass runs efficiently, respects user data privacy, and delivers reliable offline utility without reliance on closed ecosystem constraints.

Touch Grass

Tarun D Hullur — Sat, 10 Oct 2026 14:33:21 +0000

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

What I Built

EcoQuest is an AI-powered open-source outdoor companion designed specifically to get users off their screens and back into nature.

Instead of endless scrolling, EcoQuest provides real-world micro-challenges, nature identification tools, and outdoor exploration prompts. Built with privacy and outdoor functionality in mind, it operates with a minimalist interface to ensure users spend more time looking at their surroundings than at their phone screens.

Demo

Live Demo App: https://touch-grass-5emx.onrender.com/

Code

Replace this line with your GitHub repository link:
{https://github.com/tarundhullur/Touch_grass.git}

How I Built It

Frontend & UI: React, Vite, and Tailwind CSS for a fast, responsive, dark-themed interface.
Backend Infrastructure: Node.js / Express deployed on Render to deliver dynamic APIs and outdoor prompt generators.
AI Integration: Open-weight models and prompt architecture optimized to deliver concise outdoor missions and species/nature identification guidance.
State Management: Local browser storage to allow logging outdoor sessions without requiring heavy network usage on nature trails.

Prize Categories

Best Use of Render: App hosted live on Render at https://touch-grass-5emx.onrender.com/.

Intro

Tarun D Hullur — Wed, 07 Oct 2026 15:42:18 +0000

Hey! I am Tarun new to the community, happy to be the part of dev.