DEV Community: Nitu Bathyal

IT'S PLAYTIME: Every House Has a Secret

Nitu Bathyal — Fri, 30 Oct 2026 18:33:22 +0000

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

What I Built

IT's Playtime is an advanced, offline-first horror gaming ecosystem inspired by classic midway dread, abandoned sewer mysteries, floating crimson balloons, and supernatural puzzles.
Unlike static concept mockups, IT's Playtime is a 100% functional, real-world gaming platform featuring seven fully implemented games, procedural Web Audio sound design, persistent progression saved via IndexedDB, and genuine open-source AI inference.

Interpreting the Theme: "Ghost in the Machine"

In today's AI landscape, intelligence is usually locked behind distant proprietary servers, charging fees for every token and enforcing sanitized corporate filters.
For Week 4's "Ghost in the Machine" challenge, I interpreted the theme literally: the ghost should reside directly inside the player’s personal hardware.
By pairing an open-weight local model (Qwen 2.5 3B Instruct) with Ollama, the AI is resurrected locally on the player's own CPU and GPU. It requires zero cloud APIs, zero internet connection, and zero subscription costs. When the local model generates a chilling, branching horror novel, the ghost isn't streaming from a remote corporate data center—it is haunting your local silicon.

The Seven Playable Game Modes

1.🎈 The Red Balloon (Signature Feature): Follow a drifting crimson balloon through an abandoned town. Search derelict locations, manage your inventory (flashlight, municipal keys, crowbar), solve environmental riddles, and unlock the flooded storm drain to escape Derrybrook.
2.🏰 Haunted Mansion: A room-by-room gothic exploration adventure through Ravenscroft Manor. Search for hidden keys, inspect cursed heirlooms, uncover hidden passages, and lift an ancestral curse.

🎪 The Lost Carnival: A midway survival test. Navigate the Hall of Mirrors, spin the Wheel of Torment, conquer reflex challenges, collect brass carnival tokens, and unlock the rusted gates.
👻 Ghost Party: A local pass-and-play multiplayer party game for 1–4 players on a single device. Features horror trivia, bluffing duels, and ghost riddles with real-time scoring.
🌼 Day of the Dead: A warm, respectful Día de los Muertos digital ofrenda builder. Place glowing virtual candles, scatter vibrant cempasúchil marigolds, write personal remembrance tributes, and preserve memories locally.
📖 Ghost Story Teller (Core AI Game): A multi-paragraph branching interactive horror novel generated in real time by the local Qwen model. Players choose intensity, genre, and protagonist, and make branching narrative decisions that lead to distinct endings.
🗝️ The Lost Key: A dedicated cryptographic escape room. Solve mathematical cipher sequences, decode word riddles, utilize a multi-tier progressive hint engine, and crack the locked mortuary chest.

Demo

Code

https://github.com/Nitu-Bathyal/its-playtime

Full-Stack Architecture

Frontend: React 18, Vite, Tailwind CSS, Lucide Icons, Canvas Confetti.
Audio Synthesis: Native Web Audio API procedural sound engine (zero external audio asset downloads)
PWA & Offline Persistence: Custom Service Worker (sw.js) and IndexedDB (its_playtime_db)
Backend: Python 3.13, Flask, Gunicorn WSGI, Flask-CORS
Open-Source AI: Qwen 2.5 3B Instruct running locally via Ollama

How I Built It

1. Genuine Open-Source AI Integration

The core generative mechanics are powered by the open-weight Qwen 2.5 3B Instruct model via the Ollama local daemon (http://localhost:11434).

The Python Flask backend is split into modular service handlers:

story_service.py: Employs structured multi-turn prompting to produce rich, atmospheric prose with dialogue, pacing, and two branching choice prompts.
riddle_service.py & puzzle_service.py: Generates cryptic town clues and verifies mathematical/cipher logic.

2. The Dual-Tier Offline Guarantee

To ensure the game is genuinely offline-first and never fails if Ollama is not installed or offline:

The client checks /api/health with a 2.5-second TTL timeout.
If the local AI daemon is active, it streams generative output from Qwen.
If Ollama is offline or the user is disconnected from the internet, the game automatically falls back to handcrafted horror branches, cryptographic cipher banks, and procedural question tables. The user experience never crashes or stalls.

3. Procedural Web Audio Engine (Zero Megabyte Footprint)

Instead of forcing players to download 50MB of static MP3 sound files over slow connections, I developed a custom procedural sound synthesizer using the browser's native Web Audio API:

Atmospheric Drone: Low-frequency sine oscillators (48Hz and 51.5Hz) generate binaural beats creating real psychological tension.
Music Box Melodies: High-frequency sine waves shaped by exponential decay envelopes mimic an antique, detuned carnival music box.
Balloon Pops & Jump Scares: White noise bursts shaped by bandpass filters provide tactile feedback when clicking floating balloons.

Why Does Open Innovation Matter?

Open innovation is what made IT's Playtime possible:

1.Freedom from Sanitized Content Restrictions: Commercial proprietary AI APIs (OpenAI, Anthropic, Google Cloud) have heavy moderation filters that frequently flag or reject horror themes, intense dread, creepy clowns, and gothic suspense. Open-weight models like Qwen 2.5 let creators explore darker literary themes without arbitrary censorship.
2.Zero Cost for Indie Creators & Players: A branching interactive novel burns through tokens quickly. Proprietary APIs turn games into expensive subscription traps. Running open-source models on local hardware makes generative gameplay 100% free with unlimited replayability.
3.True Software Longevity & Privacy: When a company shuts down an API, games that rely on it break forever. Because IT's Playtime runs open-weight models on local silicon and caches its assets via PWA Service Workers, this game can still be played 20 years from now on a laptop in airplane mode.

The Spirit of it

While the platform embraces classic horror tropes—creepy clowns, haunted carnival rides, and locked sewer vaults—the emotional soul of the project lies in Game 5: Day of the Dead (Día de los Muertos).

The "ghost in the machine" does not always have to be malevolent. In Día de los Muertos traditions, spirits are celebrated, remembered, and welcomed home.
In this mode, players can light digital candles, scatter cempasúchil petals, and type memorial tributes to loved ones they have lost. The data is saved locally to their browser's IndexedDB—a private, sacred digital ofrenda that stays on their own device. It transforms technology from a cold, distant machine into a vessel for human memory and love.

Prize Categories

Ghost in the Machine (Week 4 Focus Track):

Best integration of horror, mystery, spirit, and local AI intelligence.

Best Offline-First Architecture:

Exceptional use of PWA Service Workers, IndexedDB, and Web Audio synthesis for zero-dependency execution.

Best UI/UX & Atmosphere:

High-polish thematic design with original artwork, smooth animations, and responsive controls.

🦥 LazySloth Cleaner: Stay Cozy, Let AI Tackle Your Digital Clutter!

Nitu Bathyal — Sat, 24 Oct 2026 17:57:31 +0000

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

What I Built

What if you were a sloth who loved sleeping for 15–20 hours a day, but your phone kept interrupting your peace with a “Storage Almost Full” notification?
Imagine opening your gallery and finding hundreds of screenshots, downloaded images, old memes, duplicate photos, study notes, receipts, and random pictures you don't even remember saving.
You know you should organize them. You know some of them might be unnecessary. But reviewing every single file takes time, and deleting something important by mistake is even worse.
And if you're a sloth? You would probably rather take another nap.
That little problem inspired me to build LazySloth Cleaner.
LazySloth Cleaner is my attempt to make digital cleanup feel less like a chore. It combines exact duplicate photo detection, a Keep Safe feature for important files, a review queue, and a sloth-inspired interface. I also integrated Gemma AI to explore how AI can help with image organization.
One thing I wanted to get right was user control. Just because a file looks unnecessary doesn't mean it should be deleted. I wanted users to have a chance to review their files and make the final decision themselves.
The result is a cozy little project built around a simple idea: cleaning up digital clutter shouldn't have to feel exhausting.

Demo

Live Demo

https://lazysloth-cleaner.onrender.com/

Video Demo

https://www.youtube.com/watch?v=JCSilQG7L8U

Code

https://github.com/Nitu-Bathyal/lazysloth-cleaner

The Problem: Digital Clutter Is Easy to Create, Difficult to Manage

We take screenshots constantly. We save lecture slides, download documents, collect receipts, keep memes, and sometimes save the same image several times.
Over time, our digital spaces become difficult to navigate.
The problem is not simply that we have too many files. The real problem is deciding what to keep, what might be unnecessary, and what should never be deleted.
For example:

A gallery can contain duplicate images, screenshots, downloaded pictures, and important memories.
A student might have lecture notes, whiteboard photos, assignment screenshots, and reference material mixed with ordinary pictures.
An email inbox can accumulate promotional messages, old notifications, and messages that deserve a second look before being archived or removed.
SMS inboxes can contain old notifications and one-time-password messages alongside important personal conversations. Manually reviewing everything is repetitive. Automatically deleting everything is risky. I wanted to explore a more thoughtful alternative: let technology help with the repetitive work while keeping the user in charge of the final decision. That is the problem LazySloth Cleaner is designed to address.

How LazySloth Cleaner Works

The application is organized around a simple workflow: select content, inspect it, review suggestions, protect important items, and confirm decisions.

Photo and Gallery Cleanup The photo-cleanup experience is the main focus of LazySloth Cleaner. Users can select image files for inspection instead of relying on an automatic process that makes decisions without their involvement. A typical gallery cleanup workflow might include:
- Selecting a collection of images.
- Checking the collection for exact duplicates.
- Reviewing the available categories and safety indicators.
- Identifying files that should remain protected.
- Reviewing the proposed cleanup queue.
- Confirming the intended action. This approach is useful for people who have accumulated large numbers of screenshots, downloads, and repeated files. It is also relevant to students who want to organize study-related images without accidentally treating every document or screenshot as clutter.

Exact Duplicate Detection with SHA-256 One of the important technical features in the current application is SHA-256-based duplicate detection. SHA-256 is a cryptographic hash function. It processes file contents and produces a fixed-length hash value. Conceptually, the application can compare the hashes of two files:
- If the hashes match, the files are candidates for an exact-duplicate match.
- If their contents differ, their hashes will generally differ too.
- This means two identical image files can be recognized even if they have different filenames.
- For example, imagine that photo.png and photo-copy.png contain exactly the same image data. Comparing their file hashes can help identify them as duplicates. However, this method has a limitation: it does not understand visual similarity. If someone crops an image, compresses it, edits its colors, or saves it in another format, the resulting file may have a different hash even when the picture looks nearly identical. SHA-256 also does not decide whether an image is useful or safe to delete. It provides evidence about file identity, not personal importance. This is why I separate duplicate detection from the review and confirmation workflow.

3.Email Cleanup: A Workflow for a More Organized Inbox
Digital clutter does not stop at the photo gallery.
Email inboxes can contain newsletters, promotional messages, outdated notifications, receipts, and messages that no longer need immediate attention.
The LazySloth Cleaner interface includes an email-cleanup experience intended to demonstrate how the same review-first approach could help users organize inbox clutter.
A useful email-cleanup workflow could allow a user to review promotional messages, identify old notifications, and separate messages worth keeping from those they may want to archive or remove.
For example, someone who receives many promotional emails might benefit from grouping those messages for review instead of opening them individually.
However, the current email section is a demo or sandbox workflow rather than a fully connected email provider integration. It should not be mistaken for an application that already accesses a user's real inbox or deletes real emails.
A future implementation could connect to an email provider through its supported authorization and API mechanisms, with clear permissions and explicit user approval.
I see this as a natural extension of the same idea: less repetitive organization, better visibility, and more control.

4.SMS and Messages: Organizing Notifications Without Losing Important Conversations
Messages can also become a source of digital clutter.
SMS inboxes may contain old delivery notifications, service alerts, temporary codes, reminders, and personal conversations. The challenge is deciding which messages can safely be ignored and which ones may still matter.
LazySloth Cleaner's SMS and Messages section demonstrates how a similar review-based workflow could be applied to message organization.
For instance, a future connected implementation could help users review old notifications separately from conversations they want to keep.
But messages are highly personal. An old-looking conversation may contain important information, and a one-time password should not be treated as universally safe to delete without considering the context.
The current section is a demo or sandbox experience, not a fully connected SMS integration that can already read or delete messages from a user's phone.
Real mobile messaging access would require platform-specific integration, appropriate permissions, and additional development.
I included this direction because digital clutter is not limited to one application. The same safety-first principles could eventually help users manage several kinds of digital content.

How I Built It

LazySloth Cleaner combines a browser-based interface, file-inspection logic, safety-oriented review controls, an AI integration, development assistance, and web hosting.
The three tools I want to highlight are Gemma, GitHub Copilot, and Render. Each serves a different purpose.

1. Gemma — The Open-Weight AI Integration

Gemma is Google's family of open-weight AI models. It is relevant to this project because AI could help move file organization beyond simple rules and exact duplicate matching.
For LazySloth Cleaner, the intended AI role is to help interpret images and provide useful classification or organization suggestions, depending on the capabilities of the selected model.
For example, an image-understanding model could potentially help distinguish a screenshot from a photograph or recognize broad visual categories. These capabilities depend on the particular model, its supported inputs, and the actual inference implementation.
This is different from SHA-256:
SHA-256 compares file contents for exact-duplicate detection.
Heuristic rules use predefined logic to support classification and safety decisions.
A vision-capable AI model can interpret image content, within the limits of its training and capabilities.
These components complement one another rather than replacing one another.
In the current project, the Gemma integration reports a Ready status in the interface. That status is useful, but the important test is whether the selected model actually completes image inference and returns meaningful results. I would only describe specific AI predictions as working features after verifying that process with a real test image.
The project should not claim that Gemma permanently deletes files, guarantees that a file is unimportant, or understands every image perfectly.
The goal is to use AI as an assistant for organizing content, while keeping the user in control of the final decision.

2. GitHub Copilot — Development Assistance

GitHub Copilot was part of my development workflow as an AI coding assistant.
Building a project involves more than writing the main interface. It also requires working through implementation details, reviewing logic, improving the user experience, considering edge cases, and testing whether the application behaves as expected.
Copilot can help with coding tasks such as drafting implementation ideas, explaining unfamiliar code, suggesting changes, and assisting with debugging.
It is important to distinguish the role of Copilot from the role of Gemma in the finished application.
GitHub Copilot helped with the development process; Gemma is the model integration intended for the application's AI functionality.
Copilot does not automatically become the runtime AI engine just because it helped build the project. The application still needs its own working implementation and tests.
I also needed to consider the difference between code that looks correct and functionality that has actually been tested. File handling, duplicate detection, protected items, and confirmation safeguards all need to work together.
Using a coding assistant can accelerate development, but it does not replace understanding the code or verifying the result.

3. Render — Hosting the Live Demo

Render is the hosting platform used to make LazySloth Cleaner available online.
A project is easier to evaluate when someone can open a live link rather than having to install every dependency and configure a development environment.
The deployed website allows reviewers to explore the interface, understand the workflow, and test the features that are available in the hosted version.
The current deployment is a static web application. This distinction matters because hosting the frontend does not automatically mean that a local model or a separate inference service is running on Render.
For example, a model running on a developer's laptop is not automatically accessible to visitors using the deployed website. Connecting a hosted frontend to a model requires an appropriate browser-local or hosted inference architecture.
I chose Render to make the project accessible for demonstration while keeping the deployment approach straightforward.

Why Does Open Innovation Matter?

Open innovation matters because useful technology should not be limited to systems that people cannot inspect, adapt, or learn from.
For this project, open-weight AI provides an opportunity to experiment with model behavior and understand how AI-assisted image organization could work. Instead of treating AI as a mysterious black box, developers can investigate model capabilities, evaluate trade-offs, and choose an architecture that fits their needs.
That flexibility matters for a privacy-conscious application.
Different users may have different priorities. One person may prefer local inference because they do not want to send photos to an external service. Another may prioritize faster inference on suitable hardware. A developer may want to experiment with another compatible model or compare the quality of different approaches.
Open-weight models can make those experiments possible, subject to each model's license and technical requirements.
They do not automatically guarantee privacy, offline operation, zero cost, or perfect performance. Those properties depend on how the model is deployed, the hardware required, and the rest of the application.
The distinction is especially important for LazySloth Cleaner because the content being organized can be personal.
I want to explore approaches that let developers inspect and improve the system, understand where their data is processed, and adapt the technology instead of depending entirely on a closed service.
Open innovation also supports learning. A student or independent developer can study the code, understand the role of each component, experiment with alternatives, and share improvements with others.
For a project like this, openness is not just about making the repository public. It is about creating room to learn, experiment, and make informed technical choices.

My First User

I shared LazySloth-Cleaner with a friend to get feedback on the experience.

The Lazy Payoff

How much effort does LazySloth Cleaner save?
I do not have a verified time study yet, so I will not invent a percentage or claim that it saves a particular number of minutes for every user.
The intended benefit is to reduce repetitive work.
When a person has to inspect a large collection manually, they may need to compare files, remember which documents matter, and repeatedly decide what to keep. Exact duplicate detection can help identify matching files, while protective rules and a review queue make the decision process more structured.
That does not eliminate the need for human judgment. It aims to make the work easier to navigate.
For a student, the idea is particularly relatable: organize a cluttered collection of screenshots without losing lecture material. For someone with a busy inbox, a similar review-first workflow could eventually help bring attention to messages that need organizing. For a phone user, the longer-term vision is to make digital clutter feel manageable instead of overwhelming.
My favorite part of this idea is that the product's personality matches its purpose.
It is not trying to make people work faster at every moment. It is trying to make a repetitive task easier, so people have more freedom to spend their time elsewhere.
And if our mascot can remind us to slow down while the application handles part of the sorting work, even better.

Prize Categories

I am considering the following categories based on the technologies used in this project:

Best Use of Gemma:

Relevant if the Gemma integration meaningfully powers the application's AI behavior and the model's actual role can be demonstrated.

Best Use of Render:

Relevant because Render hosts the deployed web demonstration.

Best Use of GitHub Copilot:

Relevant if Copilot meaningfully supported the development workflow and I can describe that work accurately.

TalkLedger: Bringing India's Traditional Udhaar Ledger into the AI Era

Nitu Bathyal — Sun, 18 Oct 2026 16:26:43 +0000

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

What I Built

Every small shop has a familiar challenge: keeping track of who owes what.
A customer buys groceries today and promises to pay tomorrow. Another customer pays back part of their outstanding balance. Someone else has credit from last week. Traditionally, many small businesses manage these transactions in a notebook called a bahi-khata.
I wanted to explore how AI could make this everyday bookkeeping process easier.
That's why I built TalkLedger — a voice-first digital udhaar ledger designed for small businesses.
TalkLedger brings the familiar idea of a shopkeeper's account book into a digital interface, with conversational AI and a workflow designed around reviewing transactions before saving them.

What can TalkLedger help with?

Voice-first bookkeeping: Make transaction entry more natural through speech-based interaction.
Customer credit tracking: Organize customer records and outstanding balances.
Payment management: Keep track of credit transactions and repayments.
Gemma-powered conversational AI: Explore how an open-weight language model can interpret bookkeeping requests.
Review before saving: Let the merchant review, edit, confirm, or discard proposed transaction details.
Dashboard and reports: Bring ledger information into one digital workspace.
Repayment forecasting: Explore how historical transaction data could support repayment predictions.

Demo

🎥 Watch the TalkLedger demo video:
https://www.youtube.com/watch?v=xJLpCL9pPh8

🌐 Try the live application:
https://talkledger-4.onrender.com/

Code

https://github.com/Nitu-Bathyal/TalkLedger

TalkLedger is an open-source project built with the intention of making its implementation accessible to other developers.
You can explore the code, understand the application architecture, and contribute ideas for improving the bookkeeping workflow, AI integration, database design, and overall usability.

How I Built It

I built TalkLedger as a full-stack application rather than just a standalone chatbot.
1. Frontend and user experience
The frontend uses React, Vite, and TypeScript.
The design takes inspiration from traditional Indian account books, with warm cream backgrounds, green accents, ledger-style layouts, and a friendly interface.
The application includes dedicated areas for the home page, dashboard, Gemma AI assistant, voice interaction, ledger, payments, forecasting, and reports.
I wanted the interface to feel approachable for small-business owners rather than like complicated accounting software.

2. Backend and database
The backend uses Node.js, Express, and TypeScript, with Prisma ORM for database access.
The deployment setup uses PostgreSQL through Neon, while Render hosts the application.
This architecture connects the user interface with backend routes and database operations, providing the foundation for managing customer and transaction information.
Moving from local development to cloud deployment also gave me practical experience with environment variables, database connectivity, API routes, and deployment configuration.

3. Exploring Gemma 2 for conversational bookkeeping
A key part of TalkLedger is Gemma 2, Google's open-weight language model family.
I designed the conversational assistant around a specific task: helping a shopkeeper express bookkeeping requests in natural language and preparing structured actions for review.
The intended workflow is:
A merchant enters a request through speech or text.
The request is sent to the backend.
The configured model provider processes the request.
The application prepares the proposed transaction details.
The merchant reviews and edits the details if needed.
The merchant confirms the action before it is submitted for saving.
The architecture explores an extensible provider approach, including integration paths for Groq, Hugging Face, and local Ollama inference.

4. Designing for user control
A ledger deals with financial records, so an AI-generated suggestion should not automatically be treated as an authorized transaction.
TalkLedger's proposed-action workflow is designed to separate interpreting a request from confirming a database change.
The merchant can review the customer, amount, and transaction type before confirming. If the action is not confirmed, it should not be written to the ledger.
This design principle is important to me: AI should assist the merchant, while the merchant remains in control of financial actions.

5. Deployment with Render
I deployed TalkLedger on Render, with PostgreSQL configured through Neon.
Render provides the hosting environment for making the application accessible through a public URL.
This part of the project helped me understand that building a web application involves more than designing a good interface. Backend configuration, database connectivity, environment variables, and production testing are also essential.

Why Does Open Innovation Matter?

I wanted to work on a practical problem that small businesses face every day, rather than building another general-purpose AI chatbot.
Open innovation makes it possible to experiment with open-weight models, inspect application code, adapt integrations, and learn from other developers.
For TalkLedger, this creates opportunities to explore how an open-weight model such as Gemma can support a specific workflow, how different model providers can be used, and how developers can improve the application without making every design decision dependent on a single proprietary service.
It also allows other developers to examine the transaction workflow and suggest improvements to reliability, usability, and user control.
My broader goal is to explore how open-source AI can make everyday digital tools more accessible to small businesses.

My Agent Session

I used AI-assisted development tools while working on the application structure, interface, and integration workflow.
I have not included a public DevRelay or agent-session link in this submission.

My First User

My first feedback came from my father, whom I asked to try TalkLedger and share his honest opinion.
It reminded me that building a useful application is not just about adding features. The experience needs to make sense to the people who might actually use it.
This was early feedback on the project, not a paid customer transaction or evidence of regular business use.

Prize Categories

I am submitting TalkLedger to the Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle.
My intended partner prize categories are:

1. Best Use of Gemma

TalkLedger explores Google's Gemma 2 open-weight model for conversational bookkeeping. The project focuses on interpreting natural-language transaction requests and preparing actions for merchant review.

2. Best Use of Render

TalkLedger is deployed on Render and has a public application URL. Render provides the hosting environment for the project's web application.

Final Thoughts

TalkLedger started with a simple question:
What if keeping track of udhaar(credit) could feel as natural as speaking to someone, instead of manually updating a notebook every time?
Building this project has helped me explore full-stack development, open-weight AI, database integration, deployment, and the importance of designing AI-assisted actions with user control in mind.
There is still room to improve the application, but I am excited about the potential of combining familiar bookkeeping practices with accessible technology.
If you are interested in open-source AI, small-business tools, or making everyday workflows simpler, I would love your feedback and contributions.

Try TalkLedger: https://talkledger-4.onrender.com/
Explore the code: https://github.com/Nitu-Bathyal/TalkLedger
Watch the demo: https://www.youtube.com/watch?v=xJLpCL9pPh8

devchallenge #hf26challenge #opensource #webdev

TrailLens: Turn Every Walk Into a Nature Discovery

Nitu Bathyal — Sat, 10 Oct 2026 19:46:26 +0000

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

What I Built

TrailLens is a nature-exploration web app designed to encourage people to go outdoors, capture interesting discoveries, and learn about the natural world.

Demo

Live app: https://traillens-db7u.onrender.com/

Code

GitHub: https://github.com/Nitu-Bathyal/traillens

How I Built It

Built using React, Vite, TypeScript, and FastAPI, with database support and an experimental TabPFN prediction component. The project is still evolving, and its AI identification capabilities need further validation.

Why Does Open Innovation Matter?

Open-source tools make it easier to learn, experiment, collaborate, and improve technology transparently. My goal is to make TrailLens a useful companion for outdoor curiosity and nature learning.

Prize Categories

No partner-specific prize category claimed at this stage.

Thanks for checking out TrailLens!

Hi ||Starting My Developer Journey.

Nitu Bathyal — Fri, 02 Oct 2026 19:22:38 +0000

Hello everyone! 👋
I'm a student at VIT Bhopal University, currently pursuing an Integrated M.Tech in Data Science.

I'm interested in AI/ML, Java, Data Science, and Software Development. I'm here to learn, build projects, explore new technologies, and connect with fellow developers. 🚀
Looking forward to learning and growing with the DEV community! ✨

DEV Community: Nitu Bathyal

IT'S PLAYTIME: Every House Has a Secret

What I Built

Interpreting the Theme: "Ghost in the Machine"

The Seven Playable Game Modes

Demo

Live Application (Render):

Live Mirror (GitHub Pages):

Demo video:

Code

Full-Stack Architecture

How I Built It

1. Genuine Open-Source AI Integration

2. The Dual-Tier Offline Guarantee

3. Procedural Web Audio Engine (Zero Megabyte Footprint)

Why Does Open Innovation Matter?

The Spirit of it

Prize Categories

Ghost in the Machine (Week 4 Focus Track):

Best Offline-First Architecture:

Best UI/UX & Atmosphere:

🦥 LazySloth Cleaner: Stay Cozy, Let AI Tackle Your Digital Clutter!

What I Built

Demo

Live Demo

Video Demo

Code

The Problem: Digital Clutter Is Easy to Create, Difficult to Manage

How LazySloth Cleaner Works

How I Built It

1. Gemma — The Open-Weight AI Integration

2. GitHub Copilot — Development Assistance

3. Render — Hosting the Live Demo

Why Does Open Innovation Matter?

My First User

The Lazy Payoff

Prize Categories

Best Use of Gemma:

Best Use of Render:

Best Use of GitHub Copilot:

TalkLedger: Bringing India's Traditional Udhaar Ledger into the AI Era

What I Built

What can TalkLedger help with?

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

My First User

Prize Categories

1. Best Use of Gemma

2. Best Use of Render

Final Thoughts

devchallenge #hf26challenge #opensource #webdev

TrailLens: Turn Every Walk Into a Nature Discovery

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Hi ||Starting My Developer Journey.