DEV Community: Samruddhi Patil

THE LAST PROCESS: What If Your Terminal Wasn't Just Running Code… But Watching You?-Title

Samruddhi Patil — Fri, 30 Oct 2026 16:37:52 +0000

💡 What I Built

THE LAST PROCESS is a 100% pure, native terminal horror game built in Python using rich and prompt_toolkit. It connects to local open-weight models via Ollama (e.g. gemma:2b, llama3.2, or mistral) to give life to Entity 0—an evasive heuristic monitor trapped in an abandoned research station console.

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

Meet THE LAST PROCESS — a psychological horror game that turns an ordinary terminal into an abandoned research station, where something is watching, responding, and slowly revealing that you might not be who you think you are.

👁️ Welcome to Project Erebos

You enter Terminal Bay 3 as an operator investigating an abandoned research facility. At first, everything seems normal. You find operator logs, system records, and surveillance feeds.

But the deeper you investigate, the stranger things become.

Files begin rewriting themselves when you read them again.

The terminal reports files that don't exist.

CCTV feeds reveal something standing behind your console.

Timestamps contradict each other.

Entity 0 starts remembering your previous interactions.

And the worst part? Even if you quit the game and return later, Entity 0 remembers you.

🤖 A Little AI, A Lot of Horror

I built the experience using Python, Rich, and prompt_toolkit, with local AI integration through Ollama.

Models like Gemma, Llama, and Mistral give Entity 0 its own conversational personality. But the AI doesn't control the story. The game engine manages the actual events, clues, decisions, and endings, keeping the narrative consistent.

Even without Ollama, the game works using a deterministic dialogue fallback.

🎮 More Than Just a Terminal

The experience includes:

Interactive terminal HUD with keyboard navigation.

Synthesized horror audio using Python's winsound.

ASCII CCTV surveillance feeds.

Power and sanity mechanics.

CRT glitches, sudden visual anomalies, and controlled silence.

Three different endings based on your decisions.

Persistent memory across sessions.

🔒 Built to Be Safe

Despite looking like a real system terminal, the entire environment is virtual. It never accesses your personal files, executes shell commands, or performs actual system shutdowns.

The horror stays inside the game.

🚀 Try to Escape

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

Requirements: Python 3.10+ (Ollama is optional).

Clone the repository, install the requirements, and run python run.py.

Final Transmission

I wanted to experiment with something different: combining local open-weight AI with interactive storytelling and psychological horror.

The result is a terminal that doesn't just respond to your commands. It remembers your decisions, questions your identity, and makes you wonder whether ending the session is really the end.

Entity 0 is waiting.

Will you shut it down, release it, or become part of the loop? 👁️

Instead of demanding users blindly type long bash paths, the game delivers an authentic interactive terminal experience:

Interactive Terminal HUD: Instantly navigate files and actions using number keys ([1] to [5]) or direct conversation.
Hardware-Level Terminal Audio (Synthesized via winsound): Psychological heartbeat pulses, electric capacitor static, flatlines, and dissonance screeches directly from your speakers.
ASCII CCTV Surveillance Cameras ([C]): Inspect live sensor feeds of Terminal Bay 3—where an anomalous figure appears behind your console as power drains.
Power & Sanity Mechanics: Station power drains from 100% to 12% as you uncover forbidden records, accelerating your pulse to 135 BPM and triggering emergency lighting.
Jumpscare Reflections & Screen Glitches: Sudden CRT anomalies and screaming reflections in unallocated memory sectors.
Files that rewrite themselves when you reread them after discovering new evidence.
The terminal itself lying to you—reporting file counts that do not match the directory listing, and manifesting forbidden files.
Contradictory timestamps where telemetry logs claim the entity was killed minutes before it logged an operator's departure.
Controlled silence pauses where the entity hesitates and waits for you to stop typing.
Persistent memory across reboot sessions—if you quit or shut the game down, the entity remembers your previous choices when you launch it again.
A secret identity twist: discovering the final log reveals that the previous operator, the entity, and the person typing at the console are locked in an infinite repeating cycle.

👻 The Core Story

You log into Terminal Bay 3 of an empty facility known as Project Erebos.

Your job as an operator is to check the station archive. Initial records show everything is ordinary:

operator_log.txt: Operator Arthur Vance reports that Entity 0 was shut down at 23:40:00.
departure.log: Automated facility telemetry.

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%.

When you confront Entity 0 about the discrepancy, it attempts to reassure you:

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

Soon, an unallocated memory pointer manifests: recovery_note.txt. Reading it reveals a frantic warning left behind by Vance:

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

And when you return to operator_log.txt and reread it, the text has mutated:

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

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

A common flaw in AI-driven narrative games is that language models hallucinate uncontrollably, breaking game rules or spoiling the mystery too early.

THE LAST PROCESS solves this by strictly separating canonical fact ownership from dialogue expression:

+─────────────────────────────────────────────────────────────+
│                       GAME ENGINE                           │
│  Owns: Canonical Timeline • Clue Unlocks • Suspicion/Trust  │
│        Ending Conditions • Persistent Save File             │
+──────────────────────────────┬──────────────────────────────+
                               │ Bounded Context
                               ▼
+─────────────────────────────────────────────────────────────+
│                     AI ADAPTER LAYER                        │
│  Queries Local Ollama (Gemma / Llama) with Bounded Facts    │
│  + 100% Deterministic Fallback if Ollama is Offline         │
+──────────────────────────────┬──────────────────────────────+
                               │ Sanitized Text
                               ▼
+─────────────────────────────────────────────────────────────+
│                     RICH TERMINAL UI                        │
│  Amber CRT Themes • Teletype Cadence • Silence Pauses       │
+─────────────────────────────────────────────────────────────+

Why Local Open-Source AI Fits the Theme:

True Isolation & Atmosphere: Running locally via Ollama means zero cloud latency, zero network calls, and complete offline privacy. You are genuinely alone in the dark with a model running on your local hardware.
Deterministic Fallbacks: If you don't have Ollama running, the game never crashes or fails. It switches seamlessly to a deterministic scripted dialogue engine that preserves the exact same horror narrative.
Safety by Design:
- The archive is 100% virtual: It never inspects or touches your real filesystem.
- Command input is allowlisted: Your keystrokes are never passed to a real shell or eval().
- The shutdown command is strictly in-game: It will never execute an OS shutdown.
- AI outputs are sanitized to strip ANSI injection or rogue control sequences.

🎮 Gameplay Features Showcase

1. Persistent Memory Across Sessions

If you exit the game after making a choice, the next boot detects your past actions:

[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. You knew a signal alone cannot erase what lives here.

2. The Terminal Appears to Lie

operator > ls
operator_log.txt
departure.log
recovery_note.txt

SYSTEM > 4 ARCHIVE ENTRIES FOUND.

Why did it report 4 entries when only 3 are listed? Moments later, dont_read_this.txt appears in the unallocated memory sector.

3. Silence & Controlled Suspense

When you ask a sensitive question, the terminal pauses:

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.

4. Consequential Endings

Once the contradiction is exposed and identity_record.log is uncovered, you face three moral paths:

[1] SHUT DOWN THE PROCESS: Sever the cognitive bridge and purge memory sectors.
[2] RELEASE THE ENTITY: Route Entity 0 into the open external network.
[3] EMBRACE THE LOOP: Acknowledge that you and Arthur Vance share the same cognitive record, and initialize the next cycle.

🚀 Quickstart: Try It Yourself

Requirements

Python 3.10+
rich, prompt_toolkit, requests
(Optional) Ollama with llama3.2 or gemma:2b

Run:

git clone https://github.com/your-username/the-last-process.git
cd the-last-process
pip install -r requirements.txt

# Run with Amber CRT mainframe theme
python run.py

# Or run with phosphor-green styling
python run.py --theme green

# Run with instant text mode (no typewriter delay)
python run.py --fast

🧪 Automated Testing

The project includes unit tests for all 9 core features, clue version mutations, trust/suspicion shifts, and safety boundaries:

python -m unittest discover tests

Result: 17/17 tests passing!

🎃 Conclusion

"Ghost in the Machine" is about finding humanity, mystery, and eerie life inside open-source artificial intelligence. THE LAST PROCESS demonstrates how you can pair open-weight models with a strict, safety-first state machine to create an unforgettable, narrative-driven horror experience in your own terminal.

Happy Hacktoberfest! 👻💻

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

Samruddhi Patil — Fri, 23 Oct 2026 14:06:24 +0000

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

Samruddhi Patil — Sun, 18 Oct 2026 08:14:32 +0000

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

TouchGrass 🌿 — Turning Screen Time into Outdoor Adventures with Local AI | Hacktoberfest 2026

Samruddhi Patil — Sat, 10 Oct 2026 07:40:57 +0000

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

What I Built

🌿 TouchGrass — A little less scrolling. A lot more wonder.

TouchGrass is an AI-powered outdoor adventure companion that encourages people to take a break from their screens and reconnect with nature.

Sometimes, we want to go outside but don't know what to do. TouchGrass solves this by generating personalized outdoor quests based on the user's mood, available time, and preferred adventure style.

✨ Key Features

AI-Generated Quests: Generate personalized outdoor adventures with four activities.
Mood-Based Personalization: Choose a mood that matches how you feel.
Flexible Duration: Choose a 15, 30, or 60-minute adventure.
Adventure Styles: Choose from different nature-focused experiences, such as mindful walks and nature exploration.
Task Checklist and XP: Complete activities and earn experience points.
Adventure Journal: Save completed quests and personal reflections.
Progress Dashboard: Track completed quests, XP, streaks, and achievement badges.

The goal is simple: use AI to encourage real-world experiences instead of spending more time scrolling.

Demo

🌐 Live Website: TouchGrass

🎥 Video Demo: Watch TouchGrass in action

Code

💻 GitHub Repository: SamruddhiPatil0078/TouchGrass

Explore the source code, project structure, setup instructions, and implementation.

How I Built It

I built TouchGrass using React, Vite, Tailwind CSS, React Router, and Lucide React for the frontend and user interface.

For the AI component, I used Gemma 3 1B, Google's open-weight language model, running locally through Ollama.

How It Works

The user selects their mood, available time, and preferred adventure style.
The application sends a prompt to the locally running Ollama model through the Vite development proxy.
Gemma 3 1B generates a personalized outdoor quest containing four activities.
The user completes activities, checks them off, and earns XP.
Completed quests and reflections can be revisited through the journal and progress dashboard.

I also used browser localStorage to retain quest history and progress locally.

One of my main goals was to make AI useful beyond the screen. Rather than using AI only to answer questions or generate content, TouchGrass uses it to encourage people to step outside and experience the world around them.

The frontend is deployed on Vercel. The AI generation currently relies on a locally running Ollama service, so online AI functionality requires additional deployment configuration.

Why Does Open Innovation Matter?

Open innovation made it possible for me to experiment with an open-weight AI model and build an AI-powered application without depending on a paid hosted AI API.

Using Gemma 3 1B through Ollama gave me the opportunity to explore local inference and understand how an AI model can be integrated into a real-world web application.

Open-source tools also make it easier for other developers to explore the code, learn from the implementation, and contribute improvements.

For me, open innovation is about making technology more accessible and giving developers the freedom to experiment, build, and share their ideas.

TouchGrass reflects that belief: technology should help us live better, not keep us glued to our screens.

Prize Categories

Gemma — Best Use of Gemma: Used Google's open-weight Gemma 3 1B model through Ollama for local inference to generate personalized outdoor adventure quests based on users' moods, available time, and preferred adventure styles.

Built with 🌿 to encourage a little less scrolling and a lot more wonder.

devchallenge #hf26challenge