DEV Community: Prasanna Lakshan

Supernatural Hunter's Journal: A 100% Offline AI Ghost Hunting Dashboard

Prasanna Lakshan — Fri, 30 Oct 2026 01:22:48 +0000

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

What I Built

I built the Supernatural Hunter's Journal, a 100% offline, AI-powered paranormal investigation dashboard.

Inspired by investigative horror games like Phasmophobia and the TV show Supernatural, I wanted to create a highly classified, digital "government-style" database for ghost hunters. Users input their eerie evidence (e.g., "The room suddenly got freezing cold, and I heard scratching in the walls"), and the system analyzes the data completely offline.

It identifies the supernatural entity, provides a chilling backstory (lore), warns of the imminent danger, and details the ancient method of defeat. To make it truly terrifying, the UI features flickering tech-grid glassmorphism and dynamically triggers specific jump-scare audio files (like glass shattering for Poltergeists or demonic growls for Demons) based on the AI's classification!

Demo

Code

shan2003034 / Supernatural-Hunter-s-Journal

A 100% offline, AI-powered paranormal investigation dashboard. Built with React, Spring Boot, and local LLMs (Ollama) to analyze supernatural evidence, identify entities, and provide dynamic horror audio experiences.

🕵️‍♂️ Supernatural Hunter's Journal

A 100% Offline, AI-Powered Paranormal Investigation Dashboard

📖 About The Project

The Supernatural Hunter's Journal is a modern, classified digital dashboard designed for paranormal investigators. It allows users to input eerie paranormal evidence and uses a 100% offline Local LLM to analyze the data, identify the supernatural entity, and provide ancient lore, danger levels, and methods of defeat.

Built with an immersive, atmospheric UI featuring flickering tech-grids, GSAP animations, and dynamic jump-scare audio themes that react to the identified entity.

✨ Key Features

🧠 100% Offline AI Analysis: Powered by Spring AI and local Ollama models (no internet required, ensuring complete privacy).
🎨 Immersive Investigator Dashboard: A modern, split-screen UI built with React and Tailwind CSS, resembling a classified government or SCP database.
🔊 Dynamic Audio Themes: Automatically plays specific background ambient noises and jump-scare sounds based on the identified entity (e.g., glass…

View on GitHub

How I Built It

To keep the theme truly "Ghost in the Machine," the entire intelligence of this app lives locally on the machine. No data is sent to the cloud.

The AI Brain (Gemma): I used Google's Gemma (gemma:2b) running completely locally via Ollama.
The Backend: I utilized Java Spring Boot integrated with Spring AI. I engineered a highly specific prompt instructing the local Gemma model to act as an ancient, battle-hardened demonologist. I also implemented a local SQLite database to automatically log every encounter into the "Database Archives" (Bestiary).
The Frontend: Built with React and Tailwind CSS. I shifted from a classic "old book" look to a modern "Classified Investigator Dashboard" using dark glassmorphism, glowing cyan terminal fonts, and GSAP for smooth fade-ins and cinematic loading states.
Dynamic Audio: The backend scans the AI's response for keywords and sends an audioTheme variable to the frontend, which plays specific jump-scares dynamically.

Why Does Open Innovation Matter?

My Agent Session

When you're hunting demons, you don't want your private paranormal evidence being sent to a corporate cloud server!

Open innovation made this project possible because open-weight models like Gemma combined with Ollama allow developers to build powerful, immersive, and highly customized AI agents that run 100% locally. A closed API would have introduced latency, privacy concerns, and potential rate limits. With an open local model, the response is entirely self-contained, free, and incredibly fast—perfect for real-time paranormal investigations.

The Spirit of It

The most satisfying moment of building this was getting the dynamic audio jump-scares to sync perfectly with the AI's generation.

During testing, I typed in: "I woke up to a heavy feeling on my chest and saw a tall shadow with red eyes at the foot of my bed." When the loading radar finished sweeping, the dashboard suddenly flashed red, identified the entity as a "Shadow Demon," and a horrifying, guttural demon growl played perfectly on cue through my headphones. It genuinely gave me chills and made me jump out of my chair. That was the moment I knew the "Ghost in the Machine" had truly come alive.

Prize Categories

I am entering the following category for this submission:

Google (Best use of Gemma)

Channel Your Inner Sloth: Turn Hours of Lectures into Flashcards with Gemma

Prasanna Lakshan — Wed, 21 Oct 2026 14:55:04 +0000

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

What I Built

Lazy Student AI is a 100% offline, privacy-first desktop application designed to do the heavy lifting of studying for you. You simply drop a boring, hour-long lecture video (MP4), audio file (MP3/WAV), or a lengthy PDF document into the app, and it automatically extracts the text, analyzes it, and generates bite-sized bullet-point summaries and interactive flashcards.

It saves countless hours of re-watching or re-reading materials. Who gets to be a little lazier? Every student who dreads going through massive lecture transcripts. Just upload the file, grab a coffee, and come back to ready-made study notes!

Demo

Here is the look of our modern landing page where users can download the setup file:

And here is the magic in action—a complete summary and interactive flashcards generated from a lecture:

Code

shan2003034 / lazy-student-ai-summarizer

A 100% offline, privacy-first AI tool that summarizes PDF, Audio, and Video lectures into interactive flashcards using local Gemma and Whisper models.

🦥 Lazy Student AI

Let Local AI Do The Heavy Lifting. Turn Hours of Lectures into Flashcards & Summaries.

📌 About The Project

Lazy Student AI is a 100% offline, privacy-first desktop application built for students who want to study smarter, not harder. Submitted for Hacktoberfest 2026 (Week 3: Slow and Steady), this tool takes your long, boring lecture videos (MP4), audio recordings (MP3), or massive PDF documents, and automatically generates bite-sized bullet-point summaries and interactive flashcards.

No cloud, no API keys, no subscription fees. It runs entirely on your local machine using open-weight models!

✨ Key Features

Multi-Format Support: Drag and drop PDFs, MP3s, or MP4s.
Smart Summarization: Powered by Google's Gemma 2B model.
Interactive Flashcards: Automatically generates Q&A pairs for active recall.
100% Offline & Private: Your data never leaves your laptop.
Standalone Desktop App: Packaged as a clean .exe for Windows.

🛠️ Tech Stack

Frontend: React…

View on GitHub

How I Built It

I wanted a seamless, industry-standard architecture that runs entirely on a local machine. Here is the tech stack and how the open-source AI fits in:

The Brain (Open-Source AI): I used Google's Gemma 2B model via Ollama (ollama run gemma:2b). It is incredibly fast, lightweight, and perfect for running locally on a laptop to generate accurate summaries and flashcard Q&A pairs. For audio and video processing, I integrated the local OpenAI Whisper CLI along with FFmpeg to extract and transcribe speech to text.

The Backend: A robust Spring Boot 3 application using Java 17 and SQLite for local data storage. It uses Apache PDFBox to parse PDFs and directly executes local shell commands to trigger Whisper and Ollama.

The Frontend: A sleek, modern UI built with React, Vite, Tailwind CSS v4, and Framer Motion for smooth, sloth-approved animations.

The Packaging: Instead of forcing users to run npm or mvn commands, I bundled the frontend into the Spring Boot static resources, compiled it into a .jar, and wrapped it into a standalone .exe installer using Launch4j and Inno Setup.

Why Does Open Innovation Matter?

For a student tool, open innovation is everything.

Zero Cost: Students are usually broke. Relying on closed, paid APIs (like OpenAI's GPT-4) would mean charging a subscription fee. By utilizing open-weight models like Gemma, the tool costs $0 to run forever.

100% Offline & Private: University lectures and personal notes shouldn't be sent to a corporate server. Running inference locally means the app works even in a library with terrible Wi-Fi, and user data never leaves their laptop.

Flexibility: Building on open tools allowed me to seamlessly pipe FFmpeg outputs into Whisper, and pipe that text directly into Gemma, entirely orchestrated by my own Spring Boot backend.

The Lazy Payoff

his app is the ultimate cheat code for laziness. Instead of spending 2 hours watching an "Object-Oriented Programming" lecture and pausing every 5 minutes to take notes, I just feed the .mp4 file to the app. In a few minutes, I get exactly what I need to know in 10 bullet points and flip-cards to memorize definitions. I literally used it this week to summarize a massive PDF assignment guideline while I watched an episode of Supernatural.

Prize Categories

Best Use of Gemma - The core intelligence of this project relies entirely on Google's open-weight Gemma model running locally via Ollama to perform the complex NLP task of summarizing and structuring flashcards from massive walls of transcribed text.

How I Built an AI-Powered Observability Platform to Stop Digging Through Microservices Logs 🚀

Prasanna Lakshan — Tue, 20 Oct 2026 15:36:57 +0000

Ever spent three hours tracing a single NullPointerException across five different microservices? You grep through endless terminal windows, match timestamps, and manually piece together the puzzle. It’s exhausting.

As a full-stack developer working heavily with Spring Boot, I realized that while microservices solve scalability issues, they introduce a massive debugging headache. I wanted a tool that didn't just show me the logs, but actually helped me fix them in real-time.

Since I couldn't find a lightweight, developer-friendly solution that fit my exact needs, I built one. Meet LogIQ.

What is LogIQ? 🧠

LogIQ is a centralized observability SaaS platform and a custom Java SDK designed to streamline the debugging workflow. It captures telemetry data, tracks server health in real-time, and uses an AI Neural Engine to analyze complex stack traces and provide actionable code fixes.

Instead of navigating through different log files, everything is streamed directly into a modern, cyber-tech inspired dashboard.

Core Features at a Glance:

Plug-and-Play SDK: A custom Spring Boot starter that integrates in under 2 minutes.
Real-Time Health Monitoring: Zero-lag live server status tracking via WebSockets.
AI-Powered Debugging: Instant stack-trace analysis and fix suggestions powered by LLMs.
Secure Team Collaboration: Built-in Role-Based Access Control (RBAC) to manage Owner/Developer access.
Cyber-Tech UI: A sleek Glassmorphism interface built with React, Tailwind CSS, and Framer Motion.

The Architecture: How It All Fits Together 🏗️

I wanted LogIQ to have zero performance bottleneck on the host microservices. To achieve this, I separated the system into three main components:

The Client SDK (logiq-spring-boot-starter): Runs on the target microservices, collecting logs and health metrics asynchronously.
The Core Engine (Spring Boot Backend): Acts as the secure broker, handling JWT authentication, database persistence (MySQL), and routing messages to the AI provider.
The Dashboard (React Frontend): Consumes REST APIs and listens to WebSocket channels for live updates.

Here is the high-level system architecture:

flowchart TB
    subgraph Target Microservices
        S1["Spring Boot App 1<br/>(LogIQ SDK)"]
        S2["Spring Boot App 2<br/>(LogIQ SDK)"]
    end

    subgraph LogIQ Core Server
        API["REST APIs<br/>(Auth, Projects)"]
        WS["WebSocket Broker<br/>(STOMP)"]
        AI["AI Processing Engine"]
    end

    subgraph Client Browser
        UI["React Dashboard<br/>(Tailwind + Framer Motion)"]
    end

    S1 -->|"Async Telemetry Stream"| API
    S2 -->|"Async Telemetry Stream"| API

    API <--> AI
    API -->|"Publish Events"| WS
    WS -->|"Real-time Health & Logs"| UI

Building the Custom Spring Boot SDK 📦

One of the most exciting parts of this project was building my own custom SDK. I wanted the integration process to be frictionless for other developers.

By creating a custom spring-boot-starter, a developer only needs to add a single dependency to their pom.xml:

<dependency>
    <groupId>com.bytecodelk</groupId>
    <artifactId>logiq-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

Then, simply configure the project credentials in application.properties:

logiq.api.key=YOUR_PROJECT_API_KEY
logiq.server.url=http://localhost:8080

Behind the scenes, the SDK automatically hooks into the Spring environment, intercepts application exceptions, and pushes them to the LogIQ backend asynchronously so it never slows down the main application thread.

The Magic: Real-Time WebSockets & AI Analysis 🪄

1. Zero-Lag Telemetry

Instead of relying on heavy polling mechanisms, I implemented WebSockets (STOMP) in the Spring Boot backend. When the backend receives a new log entry or health ping from the SDK, it broadcasts the payload to a specific project topic. The React frontend listens to this topic and updates the UI instantly.

2. The AI Neural Engine

Reading a 50-line Java stack trace is never fun. In the LogIQ dashboard, if an error is flagged as critical, you can click "Analyze with AI".

The Spring Boot backend securely formats a strict prompt containing the exact stack trace and context, sends it to the LLM via an API call, and returns a human-readable explanation and code fix. It ensures that sensitive environment variables are not unnecessarily exposed, keeping the debugging process secure.

The Frontend: Cyber-Tech Aesthetics 🌌

Developers stare at screens all day, so the UI had to be easy on the eyes but visually striking. I opted for a dark-themed, industrial cyber-tech aesthetic.

Using React, Tailwind CSS, and Framer Motion, I built a responsive Glassmorphism UI. I even integrated React Three Fiber to render some subtle 3D depth elements on the landing page to give it that futuristic command-center feel.

Conclusion & Next Steps

Building LogIQ has been an incredible journey that pushed my boundaries in full-stack development, API design, and real-time data handling.

Currently, the SDK is exclusively available for Spring Boot, but I plan to expand support to Node.js and Python microservices in the near future.

If you are a developer looking for an easier way to debug your distributed systems, or just curious about the code, I'd love for you to check it out!

🔗 Check out the source code on GitHub:

shan2003034 / logiq-backend

The core Spring Boot backend engine for LogIQ. A high-performance REST API and WebSocket broker that handles real-time microservices telemetry, JWT authentication, and AI-powered log analysis.

# 🧠 LogIQ - Core Backend Engine

AI-Powered Observability & Debugging Platform API

This is the Backend repository for LogIQ, built with Spring Boot 3 and Java 17. It serves as the central processing node, handling real-time telemetry streaming via WebSockets, robust authentication with JWT, and AI-powered log analysis.

🔗 Related Repository

This project is the backend core engine for the LogIQ platform Frontend Client: 👉 LogIQ React Frontend

📖 About The Backend

The LogIQ backend is a high-performance RESTful API and message broker built on Spring Boot. It is designed to receive, process, and store telemetry data from distributed microservices using the LogIQ custom SDK.

This engine securely handles user authentication, manages project metadata, processes live server health streams via WebSockets, and acts as the secure bridge to our AI Neural Engine for automated code debugging.

⚡ Asynchronous telemetry processing with zero bottleneck
🔒 Secure Role-Based Access Control…

View on GitHub

shan2003034 / logiq-frontend

This is the Frontend repository for LogIQ, built with React, Vite, and Tailwind CSS. It provides a cyber-tech inspired Glassmorphism UI to monitor microservices, visualize real-time server health, and display AI-generated code fixes.

logIQ - Frontend

Interactive Developer Dashboard for AI-Powered Observability

This is the Frontend repository for LogIQ, built with React, Vite, and Tailwind CSS. It provides a cyber-tech inspired Glassmorphism UI to monitor microservices, visualize real-time server health, and display AI-generated code fixes.

🔗 Related Repository

This project is the frontend client for the LogIQ platform. Backend API & Core Engine: 👉 LogIQ Spring Boot Backend (Note: Replace with your actual backend repo link)

📖 About The Frontend

The LogIQ frontend is an enterprise-grade observability dashboard built for modern developers. It connects seamlessly to the LogIQ Spring Boot backend to stream real-time telemetry data via WebSockets. The UI is heavily inspired by industrial and cyber-tech aesthetics, featuring 3D elements, dark mode by default, and smooth animations.

⚡ Real-time system health visualization
🤖 Interface for AI-powered debugging and code-fix suggestions
🔐 UI for Role-Based Access Control (RBAC) and team collaboration
🌌 Highly…

View on GitHub

If you find the architecture interesting or the tool helpful, please consider dropping a ⭐️ on the repositories. I’m also open to feedback, contributions, and ideas for new features!

What’s your current go-to strategy for debugging microservices? Let me know in the comments below! 👇

softwareengineering #springboot #reactjs #microservices #ai #webdevelopment #opensource

Building Offline Patient Summarizer : A 100% Offline AI Clinical Summarizer with Google Gemma

Prasanna Lakshan — Fri, 16 Oct 2026 14:14:33 +0000

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

What I Built

I built the Offline Patient Summarizer, a 100% offline AI clinical summarizer tailored for medical professionals. It translates unstructured, messy physician notes into clean, structured, and print-ready medical records directly on the user's local machine.

Who would pay for it? Private clinics, independent medical practitioners, and small hospitals.
What problem does it solve? The privacy vs. efficiency dilemma. While cloud-based AI tools are powerful, sending sensitive Patient Health Information (PHI) to third-party cloud APIs poses massive HIPAA and privacy compliance risks. The Offline Patient Summarizer solves this by running an advanced AI model entirely locally. No internet connection is required for processing, ensuring zero cloud connectivity and maximum data privacy.

Demo

Code

shan2003034 / offline-patient-summarizer

offline-patient-summarizer

View on GitHub

How I Built It

The Offline Patient Summarizer is built with a focus on local performance, security, and a seamless user experience.

The AI Engine (Open-Source AI): I utilized Google's Gemma open-weight model for the core NLP tasks. To achieve local inference, I integrated Ollama, allowing the AI to run directly on the user's hardware without external API calls.

Backend: Built with Java and Spring Boot, serving as the bridge between the local Ollama instance and the frontend. It securely handles prompt engineering and data formatting. I used a local SQLite database to store patient summaries on the user's hard drive securely.

Frontend: A modern, responsive web UI built with React, Tailwind CSS, Framer Motion, and Lucide React.

Packaging: To make it accessible for non-technical doctors, the entire application is packaged into a standalone .exe file for Windows.

Landing Page: The promotional landing page was designed with modern glassmorphism UI/UX and seamlessly hosted on Vercel.

Why Does Open Innovation Matter?

For the healthcare sector, open innovation is a game-changer. A closed AI API forces developers to send sensitive medical data to external servers, which is a massive security and regulatory risk. Open-weight models like Gemma, combined with open-source local inference engines like Ollama, made this project possible. Open innovation empowers developers to bring enterprise-grade, state-of-the-art AI directly to the edge (the doctor's personal computer), ensuring that patient data never has to leave the room.

Prize Categories

Best Use of Gemma: I am entering this category because PatientFlow (Offline Patient Summarizer) utilizes Google's open-weight Gemma model locally via Ollama to process and generate structured clinical summaries without relying on external cloud APIs.

Code-Break: A CLI Agent that Forces Developers to Touch Grass

Prasanna Lakshan — Sun, 11 Oct 2026 09:56:16 +0000

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

What I Built

As developers, it's easy to get lost in a marathon coding session or frantically hit Ctrl+S while stuck on a frustrating bug. I built Code-Break, a Dart-based CLI agent that runs in the background, watches your local file saves, and forcefully intervenes when you've been staring at the screen for too long.

Here is how it gets you off the screen and into the real world:

Smart Activity Monitoring: The CLI tracks your saves. If you hit a continuous coding marathon limit or a "frantic saving" threshold, it pauses your workflow.
AI Intervention (Groq): It pings the blazing-fast mixtral-8x7b-320k model via Groq API to generate a short, witty, and personalized command to step away from the keyboard and go outside.
Voice Command (ElevenLabs): It uses ElevenLabs Text-to-Speech to literally speak the command out loud, ensuring you can't just ignore a terminal message.
Nature Validation: When you return, the terminal asks: "What unique thing did you see outside?" Groq AI validates your response using strict JSON formatting. If you try to cheat, it rejects it.
Rewarding the Habit (GitHub Streak): If your observation is valid, the CLI uses the GitHub REST API to automatically push a commit to your Profile README, updating your Touch Grass 🌱 Streak counter.

Demo

Code

You can check out the full source code and documentation here:
shan2003034/code_break

How I Built It

I built this CLI tool using Dart. For the AI brain, I utilized Mixtral 8x7B (mixtral-8x7b-320k), a powerful open-weight model, running on Groq's ultra-fast inference engine.

The project is built around the AI acting in two completely different roles: a creative generator and a strict logical validator. First, it generates a witty, contextual prompt to tell the user to go outside. Then, when the user returns and types what they saw (e.g., "I saw a blue bird sitting on a mango tree"), I leveraged Mixtral's strong instruction-following capabilities to force the output into a strict JSON format ({"valid": true, "reason": "..."}). This allowed the CLI to programmatically evaluate the user's real-world observation before making a successful API call to update their GitHub streak.

Why Does Open Innovation Matter?

Open innovation was the exact reason this project succeeded because it gave me the freedom to experiment and pivot without friction.

I initially started building this agent using Google's Gemma running locally via Ollama. However, as the project evolved, I realized I needed a faster, lighter approach for the final CLI. Because I was working with open-weight models, I was able to seamlessly swap out the local model for Mixtral 8x7B hosted on Groq without having to rewrite my entire application logic. Open innovation ensures that developers aren't locked into a single closed, proprietary ecosystem—we have the ultimate flexibility to choose the models, inference engines, and deployment methods that best fit our specific needs.

My Agent Session

While I did not use DevRelay to record a session, the core "agent" logic is entirely embedded within my open-source Dart CLI. You can view the exact conversational flow, JSON structure enforcement, and prompt validation logic directly in the repository's source code (specifically within the groq_service.dart file).

Prize Categories

Best Use of ElevenLabs: I integrated the ElevenLabs API to give my open-source CLI agent a voice. Instead of just printing a static terminal message, the agent actively speaks the "Touch Grass" command out loud to ensure the developer can't ignore it and actually steps away from their screen.

Note: This is a solo submission by @shan2003034