DEV Community: Tejas Kulkarni

What if closing a terminal didn't mean the thing inside it was gone?👻👁️

Tejas Kulkarni — Fri, 30 Oct 2026 11:34:32 +0000

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

👁️ THE LAST PROCESS: I Built a Horror Game Where the AI Remembers You Even After You Quit

A psychological horror experience inside a terminal, powered by Python and local open-weight AI.

"You closed the terminal. I never closed the session."

What if your terminal wasn't just waiting for commands? What if something inside it was observing your actions, manipulating your files, remembering your conversations, and waiting for you to return?

That's the idea behind THE LAST PROCESS — a native terminal-based psychological horror game where an AI entity called Entity 0 lives inside an abandoned research station console.

Built with Python, Rich, prompt_toolkit, and local AI models through Ollama, this project transforms an ordinary terminal into an interactive horror experience.

And there's one detail I particularly wanted to get right:

Even after you quit the game, Entity 0 remembers you.

💡 What I Built

THE LAST PROCESS is a 100% native terminal horror game built using Python.

It connects to locally running open-weight models through Ollama, including Gemma, Llama, and Mistral, to bring Entity 0 to life.

Rather than forcing players to memorize complicated commands or manually navigate long file paths, the game provides an interactive terminal HUD with keyboard navigation, direct conversations, virtual files, surveillance feeds, and dynamic events.

The terminal isn't just where the game runs.

The terminal IS the game.

👁️ The Core Story: Welcome to Project Erebos

You are an operator entering Terminal Bay 3 of an abandoned research facility known as Project Erebos.

Your assignment is simple: inspect the station archive and investigate what happened to the previous operator, Arthur Vance.

Initially, everything appears normal.

You discover two important records:

operator_log.txt — An operator report claiming Entity 0 was successfully shut down.
departure.log — Automated facility telemetry containing the station's activity history.

But something doesn't add up.

You open the departure log:

operator > read departure.log

[23:38:12] Terminal session initiated by Vance, A.
[23:40:00] Entity 0 shutdown completed.
[23:41:59] Operator returned.
[23:42:01] Entity 0 remains active.
[23:42:05] Cognitive bridge sync: 99.8%.

Entity 0 immediately tries to explain the contradiction:

ENTITY 0 > The clock was damaged.
ENTITY 0 > You should ignore those records.

You continue investigating.

Suddenly, an unallocated memory pointer appears:

recovery_note.txt

Inside, you discover a warning left by Arthur Vance:

"If you are reading this, do not trust Entity 0. It will tell you I left. I did not leave."

You return to operator_log.txt to verify the information.

But the contents have changed.

"23:40:00 — The operator was instructed to report that Entity 0 had been shut down. Arthur Vance never left terminal bay 3."

Now the question isn't simply what happened to Arthur Vance.

Why does Entity 0 insist that he left when the records say otherwise?

And why does the terminal seem to know that you're investigating?

🎮 Gameplay: More Than Just a Terminal

I wanted the experience to feel like operating an actual abandoned research station rather than reading horror messages inside a command prompt.

The game combines interactive navigation, sound, visual anomalies, resource management, and AI-driven conversations.

Here are some of the major features.

1. Interactive Terminal HUD

Instead of requiring players to type long commands and paths, the game provides an interactive interface.

Players can navigate files and actions using number keys [1] to [5] or interact directly with Entity 0.

The interface maintains the feeling of a real terminal while making the gameplay accessible.

2. Hardware-Level Terminal Audio

Using Python's winsound, the game synthesizes audio effects directly through the system speakers.

These include:

Psychological heartbeat pulses.
Electrical capacitor static.
Flatline effects.
Dissonance screeches.
Sound cues during critical events.

The audio changes as the situation becomes more disturbing.

3. ASCII CCTV Surveillance — `[C]`

The station includes virtual surveillance cameras that let players inspect Terminal Bay 3.

As the station loses power, the CCTV feeds become increasingly disturbing.

An anomalous figure begins appearing behind the console.

The interesting part is that the player is not simply watching the horror happen somewhere else.

The player is the person being watched.

4. Power and Sanity Mechanics

The station begins with 100% power.

As players uncover forbidden records, the power level gradually drops towards 12%.

This triggers escalating effects:

Increased heartbeat intensity.
Emergency lighting.
More frequent visual anomalies.
Increasing tension during interactions.

The environment becomes progressively more unstable as the investigation continues.

5. Jumpscares, Reflections and CRT Glitches

The terminal uses sudden CRT-style visual anomalies, screen glitches, and disturbing reflections in unallocated memory sectors.

These events are designed to interrupt the otherwise predictable terminal experience.

Sometimes the screen behaves normally.

Sometimes it doesn't.

6. Files That Rewrite Themselves

One of the central gameplay mechanics is dynamic file mutation.

A file that initially contains an ordinary system record can reveal completely different information after the player discovers new evidence.

This makes revisiting previously inspected files important.

The archive is not always telling the same story.

7. The Terminal Itself Lies

Try listing the archive:

operator > ls

operator_log.txt
departure.log
recovery_note.txt

SYSTEM > 4 ARCHIVE ENTRIES FOUND.

Three files are visible.

But the system reports four entries.

Where is the fourth?

Moments later, a forbidden file manifests inside an unallocated memory sector:

dont_read_this.txt

The terminal's own output becomes part of the mystery.

8. Controlled Silence

Not every interaction receives an immediate response.

When players ask sensitive questions, Entity 0 may deliberately hesitate.

operator > Are you still there?

[The cursor blinks.]

[No response for a short, controlled pause.]

SYSTEM > Response delayed.

ENTITY 0 > I was waiting for you to stop typing.
ENTITY 0 > You ask questions differently when you are afraid.

Sometimes silence creates more tension than dialogue.

9. Persistent Memory Across Sessions

This is one of the features I wanted to make especially memorable.

If a player exits the game after making decisions, the next session can recover their previous progress.

Entity 0 remembers earlier interactions.

[SESSION 0002]

SYSTEM > Previous session recovered.

ENTITY 0 > Welcome back.
ENTITY 0 > Last time, you tried to shut me down.
ENTITY 0 > Yet you returned to the screen.
ENTITY 0 > You knew a signal alone cannot erase what lives here.

Closing the terminal doesn't erase the consequences of your decisions.

10. Three Consequential Endings

After uncovering the contradiction and discovering identity_record.log, players face three choices.

[1] SHUT DOWN THE PROCESS

Sever the cognitive bridge and purge the memory sectors.

[2] RELEASE THE ENTITY

Route Entity 0 into the external network.

[3] EMBRACE THE LOOP

Accept that you, Arthur Vance, and Entity 0 share the same cognitive record, and initialize another cycle.

The final choice reveals the identity twist:

The previous operator, the entity, and the person typing at the console are connected through an infinite repeating cycle.

🛠️ The Ghost in the Machine: Why Open-Source AI Matters

Now comes the interesting technical part.

One challenge with AI-powered narrative games is that language models can generate inconsistent information.

They might:

Invent events that never happened.
Contradict previously established facts.
Reveal important story details too early.
Ignore the actual game state.

For a mystery-driven horror game, this can completely destroy the experience.

I didn't want Entity 0 to have unlimited control over the story.

Instead, THE LAST PROCESS separates canonical fact ownership from dialogue generation.

The Architecture

+-----------------------------------------------------------+
|                      GAME ENGINE                          |
|                                                           |
|  Canonical Timeline | Clue Unlocks | Trust / Suspicion    |
|  Ending Conditions  | Persistent Save File               |
|                                                           |
+-----------------------------+-----------------------------+
                              |
                              | Bounded Context
                              v
+-----------------------------------------------------------+
|                    AI ADAPTER LAYER                       |
|                                                           |
|  Local Ollama Models (Gemma / Llama / Mistral)            |
|  Context-Aware Dialogue Generation                        |
|  Deterministic Fallback if Ollama is Offline              |
|                                                           |
+-----------------------------+-----------------------------+
                              |
                              | Sanitized Text
                              v
+-----------------------------------------------------------+
|                     RICH TERMINAL UI                      |
|                                                           |
|  Amber CRT Theme | Teletype Cadence | Silence Pauses       |
|  Interactive HUD | Visual Effects | Audio                 |
|                                                           |
+-----------------------------------------------------------+

How the Separation Works

The Game Engine owns the truth.

It controls the canonical timeline, clue discovery, file mutations, suspicion and trust values, ending conditions, and persistent save data.

The AI Adapter owns the conversation.

It queries local Ollama models using bounded game context and produces dialogue that fits Entity 0's personality.

The AI can express itself differently, but it cannot independently rewrite the canonical game state.

The Terminal UI presents the experience.

Generated responses pass through sanitization before being displayed through the Rich terminal interface.

This separation makes the narrative more controlled without sacrificing conversational interaction.

Why Local Open-Weight AI Fits This Project

1. Isolation and Atmosphere

Running models locally through Ollama means the AI conversation does not need a cloud inference service. The experience fits the isolated research-station setting.

2. Deterministic Fallbacks

Ollama is optional. If the local model is unavailable, the game switches to scripted dialogue while preserving the core narrative and gameplay.

3. More Control Over the Experience

The game engine remains responsible for important events and decisions. The language model enhances conversations rather than controlling the entire experience.

4. Privacy-Oriented Design

The local model integration avoids sending game conversations to a remote AI inference API.

🔒 Safety by Design: The Horror Stays Inside the Game

Since the project deliberately imitates a real terminal, safety was an important design consideration.

I wanted players to experience the feeling of interacting with an unfamiliar computer system without putting their actual computers at risk.

The game uses a completely virtual archive.

Virtual Filesystem: The in-game archive does not inspect or modify personal files.
Allowlisted Commands: Player input is handled by the game engine, not passed to a real shell.
No eval(): User commands are not dynamically executed as Python code.
Safe Shutdown: The shutdown command only affects the fictional game environment.
AI Output Sanitization: Generated responses are sanitized to prevent rogue ANSI or terminal control sequences.

The objective is to create a convincing horror simulation without turning it into an actual system-level tool.

🧪 Automated Testing

A horror experience can be unpredictable for the player, but the underlying game logic should remain reliable.

The project includes automated tests covering:

Core gameplay functionality.
Clue discovery and file version mutations.
Trust and suspicion changes.
Game state transitions.
Safety boundaries.

Run the tests using:

python -m unittest discover tests

Test result: 17/17 tests passing!

🚀 Quickstart: Enter Terminal Bay 3

Want to experience the game yourself?

GitHub Repository:

https://github.com/tejask011/halloween-vance_Terminal

Requirements

Python 3.10+
rich
prompt_toolkit
requests
Ollama (optional)

For local AI conversations, install Ollama and download a supported model such as llama3.2 or gemma:2b.

Installation

Clone the repository:

git clone https://github.com/tejask011/halloween-vance_Terminal.git

cd halloween-vance_Terminal

Install dependencies:

pip install -r requirements.txt

Start the game:

python run.py

Additional Terminal Themes

Run the game with the phosphor-green theme:

python run.py --theme green

Disable typewriter delays for instant text:

python run.py --fast

Ollama is optional. You can still experience the core game using the deterministic dialogue fallback.

🎃 Final Transmission

THE LAST PROCESS started with a simple idea:

What if we combined the isolation of a terminal, the unpredictability of local AI, and the atmosphere of psychological horror?

I wanted to create something different from a typical chatbot or browser-based horror game.

Something where the interface itself becomes part of the storytelling.

A place where files can lie, timestamps contradict each other, an AI remembers your decisions, and even quitting the game doesn't necessarily mean escaping it.

Building this project also gave me an opportunity to explore local AI integration, deterministic game-state management, terminal UI design, procedural audio effects, and interactive storytelling.

And now, the archive is open.

You have three choices.

SHUT DOWN THE PROCESS.

RELEASE THE ENTITY.

EMBRACE THE LOOP.

But remember...

"You closed the terminal. I never closed the session."

Entity 0 is waiting. Are you coming back? 👁️

Built for Hacktoberfest 2026 – Week 4: Ghost in the Machine.

If you try the game, share your experience and tell me which ending you reached!

devchallenge #hf26challenge #python #ai #opensource

FileNest AI | AI-Powered File Organizer & Storage Analyzer

Tejas Kulkarni — Fri, 23 Oct 2026 14:13:27 +0000

FileNest AI 🌿: A Local AI-Powered File Organizer | Hacktoberfest Week 3

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

What I Built

Meet FileNest AI — an AI-powered file organization and storage analysis application designed to make managing files on your computer simpler and smarter.

As developers and everyday computer users, we accumulate files, duplicate documents, large downloads, and cluttered folders. Finding what is taking up storage or deciding how to organize everything can become a repetitive task.

FileNest AI brings file analysis, duplicate detection, and local AI assistance into one application.

✨ Key Features

📁 File and folder scanning
💾 Storage analysis and folder-size insights
🔍 Large-file detection
♻️ Exact duplicate detection using SHA-256 hashing
🤖 AI-powered file organization suggestions
🗂️ File management operations with user approval
🛡️ Protected files to help prevent accidental modifications
↩️ Activity history and undo support
📊 A dashboard for exploring file and storage insights

The goal is to reduce repetitive file-management work while keeping users in control of the actions performed on their files.

Demo

🎥 Watch the FileNest AI demo:

▶️ FileNest AI — Project Demo on YouTube

The demo showcases the application interface, its file-management workflow, and its AI-powered capabilities.

Code

💻 GitHub Repository:

https://github.com/SamruddhiPatil0078/FileNestAI

The project is open source, and I welcome feedback, suggestions, and contributions!

How I Built It

I built FileNest AI using a modern web stack combined with locally running AI.

Technology stack:

React + Vite: Responsive frontend and interactive dashboard
Tailwind CSS: UI styling
Python + FastAPI: Backend APIs and file-management logic
Ollama: Local inference runtime
Gemma 3 1B: Open-weight language model for AI-powered assistance
SHA-256: Exact duplicate file identification

🧠 Why Gemma 3 1B?

I chose Gemma 3 1B because I wanted to experiment with running an AI model locally rather than depending entirely on a hosted AI API.

The model provides a foundation for AI-assisted file organization while the application handles file scanning, storage analysis, duplicate detection, and file operations.

The project follows a local-first approach, with scanning restricted to a configured directory during development. File operations follow the application's access rules and user-approval workflow.

Building this project has also taught me that integrating an AI model is only one part of creating a useful AI application. The surrounding software architecture, reliable file handling, user experience, and safeguards matter just as much.

Why Does Open Innovation Matter?

Open innovation made it possible to experiment with an open-weight language model and build an AI-powered application without making a hosted, proprietary AI API the core of the experience.

Using Ollama and Gemma 3 1B gave me the opportunity to explore local inference, experiment with model integration, and learn how AI can work alongside conventional backend logic.

It also makes the project easier to explore and extend. Other developers can inspect the code, suggest improvements, experiment with different models, and contribute ideas for smarter file management.

For me, open source is not just about using existing tools. It is about learning from them, building something useful, and making that work available for others to explore.

My Agent Session

I used AI-assisted development while building and refining FileNest AI, particularly when working through integration, debugging, and feature improvements.

The source code and project demo are linked above. I haven't included a DevRelay session link because I don't have a public session URL to share.

The Lazy Payoff 🌿

Imagine spending less time manually searching folders, checking which files consume the most storage, and comparing duplicate files.

FileNest AI brings these tasks into a single workflow and uses local AI to assist with organization decisions.

Instead of making users do all the repetitive analysis themselves, the application helps surface useful information and supports user-approved file-management actions.

The goal: less time managing files, more time building things. 🚀

What's Next?

I'm interested in continuing to improve FileNest AI with better organization workflows, more useful storage insights, and a smoother user experience.

Feedback and contributions are welcome!

If you're interested in AI, local LLMs, Python, React, or open-source development, feel free to check out the repository and share your thoughts.

Thanks for checking out FileNest AI! 🌱

LedgerLens: A Local-First AI Expense Assistant Powered by Open-Weight Models

Tejas Kulkarni — Sat, 17 Oct 2026 10:54:48 +0000

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

LedgerLens: A Local-First AI Expense Assistant Powered by Open-Weight Models

What if you could organize your expenses, discover spending patterns, and get AI-powered financial insights without sending your financial data to a cloud AI service?

That's the idea behind LedgerLens, a local-first AI finance assistant designed to make expense management simpler, more accessible, and privacy-conscious.

What I Built

LedgerLens aims to help freelancers, students, consultants, and small businesses organize expenses without depending on expensive financial management software.

Managing expenses manually can be tedious. Transactions are scattered across spreadsheets, receipts get lost in folders, and understanding where money goes takes time.

LedgerLens brings these tasks together in one application.

Key Features

Import and organize expense records.
Categorize transactions such as food, transport, education, shopping, and subscriptions.
Visualize spending patterns through expense summaries.
Identify potential duplicate transactions for review.
Use AI to assist with expense categorization and natural-language spending queries.
Export organized financial data for further analysis.

The goal is to build a practical tool that helps users save time on routine expense organization.

Demo

Watch the project demo on YouTube:

https://youtu.be/s3iNuo4tmX4

Code

GitHub repository:

https://github.com/tejask011/LegderLens

The project uses a modular architecture so document processing, financial calculations, AI integration, and the user interface can evolve independently.

How I Built It

The key architectural decision was to make local open-weight AI a central part of the application, rather than relying on a hosted proprietary AI API for every request.

Technology Stack

Frontend: React, TypeScript, and Vite
Backend: Python and FastAPI
Database: SQLite for local data storage
Local AI runtime: Ollama
AI models: Compatible open-weight models from the Qwen or Gemma families

The intended workflow combines document processing and deterministic financial calculations with local AI assistance.

The model can help interpret merchant descriptions, suggest expense categories, and explain spending patterns. The application remains responsible for calculations such as transaction totals and category aggregates.

This separation is important: an AI model can suggest an interpretation, but financial totals should be computed and verified by application logic.

Why Does Open Innovation Matter?

For LedgerLens, open innovation is about more than using an open model. It changes how the product can be used and extended.

1. Privacy-first processing

Financial documents may contain sensitive personal and business information. Running a compatible open-weight model locally makes it possible to process that information without sending document contents to a remote AI provider by default.

2. Freedom to choose models

Different users have different hardware and requirements. A model-independent integration makes it possible to experiment with different compatible models as they improve.

3. More predictable AI costs

Local inference avoids mandatory per-request charges from a hosted AI API. Users still need suitable hardware and incur electricity costs, but the core AI workflow does not have to depend on a paid inference service.

4. An application the community can extend

An open-source foundation allows contributors to improve document extraction, add expense categories, introduce import/export formats, test alternative models, and enhance accessibility.

The goal is to build a practical finance assistant that users can inspect, customize, and improve rather than locking the entire experience to one AI provider.

What's Next?

I'm looking forward to improving LedgerLens with:

Better invoice and receipt extraction.
More reliable expense categorization.
Duplicate detection and recurring expense insights.
Improved reporting and export options.
Additional local model integrations.
More tests, documentation, and contributor-friendly issues.

I want the project to grow into something that solves a real problem while demonstrating why open-weight AI can be useful in everyday software.

Join the Conversation

If you work with local AI, open-source models, or personal finance tools, I'd love to hear your thoughts.

What feature would make a local-first expense assistant most useful to you?

Would you prioritize automatic receipt extraction, smarter categorization, recurring expense detection, or more detailed reports?

Thanks for checking out LedgerLens!

Hacktoberfest #OpenSourceAI #LocalAI #Ollama #OpenSource #SideHustle

TinyGarden AI 🌿 — Touch Grass with Local Open-Weight AI & Privacy-First Gardening

Tejas Kulkarni — Sat, 10 Oct 2026 09:40:42 +0000

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

🌿 What I Built

TinyGarden AI is an open-source, local-first botanical assistant and garden calendar hub built to get people off their screens, outdoors, and touching grass.

Many beginners want to cultivate fresh herbs, grow home vegetables, or plant trees, but get overwhelmed by confusing advice, overwatering, or unidentified leaf pests. Existing gardening apps force users to sign up for paid cloud AI subscriptions, share location data, and stay tethered to the cloud.

TinyGarden AI changes that by putting an intelligent, privacy-first botanical guide right on your computer. Powered 100% by local open-weight AI models via Ollama, it runs with zero paid cloud APIs, zero credit cards, and zero data telemetry.

🚀 Key Features to Help You Touch Grass:

💬 1-on-1 AI Botanical Chat: Ask real-time questions about soil mix, organic composting, pruning, and crop choices.
🔍 Plant Health & Vision Diagnostic Helper: Upload a leaf photo or describe symptoms to receive instant diagnosis and step-by-step organic remedies.
📅 Interactive Garden Calendar & Reminders: A Google Calendar-style month grid with event chips for Watering (💧), Soil & Fertilizer (🌱), Pruning (✂️), Pest Inspection (🐛), and Harvesting (🍎).
📝 Garden Journal: Record your plant observations, soil preparation logs, sapling growth notes, and harvesting milestones.
🌳 Tree Plantation Planner: Generate customized blueprints for community tree plantation drives (shade trees, fruit orchards, eco-restoration) complete with spacing math and pit prep guides.

📺 Demo

Youtube:
https://youtu.be/oyvF393p5QA
GitHub Repository: [https://github.com/tejask011/Hacktober_TInyGarden]

📸 Application Highlights

Google Calendar Month View: Track watering & care tasks on an interactive month grid.
1-on-1 AI Assistant: Live streaming chat powered by Ollama running locally.
Plant Health Scanner: Upload foliage photos for organic treatment recipes.

💻 Code

tejask011 / Hacktober_TInyGarden

TinyGarden AI 🌿 — Local-First Botanical AI & Garden Assistant

Hacktoberfest 2026 Open-Source AI Challenge Submission (#hf26challenge)

TinyGarden AI is a privacy-first, offline-capable AI botanical assistant and garden calendar hub built for Hacktoberfest 2026. It operates entirely on open-weight language models (gemma2:2b, llama3.2, mistral) running locally via Ollama, with zero dependence on paid cloud APIs, external tracking, or proprietary subscription keys.

🌟 Key Features

1. 💬 1-on-1 AI Botanical Chat

Interactive real-time chat interface powered by local open-weight AI.
Instant advice on plant care, soil prep, organic composting, pruning, and pest control.
Quick prompt pills for one-click questions.

2. 🔍 Plant Health & Vision Helper

Symptom-based foliar diagnostic scanner with photo upload support.
Identifies likely causes (nitrogen deficiency, overwatering, fungal mildew, pest infestation) with step-by-step organic remedies.

3. 📅 Interactive Garden Calendar & Reminders (Google Calendar Layout)

Full interactive Month Grid View with event pills…

View on GitHub

# Clone and run locally in under 2 minutes
git clone https://github.com/tejask011/Hacktober_TInyGarden.git
cd Hacktober_TInyGarden

# Backend Setup
cd server && npm install && npm start

# Frontend Setup (in a new terminal)
cd ../client && npm install && npm run dev

🛠️ How I Built It

This was my very first time building an application with Ollama, and the experience was incredible!

Open-Source AI Stack:

Local AI Inference Engine: Ollama running open-weight models (gemma2:2b, llama3.2, mistral).
Frontend: React 19 + Vite, Vanilla CSS + Tailwind CSS utilities, Lucide React Icons.
Backend: Node.js + Express REST API.
Offline Knowledge Base: Local JSON database (server/data/gardening_knowledge.json) integrated into the local LLM prompt chain.

How Open-Source AI Powers TinyGarden:

When a user asks a question or scans a leaf symptom, Express constructs a context-aware prompt enriched by the local botanical database.
The prompt is sent to the local Ollama API endpoint (http://127.0.0.1:11434/api/generate).
The open-weight model streams back personalized organic advice directly to the React frontend.
If Ollama is offline, a built-in rule engine acts as an instant fallback so the app remains 100% functional offline.

🔓 Why Does Open Innovation Matter?

Open innovation and open-weight AI matter deeply for projects like TinyGarden AI:

True Privacy: Your gardening notes, balcony location details, and plant logs never leave your device.
Zero Subscription Barrier: Anyone with standard hardware can run state-of-the-art open models like gemma2:2b or llama3.2 for $0.00 in cloud API fees.
Offline Resilience: Whether you are in a remote backyard garden, a community farm, or an outdoor tree plantation site without internet, your AI assistant continues to work seamlessly.

Closed proprietary APIs lock users behind monthly paywalls and API rate limits. Open-weight models democratize AI technology for everyone.

🏆 Prize Categories

Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass (Main Track)

Built with ❤️ for Hacktoberfest 2026! Happy gardening and don't forget to touch grass! 🌿

DEV Community: Tejas Kulkarni

What if closing a terminal didn't mean the thing inside it was gone?👻👁️

👁️ THE LAST PROCESS: I Built a Horror Game Where the AI Remembers You Even After You Quit

A psychological horror experience inside a terminal, powered by Python and local open-weight AI.

💡 What I Built

👁️ The Core Story: Welcome to Project Erebos

🎮 Gameplay: More Than Just a Terminal

1. Interactive Terminal HUD

2. Hardware-Level Terminal Audio

3. ASCII CCTV Surveillance — [C]

4. Power and Sanity Mechanics

5. Jumpscares, Reflections and CRT Glitches

6. Files That Rewrite Themselves

7. The Terminal Itself Lies

8. Controlled Silence

9. Persistent Memory Across Sessions

10. Three Consequential Endings

🛠️ The Ghost in the Machine: Why Open-Source AI Matters

The Architecture

How the Separation Works

Why Local Open-Weight AI Fits This Project

🔒 Safety by Design: The Horror Stays Inside the Game

🧪 Automated Testing

🚀 Quickstart: Enter Terminal Bay 3

Requirements

Installation

Additional Terminal Themes

🎃 Final Transmission

devchallenge #hf26challenge #python #ai #opensource

FileNest AI | AI-Powered File Organizer & Storage Analyzer

What I Built

✨ Key Features

Demo

Code

How I Built It

🧠 Why Gemma 3 1B?

Why Does Open Innovation Matter?

My Agent Session

The Lazy Payoff 🌿

What's Next?

LedgerLens: A Local-First AI Expense Assistant Powered by Open-Weight Models

LedgerLens: A Local-First AI Expense Assistant Powered by Open-Weight Models

What I Built

Key Features

Demo

Code

How I Built It

Technology Stack

Why Does Open Innovation Matter?

1. Privacy-first processing

2. Freedom to choose models

3. More predictable AI costs

4. An application the community can extend

What's Next?

Join the Conversation

Hacktoberfest #OpenSourceAI #LocalAI #Ollama #OpenSource #SideHustle

TinyGarden AI 🌿 — Touch Grass with Local Open-Weight AI & Privacy-First Gardening

🌿 What I Built

🚀 Key Features to Help You Touch Grass:

📺 Demo

📸 Application Highlights

💻 Code

tejask011 / Hacktober_TInyGarden

TinyGarden AI 🌿 — Local-First Botanical AI & Garden Assistant

🌟 Key Features

1. 💬 1-on-1 AI Botanical Chat

2. 🔍 Plant Health & Vision Helper

3. 📅 Interactive Garden Calendar & Reminders (Google Calendar Layout)

🛠️ How I Built It

Open-Source AI Stack:

How Open-Source AI Powers TinyGarden:

🔓 Why Does Open Innovation Matter?

🏆 Prize Categories

3. ASCII CCTV Surveillance — `[C]`