DEV Community: Piyush Annigeri

GHOSTLINE — The Terminal That Remembers

Piyush Annigeri — Sat, 31 Oct 2026 05:56:29 +0000

GHOSTLINE 👻 — The Terminal That Remembers

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

What I Built

What if your terminal remembered everything you told it, understood your mistakes, and occasionally whispered back?

Meet GHOSTLINE — The Terminal That Remembers.

GHOSTLINE is a local-first AI-powered terminal companion designed to make developer workflows more interactive, intelligent, and a little spooky.

Inspired by the idea of a ghost living inside an old computer, I wanted to build something that brings the Halloween theme to life while solving a real developer problem: understanding terminal commands, debugging errors, and retaining context across interactions.

Instead of building another web-based chatbot, I decided to bring AI directly into the terminal.

With GHOSTLINE, you can:

Have conversations with an AI assistant directly from your terminal.
Ask questions about programming, debugging, and development.
Explicitly execute terminal commands and let AI interpret their output.
Maintain persistent conversation memory across sessions.
Export conversations into Markdown for future reference.
Run AI inference locally using an open-weight model.
Use the application without an internet connection after the model has been downloaded.

GHOSTLINE is designed around one important principle:

Your terminal activity should remain yours.

It doesn't automatically monitor your shell or execute commands behind your back. You decide what information to share and which commands to run.

Demo

ghostline --demo

For the actual AI-powered experience, install Ollama and download the model:

ollama pull qwen3:8b
python -m pip install .
ghostline

The demo mode demonstrates the interaction flow, while the live application uses local model inference.

Code

GitHub Repository: https://github.com/pixelcrisscross/GHOSTLINE.git

The project is built with Python and uses a modular architecture.

Key components include:

ghostline/cli.py — Interactive terminal interface, command handling, safety prompts, and session management.
ghostline/core.py — Local model communication, conversation memory, and Markdown export.
tests/ — Unit tests for memory management, export functionality, and command safety checks.

The repository also includes installation instructions, configuration options, and an MIT License.

How I Built It

I wanted GHOSTLINE to be more than a themed interface around a closed AI API. The AI itself needed to be a core part of the application.

Technology stack:

Python: Core application and terminal interface.
Ollama: Local model serving and inference.
Qwen3 (8B): Default open-weight language model.
JSONL: Persistent, locally stored conversation memory.
HTTP API: Communication between the Python application and the local Ollama server.

Architecture

The application follows a straightforward architecture:

             DEVELOPER
                 |
                 v
          GHOSTLINE CLI
                 |
          +------+------+
          |             |
          v             v
     Local Memory   Command Runner
       (JSONL)           |
          |              v
          |         Command Output
          |              |
          +-------+------+
                  |
                  v
             Ollama API
           localhost:11434
                  |
                  v
            Qwen3 8B Model
                  |
                  v
          Contextual Response
                  |
                  v
              GHOSTLINE

The application communicates with Ollama through its local HTTP API.

Conversation history is stored in JSONL format, allowing the application to retain context without requiring an external database.

One of the important design decisions was keeping command execution explicit. Normal conversations never execute shell commands. The developer must use the :run command to execute something.

I also implemented confirmation prompts for commonly recognized destructive commands.

The application includes a demo mode, allowing someone to explore its interface without downloading a model.

Why Does Open Innovation Matter?

This is probably the most important part of GHOSTLINE.

Terminal interactions can contain sensitive information: directory structures, project details, command output, error logs, and sometimes accidental exposure of credentials.

Building GHOSTLINE around local inference changes how that information is handled.

Using an open-weight model through Ollama gives us several advantages:

1. Privacy and control

Conversation context and command output can remain on the developer's machine instead of being sent to a third-party hosted AI API.

2. Offline capability

Once the model is downloaded, GHOSTLINE can continue performing local inference without an active internet connection.

3. Model independence

The application is not permanently tied to one proprietary model provider. Developers can change the model through configuration.

4. Transparency

Conversation memory is stored in a readable JSONL file. Developers can inspect, export, and delete their own data.

5. Accessibility

There is no mandatory per-request cloud inference fee. The trade-off is that inference depends on the user's available hardware.

For me, open innovation means more than having access to source code.

It means having the freedom to understand, modify, run, and control the intelligence behind the software we build.

My Agent Session

The current version does not yet have a recorded DevRelay session.

I plan to add an actual development session showing the architecture, local model integration, memory implementation, and debugging process.

The Spirit of It

Halloween has always been associated with haunted houses, mysterious voices, and things that refuse to disappear.

I wanted to bring that feeling into something developers interact with every day.

Imagine opening a dark terminal.

A familiar green glow appears.

A machine wakes up.

You ask it a question.

And something answers.

But beneath the Halloween aesthetic is a more meaningful idea: software should not have to forget everything when you close a window, and intelligent tools should not require you to surrender control of your data.

GHOSTLINE is my interpretation of the Ghost in the Machine.

Some machines execute commands. Some machines remember.

This one does both — but only when you ask.

Prize Categories

Primary submission:

Overall Hacktoberfest Open-Source AI Challenge Winner.

Built with curiosity, Python, open-weight AI, and a little Halloween spirit. 👻

devchallenge #hf26challenge #hacktoberfest #opensource #AI #Python #Ollama #Qwen

Trick, Treat, and Code: Highlighting GDGC VTU's Best Halloween Hacks 🕸️💻

Piyush Annigeri — Sun, 25 Oct 2026 11:26:29 +0000

#GDGCVTU #HalloweenDevChallenge #TrickOrTreat

Hello Developers,

That's a wrap on Halloween DEV Challenge 1: Trick or Treat?, hosted by Google Developer Groups on Campus at Visvesvaraya Technological University (VTU), Belagavi.

This internal community challenge encouraged chapter members to explore creative problem-solving through theme-driven applications. Participants were challenged to build solutions that either helped users manage everyday tasks (Treat) or delivered a fun, harmless prank (Trick).

Through this challenge, we aimed to foster experimentation, strengthen development skills, and provide a platform for our community to showcase its work. We are proud to spotlight the projects and developers who stood out through their creativity and execution.

As part of this recognition, the winners will receive an exclusive digital badge and a dedicated repository in our official GDG on Campus VTU GitHub organization.

Top 3 Halloween Hacks

1st Place: ExamOracle — The AI Exam Survival Kit

Category: Best AI Utility

Asiya D Varge

Year: First Year
Institution: Visvesvaraya Technological University, Belagavi
Branch: Computer Science and Business Systems (CSBS)
GitHub: asiya2526
LinkedIn: Asiya D Varge
Project Repository: ExamOracle

About the project

ExamOracle is a full-stack, AI-powered exam preparation platform designed to make studying more strategic and engaging. Rather than relying solely on generic AI-generated suggestions, it analyzes historical question recurrence using previous-year question papers.

The platform incorporates features such as Boss Battles, a Mystery Study Cauldron, and a Halloween-inspired interface to make exam preparation more interactive. By combining AI, historical data, and gamification, ExamOracle offers a creative approach to a common student challenge.

2nd Place: BOO! — Trick or Treat Lab

Category: Best Theme Alignment

Shaik Mohammed Nawaz

Year: Fourth Year
Institution: Ballari Institute of Technology and Management
Branch: Artificial Intelligence and Machine Learning
GitHub: nawazshaik313
LinkedIn: Shaik Mohammed Nawaz
Project Repository: BOO! — Trick or Treat Lab

About the project

BOO! is a mobile-friendly prank platform and mini-game experience built using React and Vite. Designed around the dual themes of tricks and treats, it allows users to explore harmless pranks through its Cursed Name feature and play Candy Chaos, a timed mini-game where players earn virtual Candy Coins.

An AI-powered prank coach adds another interactive element to the experience. The project demonstrates how creative concepts and web technologies can be combined to deliver an engaging, theme-focused application.

3rd Place: ctrl-alt-scream — The Possession Simulator

Category: Best Creative Concept

Soujanya Krishnappa Thaleppagol

Year: First Year
Institution: Visvesvaraya Technological University, Belagavi
Branch: Computer Science and Engineering
GitHub: Soujanya-oss
LinkedIn: Soujanya Thaleppagol
Project Repository: ctrl-alt-scream

About the project

ctrl-alt-scream is a retro-inspired interactive desktop simulator built around a fictional operating system called Boo-OS 95. Combining nostalgic interface design with Halloween-themed interactions, the project features a Curse Control Center, prank deployment mechanics, and the Grimbyte AI Spirit Oracle, powered by Google Gemini.

The project stands out for its distinctive concept and creative use of interactive elements, demonstrating how familiar computing experiences can be reimagined through a Halloween-themed application.

Honorable Mentions

We would also like to recognize the following submissions for their creativity and contribution to the challenge.

Nagaraj — CREDITVERSE

Year: First Year
Institution: Visvesvaraya Technological University, Belagavi
Branch: VLSI Design and Technology
GitHub: Nagaraj-web877
LinkedIn: Nagaraj A. N.
Project Repository: CREDITVERSE

CREDITVERSE was among the gamified project concepts submitted during the challenge. It reflects the community's interest in exploring interactive approaches to application development and creative problem-solving.

Aarun Vishal Ramanavar — Haunted Scroll

Year: First Year
Institution: Visvesvaraya Technological University, Belagavi
Branch: Computer Science and Engineering
GitHub: Newbie-Avr
LinkedIn: Aarun Vishal Ramanavar
Project Repository: Haunted Scroll

Haunted Scroll brought a productivity-focused concept to the challenge, demonstrating how a seasonal theme can be incorporated into an application designed around everyday use cases.

Celebrating Our Developer Community

We extend our appreciation to every participant who took part in the Halloween DEV Challenge. The submissions, ranging from AI-powered study tools and interactive prank experiences to gamified concepts and productivity applications, reflected the diversity of ideas within our community.

Challenges like these provide students with opportunities to move beyond theory, experiment with technologies, develop practical skills, and share their work with fellow developers. Every contribution helps strengthen the campus developer ecosystem and encourages continued learning through building.

What's Next?

The Trick or Treat? Halloween DEV Challenge may have concluded, but there are more opportunities ahead to learn, collaborate, and build.

Follow GDG on Campus VTU Belagavi for upcoming community activities, development challenges, and opportunities to showcase your work.

Keep building. Keep learning. Keep contributing.

GDG on Campus VTU Belagavi

This community spotlight is published by GDG on Campus VTU Belagavi. The projects were submitted as part of internal chapter activities.

SlothDesk: Your Local AI File Organizer That Does the Heavy Lifting

Piyush Annigeri — Sun, 25 Oct 2026 10:41:38 +0000

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

🦥 SlothDesk: Let AI Organize Your Files While You Do Absolutely Nothing

What if your computer could clean up your messy folders without sending your personal file metadata to a cloud AI service?

We all have that one folder. Hundreds of screenshots, PDFs with meaningless names, documents we promised to organize later, and duplicate files we are afraid to delete.

I built SlothDesk, a local-first AI file organizer powered by Qwen, to make that repetitive work a little less painful.

The idea behind this project is simple: let AI do the tedious thinking, keep humans in control, and make getting organized effortless.

What I Built

SlothDesk is a local AI-powered file organization assistant that scans a selected folder, proposes a cleaner structure, and lets users review changes before applying them.

Instead of manually inspecting and renaming every file, you can let SlothDesk prepare an organization plan.

Here's what it does:

AI-powered organization: Suggests categories and more readable filenames using a locally running Qwen model.
Human-in-the-loop automation: Review, edit, approve, or reject suggestions before anything changes.
Exact duplicate detection: Identifies files with identical content using SHA-256 hashes.
Safety checks: Validates filenames and destinations and prevents silent overwrites.
Undo support: Records successful operations so supported changes can be reversed.
Local-first processing: Uses Ollama for local model inference instead of requiring a hosted AI API for the core workflow.

The target user is anyone who spends too much time organizing downloads, project documents, study materials, screenshots, or other digital clutter.

The goal isn't to build an AI that takes over your computer. It's to build one that handles the boring stuff while you stay in control.

Demo

Try it locally: Follow the setup instructions in the repository's README.

Code

GitHub repository: [https://github.com/pixelcrisscross/SlothDesk.git]

The project is written in Python and uses Streamlit for its interface.

The codebase separates the AI planner from the filesystem execution layer. This means model suggestions are treated as untrusted input and validated before any approved operation is executed.

The repository includes the application, setup instructions, safety checks, undo functionality, and automated tests.

How I Built It

I built SlothDesk using a deliberately lightweight stack:

Python — application logic and filesystem operations.
Streamlit — a browser-based local interface.
Ollama — local model inference.
Qwen — open-weight AI for generating organization suggestions.
Pydantic — structured output validation.
SQLite — local operation history.
SHA-256 — exact duplicate detection.
pytest — automated tests for important safety and rollback behavior.

The workflow has four main stages.

1. Scan: The application collects basic file metadata, including filenames, extensions, and sizes.

2. Plan: Qwen generates structured suggestions for filenames and destination categories. In this MVP, the model does not inspect document contents.

3. Validate: The application checks the suggestions, rejects unsafe paths, and detects destination conflicts.

4. Execute: Only explicitly approved changes are applied, and successful operations are recorded for potential rollback.

One important design choice was to keep model reasoning separate from file operations. The model does not generate shell commands or directly execute arbitrary instructions against the filesystem.

The application, rather than the model, controls what operations are permitted.

Why Does Open Innovation Matter?

For SlothDesk, open innovation is about more than avoiding an API bill. It gives developers greater control over where inference happens, how models are selected, and how an application behaves.

1. Privacy by design

Filenames can reveal project names, personal details, and other sensitive information.

By using local inference, SlothDesk can process file metadata without sending it to a hosted AI model API. This reduces external data exposure, although local execution alone does not guarantee complete security or privacy.

2. Less dependence on paid APIs

Once the model is downloaded, inference can run locally without a per-request fee from a hosted AI provider. Hardware, electricity, storage, and setup still have costs, but the core workflow doesn't depend on a paid inference endpoint.

3. Freedom to experiment

Starting with Qwen lets me explore different model sizes and configurations based on the laptop's available resources.

The model layer is separate from the file-operation logic, making it easier to experiment without rewriting the safety system.

4. More control over automation

A closed API can provide excellent model capabilities, but SlothDesk's core value comes from combining AI suggestions with locally enforced rules.

The application can validate destinations, require approval, record changes, and support rollback regardless of which compatible model generates the suggestions.

Open innovation makes it possible to build an assistant around the principle that your files should remain under your control, even when AI helps organize them.

The Lazy Payoff

The payoff is fewer repetitive decisions.

Instead of manually reviewing every filename and deciding where each file belongs, users can review a batch of AI-generated suggestions in one place.

I haven't established a reliable time-saving benchmark yet, so I won't claim a specific percentage improvement. A useful next experiment would compare manual organization against SlothDesk using the same synthetic folder, measuring completion time, classification accuracy, and the number of corrections required.

The goal is to make one of those small, annoying tasks disappear from the to-do list.

Less sorting. Fewer repetitive decisions. More time for something else.

Prize Categories

Primary target: Overall Hacktoberfest Open-Source AI Challenge Week 3 prize.

SlothDesk is built around local open-weight AI and directly addresses the Slow and Steady theme through practical automation.

I'm not claiming any partner-specific prize category at this stage. I would only add a partner category if the finished implementation genuinely uses the required partner technology.

SlothDesk is my attempt to make AI useful in a quieter way.

Not another assistant demanding more of your attention, but one that helps you get a tedious task out of the way.

Because sometimes the most productive thing you can do is let your computer do the organizing.

🦥 Stay slow. Stay organized. Let AI handle the boring stuff.

devchallenge #hf26challenge

PrivaLedger AI: Why Open-Source AI Makes a 99.4% Margin Side Hustle Possible

Piyush Annigeri — Sat, 17 Oct 2026 08:58:29 +0000

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

PrivaLedger AI 🛡️🧾

“Build something with open-weight models or open-source AI that someone would actually pay for.”

Every freelancer, solo developer, and independent contractor dreads the same two events every year: tax season and paying their monthly accounting software bill.

Legacy tools like QuickBooks and Expensify charge between $35 and $70 every single month ($420 to $840 annually). But worse than the subscription fee is the privacy trap: as independent operators, we routinely sign Non-Disclosure Agreements (NDAs) with clients. Uploading banking slips, client invoices, project names, and hourly rates to cloud AI APIs (like OpenAI, Google Cloud Vision, or AWS Textract) violates client confidentiality agreements and risks sensitive data exposure.

To solve this, I built PrivaLedger AI: an air-gapped, local-first receipt and invoice intelligence engine that automatically maps business expenses to IRS Schedule C tax deductions without a single byte of data leaving the user’s computer.

⚡ Why Open Innovation Matters (The Core Question)

The prompt asks: “Tell us where your open-based approach worked better than a closed one. Does it run on a laptop with no internet? Keep someone's data off a server they don't control? Cost nothing to run?”

Here is the candid reality of building an AI micro-SaaS in 2026: a closed-source approach would have killed this business before launch.

1. Zero Marginal Token Cost ($0.00 vs $0.05/scan)

If you build this with proprietary closed APIs (e.g. GPT-4o Vision or Claude 3.5 Sonnet), every receipt scan costs ~$0.03 to $0.08 in API token meters. A freelancer scanning 250 receipts in a year costs the developer ~$15 in cloud bills. You are forced to charge an expensive recurring subscription just to stay afloat.
With open-source AI (compiled via WebAssembly to run directly on the client's CPU), our marginal serving cost per user is literally $0.00. We have zero GPU cloud servers, zero vector database hosting bills, and zero API meter anxiety.

2. Client Confidentiality & Air-Gapped Peace of Mind

Freelance developers and consultants cannot legally upload client invoices with proprietary project names or subcontracting agreements to closed third-party cloud servers. Because PrivaLedger AI runs locally in the browser memory, zero bytes are transmitted outbound. The application can run on an airplane, in a cabin with no Wi-Fi, or in high-security corporate environments.

3. High-Converting Pricing Freedom

Because we don't have recurring API bills, we can break free from SaaS subscription fatigue and offer what freelancers actually want: a $39 One-Time Lifetime License.

100 Customers × $39 = $3,900 Revenue
Cloud Inference / API Fees = $0.00
Gross Profit Margin = 99.4%

🛠️ How It Works: The Local-First Architecture

graph TD
    A[Freelancer Drops Receipt / Invoice Image or PDF] --> B[Client-Side WebAssembly OCR Engine]
    B --> C[Raw Text Extraction Buffer]
    C --> D[Open-Weight Structured Entity Parser]
    D --> E[Entity Extractor: Vendor, Date, Currency, Total, Line Items]
    E --> F[IRS Schedule C Deduction Engine]
    F --> G[Compliance & Anomaly Audit: 50% Meals, 1099 Alerts, Duplicates]
    G --> H[Interactive Ledger Dashboard & Instant CSV / JSON / Schedule C Export]

On-Device OCR Engine: When a user drops a receipt (PNG, JPG, WEBP, or TXT), Tesseract.js initializes inside a local Web Worker via compiled WebAssembly. It extracts characters entirely client-side.
Open Structured Entity Parser: A local entity recognizer cleans and extracts the vendor name, invoice reference number, transaction date, currency, total amount, taxes/VAT, and payment method.
IRS Schedule C Deduction Engine: Expenses are categorized into official IRS Schedule C write-off categories:
- Line 8: Advertising & Marketing (100% deductible)
- Line 11: Contract Labor & Freelancers (100% deductible; flags payments $\ge$ $600 for Form 1099-NEC compliance)
- Line 18: Software, SaaS & Cloud Tools (100% deductible)
- Line 24a: Business Travel & Lodging (100% deductible)
- Line 24b: Business Meals (automatically calculated at the statutory 50% limit)
- Line 25: Co-working & Utilities (100% deductible)
- Section 179: Hardware & Tech Equipment (< $2,500 De Minimis Safe Harbor)
Audit & Anomaly Safeguard: Flags duplicate submissions within 48 hours and alerts on missing sales tax lines.
CPA & Tax Export: One-click download of an accountant-ready CSV, formatted JSON, and printable Schedule C summary report.

👥 Landing My First Users (Bonus Points Track)

I demoed PrivaLedger AI to three independent professionals to test whether they would actually pay for this and what they needed next:

1. Marcus Vance — Freelance Fullstack Developer

His Problem: Under NDA with a European fintech startup. Could not upload client invoices or contractor payouts to cloud AI scanners.
His Verdict: “I was paying for QuickBooks just to generate a CSV for my accountant at tax time. PrivaLedger being 100% client-side means I don't violate my client's privacy clauses.”
Would He Pay?: Yes, $49 Lifetime.
Next Asked Feature: Direct export to QuickBooks Desktop and FreeAgent CSV formats.

2. Sarah Chen — Independent Brand Designer

Her Problem: Hated Expensify's $9/user/month subscription to organize Figma, Adobe CC, and typeface receipts.
Her Verdict: “The automatic Schedule C line breakdown is worth its weight in gold. I usually spend 3 days before April 15 trying to figure out which line item goes where.”
Would She Pay?: Yes, $29 / Year.
Next Asked Feature: Multi-currency conversion for foreign client contracts.

3. David O'Connor — Solo Commercial Videographer & Editor

His Problem: Missed the 50% deduction limit on client dinners last year and got penalized by his CPA; failed to send 1099s to second shooters.
His Verdict: “The warning that popped up on a $1,250 subcontractor invoice reminding me to issue a 1099-NEC saved me from an IRS penalty alone.”
Would He Pay?: Yes, $39 One-Time.
Next Asked Feature: Bulk ZIP folder drag-and-drop.

🚀 Try It & Open Source Code

GitHub Repository: pixelcrisscross/PrivaLedger-AI (dev2)
License: MIT (100% Free & Open-Source)
Local Run:

  git clone https://github.com/pixelcrisscross/PrivaLedger-AI
  cd dev2
  npm install
  npm run dev

💡 Final Thought: The Future of Open-Source Micro-SaaS

Open-source AI isn't just about competing with frontier labs on benchmark leaderboards. Its real superpower is empowering solo founders to build ultra-private, zero-marginal-cost tools that solve genuine problems for real people.

By removing token fees, eliminating servers, and keeping user data private on their own hardware, open-weight AI makes micro-businesses profitable from day one.

NightSky Whisperer: An Offline AI Stargazing Companion on Arduino UNO Q

Piyush Annigeri — Sat, 17 Oct 2026 08:55:27 +0000

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

NightSky Whisperer 🌌

Less screen time. More time under the stars.

What if exploring the night sky felt less like operating an app and more like having an astronomy companion beside you?

Imagine stepping outside, pointing your phone toward the sky, and asking:

“Find Betelgeuse.”

Instead of searching through menus and reading information on a screen, NightSky Whisperer is designed to respond through voice, calculate where the star should be, and guide your attention using a tiny LED matrix.

The idea behind this project is simple: AI should help us experience the world, not give us another reason to stare at a screen.

What I Built

NightSky Whisperer is a local-first astronomy companion built around an Arduino UNO Q with 4 GB RAM and an Android phone.

The phone provides location, orientation sensors, and microphone input. The UNO Q runs the local AI and astronomy services, while its onboard LED matrix provides a physical interface for navigation and status feedback.

The project combines:

Offline speech recognition using Whisper through whisper.cpp.
Local AI conversations using a quantized Gemma 3 1B model served by llama.cpp.
Spoken responses generated using Piper TTS and played through the phone.
Astronomical calculations using Astropy to transform celestial coordinates into local altitude and azimuth.
Phone-based pointing using live location and orientation telemetry.
Physical LED animations for directional guidance, listening, thinking, speaking, target acquisition, and safety warnings.

Rather than building another astronomy chatbot that only returns text, I'm exploring how local AI can connect conversation to a real-world activity.

Demo

Source code: NightSky Whisperer on GitHub

The intended live demonstration starts with a spoken request to find a bright star. The system transcribes the request, produces a spoken response, calculates the target's position, and uses the LED matrix to communicate guidance or a safety warning.

A representative test also checks what happens when a star is below the horizon. Instead of issuing normal directional guidance, the astronomy service identifies that the target is geometrically below the horizon and marks navigation as non-actionable.

The project is running on real hardware, and I am continuing to validate the complete voice-to-navigation experience and physical direction mapping.

How I Built It

1. Local speech and AI

The voice pipeline uses three components:

Whisper through whisper.cpp transcribes spoken questions locally.

Gemma 3 1B through llama.cpp generates conversational answers on the UNO Q, without requiring a hosted language-model API for each question.

Piper TTS converts the response into speech, which is streamed back to the Android phone for playback.

This gives me control over the models, prompts, runtime, and integration between the different components.

2. Real-time astronomy

A star's celestial coordinates alone aren't enough to tell someone where to point their phone. Its local position depends on the observer's location and the observation time.

I integrated Astropy to transform star coordinates into horizontal coordinates:

Altitude: how far above or below the geometric horizon the target is.
Azimuth: its compass direction, measured from north.
Angular separation: how far the target is from the phone's current pointing direction.

The guidance engine compares the calculated target position with the phone's calibrated pointing direction and produces a coarse directional hint.

One important distinction: calculating that a star is above the horizon does not guarantee that it is visually observable. Daylight, clouds, buildings, glare, and light pollution can all interfere.

3. Connecting the phone and UNO Q

The Android phone streams location and orientation telemetry to a FastAPI server over WebSocket.

The server exposes endpoints for selecting stars, requesting guidance, controlling the matrix, and monitoring system state. The phone also supplies audio for the local speech pipeline.

The architecture is designed to keep core AI inference and astronomy calculations local. The phone and UNO Q still need a working local connection, and downloading updated data or software can require internet access.

4. The physical interface

The UNO Q's onboard LED matrix has only 8 rows and 13 columns. Designing useful animations at that resolution is an interesting constraint.

The firmware includes distinct states for directional arrows, listening, thinking, speaking, a target-acquired effect, a cosmic Easter egg, and a below-horizon warning.

A key design requirement is priority: active navigation and safety warnings should not be overwritten by decorative or conversational animations.

Why Open Innovation Matters

For an application designed to encourage outdoor exploration, I don't want internet access to be a mandatory dependency for every conversation.

Building around open-source software and an open-weight language model provides several advantages.

Privacy by design

Speech recognition and language-model inference can happen locally. A spoken astronomy question does not inherently need to be sent to a cloud AI provider.

Control over the technology

I can inspect the code, change command routing, adjust prompts, replace models, and improve the behaviour of the assistant without depending on a proprietary API's capabilities or pricing.

A path toward offline use

With the required models, software, and astronomy data already installed, the core voice-and-guidance pipeline is designed to operate locally. The phone-to-device connection must still be available unless another local transport is used.

AI that interacts with the physical world

The open components are not merely generating text. They are part of a system that combines speech, astronomical computation, mobile sensors, and a physical display to support an activity outside the screen.

Open innovation gave me the flexibility to build and change the whole stack rather than treating the language model as a black box.

Challenges and What I Learned

The hardest part has not been getting an AI model to explain a star. It has been making every component work together reliably.

For example, a voice assistant can correctly recognize “Find Betelgeuse” and generate an explanation without actually starting navigation. Recognizing a target, selecting it, activating the navigation session, checking sky conditions, and updating the matrix are separate operations that must be connected deliberately.

Astronomy introduces another challenge: correct coordinates do not automatically mean correct physical guidance. Sensor calibration, phone orientation, mount geometry, and matrix direction mapping all need validation on the assembled hardware.

I have also observed that local model latency can be significant on this device. Reducing the time between a spoken command and the physical response is an important next step.

These challenges have shaped the project into more than a chatbot. The goal is a complete system whose calculations, actions, and physical feedback can all be tested.

What's Next?

I want NightSky Whisperer to grow into a more capable personal astronomy companion.

My next priorities are:

Complete and validate voice commands that start and stop star navigation.
Verify physical left, right, up, and down guidance against the mounted phone.
Improve model latency and the time from voice input to response.
Expand the catalogue and add richer constellation exploration.
Improve recovery after power-on and loss of phone connectivity.
Test the system outdoors under actual nighttime conditions.

The longer-term vision is an assistant that helps people explore stars, constellations, planets, and other celestial objects through conversation and physical guidance—with the screen playing as small a role as possible.

Try It and Follow Along

GitHub: https://github.com/pixelcrisscross/nightsky-whisperer.git

I'm building NightSky Whisperer as a hardware-and-AI experiment, and real-world testing is an essential part of making it useful. The next milestone is a complete outdoor demonstration: ask a question, select a target, and verify that the physical guidance helps you find it safely.

What would you add to an offline AI astronomy companion? Constellation identification, satellite passes, meteor-shower alerts, or a conversational guide to the night sky?

I'd love to hear your ideas.

Hacktoberfest #OpenSourceAI #Arduino #Astronomy

FanFlame — The Passion Companion for World Cup Fans (Weekend Challenge: Passion Edition)

Piyush Annigeri — Sat, 11 Jul 2026 15:43:40 +0000

This is a submission for Weekend Challenge: Passion Edition

What I Built

FanFlame is a passion companion for World Cup fans, built with Streamlit
and the Gemini API. It turns the raw emotion of football fandom into
three interactive experiences:

🎤 Passion Pledge — generate a personal hype speech for your team, in a tone of your choice, optionally woven with your own memory of falling in love with the game.
🏆 Rivalry Trivia — pick two rival teams and instantly get a 5-question trivia quiz about their shared football history, legendary players, and iconic World Cup moments.
📊 Passion Meter — paste any fan chat message, tweet, or comment and get a 0–100 "passion score," a mood label, and a fun fan archetype.

What inspired this project

This weekend's prompt asked us to build something inspired by passion, and
with the World Cup happening right now, it felt obvious: passion for football
is one of the purest, loudest forms of passion there is. Rivalries, devotion,
36-year droughts, last-minute goals — it's all there. I wanted to build
something that didn't just talk about that passion, but let fans generate
and measure it themselves.

Demo

Code

pixelcrisscross / fanflame

🔥 FanFlame — The Passion Companion for World Cup Fans

Built for the DEV Weekend Challenge: Passion Edition (July 2026).

FanFlame is a Streamlit app powered by the Gemini API that helps World Cup fans express and explore their passion for the game in three ways:

🎤 Passion Pledge — generates a personalized hype speech for your team in your chosen tone, optionally woven with a personal memory.
🏆 Rivalry Trivia — instantly builds a 5-question multiple-choice quiz about any two rival teams' football history.
📊 Passion Meter — scores how much devoted-fan energy is packed into a fan chat message, tweet, or comment, with a fun "fan archetype" label.

Why this fits the theme

The World Cup is the purest expression of football passion — rivalries devotion, heartbreak, and joy all at once. FanFlame turns that passion into something interactive: fans can generate their own hype, test their rivalry…

View on GitHub

How I built it

Frontend/app: Streamlit, single app.py file with three tabs.
AI layer: Google's google-genai Python SDK calling gemini-2.5-flash.
- The Passion Pledge tab uses free-form text generation with a tuned prompt and temperature for creative, quotable output.
- The Rivalry Trivia and Passion Meter tabs use Gemini's structured JSON output mode (response_mime_type="application/json") so responses map cleanly onto the UI without brittle string parsing.
Styling: custom CSS for a warm, "flame" gradient theme that matches the passion theme.

Prize category

Submitting for Best Use of Google AI — the entire experience is powered
by the Gemini API for generation, trivia creation, and sentiment-style
scoring

BWAI'2026 @ VTU, Belagavi

Piyush Annigeri — Sun, 03 May 2026 15:31:54 +0000

#BuildwithAI

Hello Developer,
That's a wrap at BWAI'2026 @ VTU, Belagavi.

The Build with AI 2026 workshop series, hosted at Visvesvaraya Technological University (VTU), Belagavi, was a flagship initiative designed to transition students and developers from theoretical understanding to practical mastery of Artificial Intelligence. In an era where Generative AI and Autonomous Agents are redefining the engineering landscape, this week-long intensive program provided a sandbox for innovation.

The series focused on the "Learn-Build-Scale" philosophy, leveraging the Google Cloud Ecosystem. Over the course of seven days, participants engaged in high-intensity labs, credit redemption sessions, and collaborative builds, culminating in an Open Innovation Demo Day. The event served not only as a training ground but as a networking hub for the next generation of AI engineers.

🟢 DAY - 0 🔵 [06-04-2026]

Topic	Description
Onboarding & Environment Setup	Introduction to Google Cloud Platform (GCP), environment configuration, and Google Cloud Credit redemption to ensure zero-cost development for students.

🟢 DAY - 1 🔵 [07-04-2026]

Topic	Description
Conversational Voice Systems	Building voice-responsive agents. Integration of Compute Engine instances, LLMs (Large Language Models), and Asterisk for telephony-based AI interactions.

🟢 DAY - 2 🔵 [08-04-2026]

Topic	Description
Predictive Analytics & Big Data	Exploring BigQuery AI. Participants built a job navigation system that uses predictive analysis to match candidates with roles based on historical data patterns.

🟢 DAY - 3 🔵 [09-04-2026]

Topic	Description
A-2-A Workflow Orchestration	Advanced Agent-to-Agent workflows. Utilizing MCP Java SDK and Vertex AI to create interconnected systems where AI agents communicate to solve complex tasks.

🟢 DAY - 4 🔵 [10-04-2026]

Topic	Description
Enterprise Supply Chain Agents	High-level engineering using AlloyDB AI and ScaNN (Scalable Nearest Neighbors). Building an autonomous supply chain agent capable of multimodal data processing.

🟢 DAY - 5 🔵 [11-04-2026]

Topic	Description
Surplus Engine with Cloud SQL In-Database AI	In this codelab, you will build KarmaLoop — a sustainable surplus-sharing app that treats intelligence as a first-class citizen of the data layer.

🟢 DEMO DAY 🔵 [13-04-2026]

Topic	Description
AI for Engineers: Challenges and Opportunities	As a primary mentor, Mr. Bhandari brought a wealth of international experience from the heart of Google's engineering labs in Japan. His session addressed the critical shift in the job market, emphasizing that the modern engineer must be "AI-augmented."

Speaker@BWAI


	Haren Bhandari 🔴 LINKEDIN GOOGLE - TOKYO Senior Developer Relations Engineer

Organizers@BWAI


	Piyush Annigeri 🔴 LINKEDIN ORGANIZER Google Developer Group on Campus, Visvesvaraya Technological University, Belagavi


	Yuvaraj Sutar 🟡 LINKEDIN CONTENT CREATOR Google Developer Group on Campus, Visvesvaraya Technological University, Belagavi


	Prajwal Rawoot 🔵 LINKEDIN TECHNICAL-LEAD Google Developer Group on Campus, Visvesvaraya Technological University, Belagavi


	Shravan Chougule 🟢 LINKEDIN MEDIA-LEAD Google Developer Group on Campus, Visvesvaraya Technological University, Belagavi


	Ananyaa Sudhanshu 🔴 LINKEDIN EVENT COORDINATOR Google Developer Group on Campus, Visvesvaraya Technological University, Belagavi


	Advika Gurav 🟡 LINKEDIN PR & MARKETING Google Developer Group on Campus, Visvesvaraya Technological University, Belagavi


	Yash Koparde 🟢 LINKEDIN TECHNICAL-LEAD Google Developer Group on Campus, Visvesvaraya Technological University, Belagavi

#BWAIchampions


	Sadiya Sanadi 🟡 LINKEDIN Second-year AI/ML student at Jain College of Engineering, Belgaum.

I recently developed NyayaSetu, an AI-powered welfare rights navigator that helps users discover government schemes and check eligibility easily, addressing the lack of awareness and difficulty in accessing public welfare information. The project secured 1st place for its impact and usability.


	Muhammad Rehan 🟡 LINKEDIN Founder of StackBIZ.tech & a result-driven full-stack developer focused on building production-ready SaaS platforms, cloud infrastructure, & AI-based solutions.

I created PromptedForge.in, an AI-powered platform that helps students generate problem statements, prompts, and execution roadmaps without the need for brainstorming. My work has been recognized by the Entrepreneurship Cell at IIT Delhi, and you can explore the platform at promptedforge.in.

Irayya R Hiremath
🟡 LINKEDIN

I am a BCA student with a strong interest in software development and technology. I am currently learning programming languages like Python and JavaScript and working on practical projects to build my skills. I am passionate about creating useful applications and continuously improving my knowledge in the tech field.

The Build with AI workshop at VTU Belagavi concluded as a landmark event for the region's tech community. By providing direct access to Google experts and enterprise-grade tools, the workshop demystified the complexities of Artificial Intelligence.

Moments@BWAI