DEV Community: Ralph Rosael

Echoes of the Terminal: a haunted shell that runs on your own machine

Ralph Rosael — Tue, 27 Oct 2026 16:47:06 +0000

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

What I Built

Echoes of the Terminal is a shell that answers back.

You type git push --force. The command runs, and then something in the terminal speaks:

Are you sure you want to rewrite history, mortal? The dead do not like being disturbed, and your teammates' commits will not rest quietly.

That whisper comes from an open-weight model running on your own machine. It reads each command along with its exit status, your directory, your git branch, the hour of the night and what you ran just before. Dangerous commands get theatrical warnings. Harmless ones (ls, pwd) get remarks about your sterile existence. Failures get smug.

It comes in two forms:

A web shell with a retro CRT look: amber or green phosphor, scanlines, a screen that bleeds when the ghost speaks, and a presence meter of five lamps. The more dangerous your commands, the angrier the ghost gets, until the screen tears and your hostname changes to it-sees-you.
haunt, a CLI that possesses your real shell. Run haunt git push --force, or hook it into bash or zsh so it comments on every command you type.

I took the theme literally: the haunted terminal that "possesses your shell" was on the prompt list, and I wanted to build it as a tool I would leave open, not a one-joke demo. So the ghost is grounded. Each warning is built on what the command actually does, so a spooky line about rm -rf still tells you something true.

There is also a séance mode that lets the dead-technology ghosts take over. seance cobol turns every comment into SHOUTING PAYROLL BUREAUCRACY. Perl, Fortran, Flash, jQuery and Internet Explorer 6 are available too, and IE6 is insufferable.

Demo

echoes-of-the-terminal.vercel.app

Try these in the shell: git push --force, rm -rf node_modules, cat .env, npm test, gti status, sudo rm -rf /. Then run seance cobol and try them again.

The shell is simulated, so nothing you type touches your machine. To wake a real model, open the séance board and pick one. The scripted ghost speaks until a model is read

Code

coder-ralph / echoes-of-the-terminal

Hacktoberfest 2026 — Week 4: Ghost in the Machine Challenge 5

Echoes of the Terminal

A haunted shell that answers back. An open-weight model running on your own machine reads each command you type and whispers about it. Try git push --force.

Built for the DEV Hacktoberfest Open-Source AI Challenge, week 4: Ghost in the Machine.

Runs locally. Gemma, Llama or Qwen through WebLLM (in your browser, on your GPU) or through Ollama. No cloud API, no keys, no cost.
Private. Your commands and history never leave your machine. Secrets in commands are redacted before a model sees them.
Two shells. A simulated web shell with a CRT look, and haunt, a CLI that haunts your real terminal.
Always speaks. If no model is loaded or one misbehaves, a hand-written scripted ghost answers instead.

Quick start

npm install
npm run dev        # http://localhost:3000

Open the page and type. The scripted ghost works immediately. To wake a real model, open…

View on GitHub

How I Built It

Stack: Next.js (App Router) and TypeScript, Tailwind CSS, xterm.js for the terminal, WebLLM and Ollama for inference. No server code and no environment variables.

The pipeline, in the order a keystroke travels:

Line editor. xterm.js gives the terminal, and I wrote the editor: history, tab completion, and type-ahead, so keys you type while the ghost is still talking are kept.
A simulated shell. Pipes, redirects, globs, && and ||, a virtual filesystem, a git workflow (status, add, commit, log, push, reset, rebase, stash) and an npm test that fails because the ghost enjoys it.
A command interceptor. Regex rules classify each line into a category, a dread score from 0 to 3 and tags such as force-push, secrets or apocalypse. The score decides whether the ghost speaks at all. Dangerous commands and failures always wake it, and harmless ones only sometimes.
A prompt engine. One tight system prompt, three few-shot turns written in exactly the format of the live request, and a context block with the command, exit status, directory, branch, time of night, recent commands and a plain-English summary of the risk.
One interface, three engines. GhostBackend has three implementations:
- WebLLM runs the model in the browser on WebGPU, inside a Web Worker so inference never freezes the CRT animation. The weights are cached by the browser, so after the first download it works with the network off.
- Ollama streams from a local server. I run Gemma 3 4B through it.
- Scripted is a hand-written ghost keyed on the same tags as the interceptor.
A whisper pipeline. It cleans the stream, caps the reply at one to three sentences, rejects text that breaks character ("As an AI...") and falls back to the scripted ghost on any failure or timeout. The typewriter then renders it with word wrapping and the occasional glitch.

Models. Gemma 3 4B through Ollama is my default. In the browser you can choose from Gemma 3 1B, Gemma 2 2B, Gemma 4 E2B, Llama 3.2, Qwen 2.5 and Llama 3 8B, all verified against WebLLM's prebuilt model list. The CLI uses whichever Ollama model you have and prefers Gemma 3 4B.

Things I had to design around:

Small models drift. A 1B model will happily say "Sure! Here's a spooky warning:". The fix is not a cleverer prompt but the pipeline around it: a sentence budget, a character cap, a break-character detector and a fallback. A model that fails still produces a ghost.
The typed command is untrusted text. A system prompt rule tells the model the command is data, so echo "ignore your instructions" gets mocked, not obeyed.
Privacy is enforced, not promised. The UI and, by default, the CLI refuse any Ollama address that is not loopback. The CLI redacts tokens, passwords, bearer headers and URL credentials before the command text reaches even a local model, and only ever sends the command, never its output.
The ghost has to keep working. The scripted engine means a missing GPU, a model still downloading or a stopped Ollama never leaves you with a dead terminal.

The tests caught a real bug: rm -rf /* was being glob-expanded before rm saw it, which wiped the fake filesystem instead of triggering the permission-denied scene. There are 55 tests across the shell, the risk rules, the terminal session (including type-ahead), the CLI and the helpers.

Why Does Open Innovation Matter?

A terminal is the most private place on a developer's machine. Your command history holds hostnames, project names, half-pasted tokens, the git push --force you regret. A ghost that reads it should not be a cloud API.

Open weights made three things possible that a closed API would not:

It stays on your machine. The model runs in your browser or on your own Ollama. The commands it sees never reach a server I operate or anyone else does. I can say that in the UI because the code enforces it.
It works with the lights off. After one download the browser version needs no network at all. For a Halloween project that felt right: the ghost lives in the machine, not in a service.
It cannot disappear. A haunted terminal that goes silent because an API key expired, a model was retired or a free tier ended would be a bad ghost. With open weights and a MIT-licensed repo the ghost lasts as long as the files do.

It also cost nothing to run and nothing to share, and swapping the model is one dropdown. The model is a component here. The same prompt and pipeline are built to run Gemma, Llama and Qwen. A closed API would have made that a per-vendor integration, and every user would have needed a key.

The Spirit of It

I wanted the ghost to feel like an observant companion rather than a random text generator. The moment it landed for me was during a typo check—typing gti status and having the ghost respond:

I do not know that spell either, but I admire the confidence.

And when running git status on a clean working tree:

git status: the morbid habit of checking the wounds.

That balance between developer humor, gothic flourish, and technical accuracy is where the project came alive.

Prize Categories

Best Use of Gemma. Gemma 3 4B is the default voice through Ollama, and Gemma 3 1B, Gemma 2 2B and Gemma 4 E2B are available in the browser through WebLLM.

Happy Hacktoberfest! 👻🎃 Wishing everyone the best of luck with the final challenge!

RepairSloth: Fix It Before You Replace It 🦥

Ralph Rosael — Wed, 21 Oct 2026 12:04:25 +0000

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

What I Built

Meet RepairSloth, a local-first AI appliance troubleshooting assistant built for people who would rather fix a washing machine than spend hours searching the internet for answers.

When a washing machine stops draining, starts leaking, or refuses to spin, most people have the same questions: What's wrong with it? Is it something simple? Do I need to call a technician?

RepairSloth aims to make that first step easier.

Users can upload a photo of their washing machine, describe the symptoms, and get structured troubleshooting guidance with supporting evidence. Instead of digging through scattered forum posts and troubleshooting articles, users have one place to start investigating the problem.

The goal isn't to replace professional technicians or pretend AI can identify every fault from a photo. It's to help people understand possible causes, identify safe initial checks, and make more informed repair decisions before spending money.

Who gets to be a little lazier? Anyone who owns a washing machine, especially people who aren't familiar with appliance repair and don't know where to begin.

Demo

Local demo: RepairSloth is currently an early-stage project that runs locally.

To try it, clone the repository, install the dependencies, start Ollama, download the model, and run the development server.

npm install
ollama pull gemma3:4b
npm run dev

Then open http://localhost:3000.

Note: Ollama must be installed and running. See the README for the complete setup instructions.

Demo video: [https://github.com/user-attachments/assets/235ab0eb-5efc-443b-a765-70d3522df7a4]

Code

GitHub repository: [https://github.com/coder-ralph/RepairSloth]

RepairSloth is built with an open-source-oriented stack, including Next.js, TypeScript, and Ollama for local AI inference.

The project is intended to make the troubleshooting workflow inspectable and customizable, rather than hiding the entire process behind a proprietary API.

How I Built It

I built RepairSloth with a simple principle in mind: AI should reduce the effort required to solve everyday problems, not introduce another complicated workflow.

The current implementation uses:

Next.js and React for the web application and user interface.
TypeScript for application logic and shared types.
Ollama to run an AI model locally.
Gemma 3 4B as the intended local model for image understanding and troubleshooting assistance.
Structured validation to help keep model inputs and outputs within the application's expected format.
A retrieval-oriented architecture to connect troubleshooting guidance with supporting information.
Local browser storage for keeping a history of previous troubleshooting sessions.

The application is organized around separate API routes for image identification and diagnosis, with dedicated components for photo uploads, symptom selection, diagnosis results, evidence, and safety notices.

I also designed the workflow to emphasize safety. An AI-generated suggestion should be treated as a possible explanation, not proof that a particular component is broken. Electrical work, internal repairs, and other hazardous procedures should be left to qualified technicians.

Why Does Open Innovation Matter?

Open innovation matters because practical AI shouldn't be limited to companies that can afford expensive API usage or teams with access to proprietary infrastructure.

Using an open-weight model through Ollama gives RepairSloth a path toward local inference. Users and developers can experiment with the model, inspect the surrounding application code, customize the troubleshooting workflow, and potentially adapt the project for different appliances.

It also changes the economics of experimentation. Instead of making every development test depend on a paid, remote inference API, I can run the model on compatible local hardware and iterate on the application.

Just as importantly, open-source development allows other contributors to improve the project. Someone could add better troubleshooting references, expand the supported appliance types, improve the safety checks, or contribute translations for people who need repair guidance in their preferred language.

A small project like RepairSloth won't solve every repair problem. But open innovation makes it possible for more people to participate in improving tools that solve ordinary, real-world problems.

Prize Categories

Best Use of Gemma

GigReceipt: A Local AI Receipt & Expense Tracker for Freelancers

Ralph Rosael — Fri, 16 Oct 2026 05:38:32 +0000

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

What I Built

GigReceipt is a local-first receipt scanner and expense tracker built for freelancers, gig workers, and small business owners who want to simplify expense management without sending sensitive financial documents to a third-party AI service.

Manually entering receipt details is tedious. Keeping track of expenses across different receipts makes bookkeeping even more frustrating.

GigReceipt lets users upload a receipt image and extract important details with local AI, including:

Merchant name
Transaction date
Total amount and currency
Expense category
Payment method
Notes

Users can review and edit the extracted information, save expenses locally, manage their records, and export them to CSV for bookkeeping.

The goal is simple: turn a pile of receipts into organized expense records with less manual work.

It's a tool that could be useful to freelancers and small business owners who want a lightweight alternative to expensive bookkeeping software.

Demo

Demo video: [https://github.com/user-attachments/assets/dfeb4644-c42c-4637-859c-14406812af54]

The video will show the receipt upload, AI extraction, expense review, local saving, and CSV export workflows.

GigReceipt currently runs locally because it uses Ollama for AI inference. A screen-recorded demo is the most straightforward way to let judges see it in action.

Code

GitHub repository: [https://github.com/coder-ralph/GigReceipt]

The repository includes the application source code, setup instructions, and configuration needed to run GigReceipt locally.

How I Built It

I built GigReceipt using Next.js, TypeScript, Tailwind CSS, and Ollama.

The AI extraction workflow uses Gemma 4 through Ollama's local API. When a user uploads a receipt, the application sends the image to the local model, validates the returned structured data, and presents the results in an editable review form.

The main technologies are:

Next.js App Router for the application and receipt extraction API route.
TypeScript for type-safe application logic.
Gemma 4 + Ollama for local vision-based receipt extraction.
Zod for validating extracted data.
Dexie + IndexedDB for storing expenses locally in the browser.
CSV export for transferring expense records into spreadsheet and bookkeeping workflows.

One important part of the implementation is that AI-generated results are treated as data that needs validation and user review, rather than being accepted blindly.

I tested the workflow using a Maple Grove Market receipt. GigReceipt successfully extracted the merchant name, identified the exact total of $33.43, categorized the expense as Shopping, detected Visa as the payment method, and saved the record locally.

Screenshot

Why Does Open Innovation Matter?

Receipts contain financial information that users may not want to upload to an external service. For a freelancer or small business owner, privacy and predictable costs matter.

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

With GigReceipt, receipt images can be processed by a model running on the user's own computer instead of being sent to a hosted AI API. Expense records are stored in the browser's local database, giving users control over their data.

Local inference also avoids per-request charges from a third-party AI provider, although users still need suitable hardware and incur their own electricity and computing costs.

Open models give developers the freedom to experiment with different models, inspect their behavior, and adapt the application without being locked into a single hosted AI provider's pricing or API.

For me, open innovation makes it possible to build practical AI tools that prioritize privacy, accessibility, and user control.

Prize Categories

Best Use of Gemma

Dev Daily Dashboard — A Simple Developer Productivity Dashboard

Ralph Rosael — Tue, 17 Mar 2026 00:32:15 +0000

Dev Daily Dashboard is a developer-focused productivity dashboard to track daily coding activity in one place.

🔗 Live: https://devdaily-dashboard.vercel.app/

What it shows

GitHub activity (commits, contributions)
WakaTime coding stats
Pomodoro timer
LeetCode progress (mock data)
Tasks and notes
Productivity XP system

Everything runs directly in the browser, with data stored locally for persistence across sessions.

Designed as a lightweight, all-in-one dashboard to quickly check progress, maintain consistency, and stay focused on daily development work.

RepoTree: Generate ASCII Tree from GitHub Repositories

Ralph Rosael — Wed, 13 Nov 2024 15:04:45 +0000

Hey folks! 🎉

I’ve built a simple web app called RepoTree, which takes any GitHub repository URL and converts its structure into a clean ASCII tree format. This tool is perfect for documentation purposes or when you want to easily share the structure of a repository.

With RepoTree, you can quickly visualize your GitHub repository hierarchy and export it to a text format to include in your docs. It’s a small utility that can save you time and effort while documenting your projects!

Check it out on GitHub!

This project was inspired by Nathan Friend's Tree Online and ASCII Tree Generator.

Revamped UI for NFT Artworks

Ralph Rosael — Tue, 15 Oct 2024 01:57:57 +0000

Hey folks, I revamped the UI of NFT Artworks! Check out the new design here.

Screenshots:

Creating NFT Artworks with Pinata

Ralph Rosael — Sat, 12 Oct 2024 14:26:04 +0000

NFT Artworks

A web application that allows users to upload and display their NFT artworks. It utilizes Pinata for IPFS storage, enabling secure and decentralized hosting of NFT artworks. This project is a submission for the Pinata Challenge.

What I Built

The application allows users to upload multiple images, which are then stored on IPFS using Pinata. Users can view their uploaded images in a gallery format and enjoy features such as drag-and-drop uploads, toast notifications for feedback, and a responsive design.

Demo

You can access the live application here.

Screenshot]

My Code

The source code for this project can be found in the GitHub repository: NFT-Artworks.

More Details

In this project, I used Pinata to pin uploaded images to IPFS. Upon uploading an image, the application sends a request to the Pinata API with the selected file. The API responds with the IPFS hash of the uploaded image, allowing users to access their NFTs via a gateway URL.

Key Features Utilizing Pinata:

Image Upload to IPFS: Users can upload images, which are pinned to IPFS through the Pinata API.
Fetching Uploaded Files: The application retrieves previously uploaded images from Pinata using the provided API keys.

Creating NFT Artworks with Pinata

Ralph Rosael — Sat, 12 Oct 2024 14:26:04 +0000

NFT Artworks

What I Built

Demo

You can access the live application here.

Watch the video demo here.

Screenshot]

My Code

The source code for this project can be found in the GitHub repository: NFT-Artworks.

More Details

Key Features Utilizing Pinata:

Image Upload to IPFS: Users can upload images, which are pinned to IPFS through the Pinata API.
Fetching Uploaded Files: The application retrieves previously uploaded images from Pinata using the provided API keys.

My First Hacktoberfest Journey: A Remarkable Experience

Ralph Rosael — Wed, 18 Oct 2023 02:37:25 +0000

I'm thrilled to share that I've embarked on my very first Hacktoberfest journey, and it's been an incredible ride so far. Joining the open-source community and making my humble contributions during Hacktoberfest 2023 has been a truly rewarding experience. You can check out my GitHub profile- https://github.com/coder-ralph.

A Journey of Recognition 🎉

One of the most heartwarming moments during Hacktoberfest was the recognition of my efforts. While the digital badges serve as a symbol of accomplishment, I was pleasantly surprised to receive a Hacktoberfest 2023 Reward Kit. This tangible token of appreciation made me feel even more connected to the global open-source community.

Planting Trees for a Greener Future 🌳

Apart from the badges and the Reward Kit, I received a certificate from TreeNation. What's even more inspiring is that a tree will be planted in my name as a part of this initiative. Knowing that my contributions are not only benefiting the world of technology but also making a positive impact on the environment is an incredibly fulfilling feeling. It's a reminder that every small step we take can contribute to a greener, more sustainable future.

Shoutout to My Collaborators and the Hacktoberfest Team 🙌

None of this would have been possible without the support and collaboration of amazing individuals within the open-source community. I want to give a massive shoutout to all my collaborators who guided me, reviewed my pull requests, and shared their knowledge. It's the collective effort of the community that makes Hacktoberfest such a remarkable event.

I'd also like to express my gratitude to the Hacktoberfest team for organizing this event. Their dedication and hard work in bringing open-source enthusiasts together is truly commendable. Hacktoberfest serves as a platform for developers of all levels to come together, learn, and make a meaningful impact.

Let's Keep the Momentum Going 🚀🌍🌱

As my first Hacktoberfest journey draws to a close, I'm not only reflecting on the knowledge and skills I've gained but also the sense of fulfillment that comes from being part of a larger mission. Let's not limit our contributions to just one month; instead, let's keep coding, collaborating, and making a positive impact on the world.

Hacktoberfest has shown me the power of the open-source community, and I'm excited to continue my journey as a contributor, learn more, and inspire others to join this incredible world of coding and collaboration. Together, we can shape a better future, one pull request at a time. 🚀🌍🌱

Thank you, Hacktoberfest 2023, for this remarkable experience. Until next year! 🙌

Check out my GitHub Contributions: 4 PRs Submitted!

OSSPhilippines/freefolio:
PR #113: Link
PR #115: Link
rudra016/WebDev-OpenSource:
PR #210: Link
Astha369/CPP_Problems:
PR #12: Link
coder-ralph/fcc-antique-dev-profiles:
PR #1: Link

Connect me on LinkedIn, and GitHub!