DEV Community: jalanindw

Summoning The Offline Medium: A Completely Private AI Séance

jalanindw — Fri, 30 Oct 2026 08:23:07 +0000

What I Built
I built The Offline Medium, a deeply private, fully local web application that acts as a digital clairvoyant and tarot card reader.

To honor the "Ghost in the Machine" theme, I interpreted the prompt literally: what if there was an entity living inside your local hardware? The Offline Medium does not present itself as an AI assistant. Instead, it embodies the persona of a mysterious, slightly dark spirit trapped inside the machine, offering philosophical insights and imaginary tarot readings based on the user's questions.

Demo
(Since this project is designed to be run locally for absolute privacy, here is a video demonstration of the app running with my Wi-Fi completely disabled)

Code

dimaswahyu-official / medium-offline-web

React + Vite

This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.

Currently, two official plugins are available:

@vitejs/plugin-react uses Oxc
@vitejs/plugin-react-swc uses SWC

React Compiler

The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see this documentation.

Expanding the ESLint configuration

If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the TS template for information on how to integrate TypeScript and typescript-eslint in your project.

View on GitHub

How I Built It
This project relies entirely on local inference and open-weight models to function:

Core AI Engine: I used Ollama to serve the Llama 3 (8B) open-weight model locally.

System Prompting: I heavily engineered the system prompt to force Llama 3 to break its standard "helpful assistant" alignment and instead roleplay strictly as an ethereal medium.

Frontend Architecture: Leveraging my experience in web application development, I built a minimalist, dark-themed UI using React, Vite, and Tailwind CSS. I implemented strict state management to handle loading states and protect against edge cases (like preventing empty inputs).

Streaming & Voice: I integrated the ReadableStream API to parse Ollama's JSONL chunks, creating a real-time, character-by-character typing effect. I also hooked this into the browser's native Web Speech API to give the Medium a low, slow, and haunting voice.

Why Does Open Innovation Matter?
For a project like a Tarot Reader or a digital séance, privacy is paramount. People often ask tarot cards deeply personal, vulnerable, or sensitive questions about their relationships, careers, and fears.

If I built this using a closed, proprietary API, every personal fear or hope typed into the prompt would be sent to a corporate server and potentially used for training data. Open innovation made it possible to build a system that guarantees 100% data sovereignty. Because it runs on an open-weight model via Ollama, it works with the lights out and the Wi-Fi disconnected. It proves that we can have deeply engaging, immersive AI experiences without sacrificing our right to digital privacy.

The Spirit of It
The moment this project truly landed for me was during testing. I physically unplugged my router, sat in a dark room, and typed: "I feel completely stuck in my life right now. What do the cards say?"

Seeing the local terminal spin up my GPU, process my vulnerability completely offline, and slowly stream back a haunting, poetic response about the "Tower card" and "necessary destruction"—followed by a slow, robotic voice echoing through my speakers—gave me genuine chills. It truly felt like there was a ghost in the machine.

Prize Categories
Local Inference Hero

DrowsyGuard: An Offline Drowsiness Alert for Ride-Hailing & Truck Drivers

jalanindw — Sun, 18 Oct 2026 16:24:16 +0000

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

What I Built

DrowsyGuard is a React Native app that watches the driver's face through the phone's front camera and sounds an alarm when it detects drowsiness: the phone vibrates, says "Wake up! Pull over and rest," and the screen turns red.

Who would pay: [ride-hailing and delivery drivers, long-haul truckers, small logistics fleets and bus operators]. Fatigue is a real safety and cost problem for them, and dedicated in-cab monitoring hardware is expensive. A phone they already own is a far cheaper option.

How it decides:

Every frame, it computes the eye aspect ratio (EAR) from the face landmarks.
It raises the alarm if the eyes stay closed for about 1.5 seconds, or are closed for more than 30% of the last 30 seconds (PERCLOS, a standard fatigue measure).
It also warns the driver if no face is visible for 3 seconds, meaning they are not looking at the road.

Demo

Code

https://github.com/dimaswahyu-official/drownsy-app-ai.git

How I Built It

Open-weight model: MediaPipe Face Landmarker's face_landmarks_detector.tflite (Apache-2.0). It outputs 478 3D face landmarks per frame.
Inference: runs fully on the phone through react-native-fast-tflite, called from a Vision Camera frame processor at about 15 fps.
App: React Native (Expo dev build) with react-native-vision-camera v4, vision-camera-resize-plugin and react-native-worklets-core.
Detection logic: a small, model-independent TypeScript class (drowsiness.ts) that computes EAR from six landmarks per eye and applies the eyes-closed duration and PERCLOS rules. Swapping the model doesn't touch the alert logic.
Alerts: vibration plus text-to-speech (expo-speech), with the screen kept awake.
Calibration: [describe what you measured, e.g. your EAR for open vs closed eyes, and the threshold you picked].

Why Does Open Innovation Matter?

Privacy: the driver's face video never leaves the phone. No uploads, no accounts. Drivers and employers don't have to trust a server with facial video.
Works offline: it works in tunnels, on rural highways and in areas with poor signal, which is exactly where drowsy driving is most dangerous. A cloud API would fail there.
Zero running cost: there are no per-frame API fees. A closed vision API called about 15 times a second would make a cheap driver app unaffordable. With an open model, the marginal cost per user is zero.
Tunable and swappable: I can adjust thresholds, retrain, or replace the model for real conditions such as night driving, glasses and helmets, without waiting for a vendor. [Add anything you actually tuned.]
No lock-in: no vendor can change the pricing or shut off the API my business depends on.

WildHarvest AI: 100% Offline Campfire Recipe Generator using Gemma 7B

jalanindw — Thu, 08 Oct 2026 08:25:09 +0000

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

What I Built

I built WildHarvest AI, an offline-first campfire recipe generator designed for hikers, campers, and foragers. You simply input the ingredients you just foraged in the wild (e.g., wild mushrooms, bamboo shoots) and the app generates 3 safe, easy-to-cook recipe options using only your found ingredients and basic camping supplies (like a mess kit, salt, and water).

It perfectly fits the "Touch Grass" theme because it encourages people to get out into the woods, forage responsibly, and cook outdoors, all while bringing a smart chef along in their backpack.

Demo

Code

dimaswahyu-official / WildHarvest-AI

Collecting what you see in wild and i'll make a recipe's for that using Gemma:7b

🌲 WildHarvest AI

WildHarvest AI is a 100% offline, local-first campfire recipe generator built for hikers, campers, and foragers. This project is an official submission for the Hacktoberfest 2026 DEV Challenge (Week 1: Touch Grass).

When you are deep in the woods, you don't have internet access. This application solves that by running a local AI model to turn your foraged ingredients into safe, actionable campfire recipes without needing a single bar of cell service.

✨ Features

100% Offline Inference: Powered by Google's open-weight Gemma model running entirely on your local machine via Ollama.
Strict Ingredient Bounding: The AI is highly constrained to only use the ingredients you actually found, plus basic camping supplies (water, salt, oil, etc.). No hallucinated ingredients!
Campfire Ready: Recipes are designed to be cooked outdoors using basic mess kits or portable stoves.

🛠️ Tech Stack

Frontend: Next.js (App Router), React, Tailwind CSS
AI Integration:…

View on GitHub

(Note: I pivoted the project from a dessert app to a foraging app during the hackathon to better fit the theme, but the core engine remains the same!)

How I Built It

I built the frontend using Next.js (App Router) and Tailwind CSS. The core intelligence is powered by Google's open-weight Gemma (7B) model, running entirely locally on my machine via Ollama.

To make the AI act like a strict campfire chef, I created a custom Next.js Route Handler that talks to the local Ollama API. I set the model's temperature to 0.1 and wrote a highly constrained system prompt to prevent the AI from hallucinating ingredients the user didn't actually find.

Why Does Open Innovation Matter?

For a foraging and camping app, open innovation isn't just a nice-to-have; it is the only way the app functions.

When you are deep in the woods or at a campsite ("touching grass"), you rarely have a stable internet connection. If I had built this using a closed, cloud-based API like OpenAI or Claude, the app would be completely useless on the trail. By using an open-weight model like Gemma running locally on a laptop via Ollama, the entire AI inference happens offline. Open innovation made it possible to bring powerful AI into the wilderness without needing a single bar of cell service.

My Agent Session

(N/A - I built the logic directly based on local LLM experimentation)

Prize Categories

I am submitting this project for the following category:

Best Use of Gemma: The project relies entirely on Google's open-weight Gemma model running locally for its offline recipe generation logic.