DEV Community: Basant Nema

PhantomShell: The Haunted Terminal Possessed by Forgotten Code & Dead Daemons

Basant Nema — Wed, 28 Oct 2026 13:41:59 +0000

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

What I Built

PhantomShell is an offline, spooky AI-possessed terminal that breathes life into the spirits of forgotten computing history for Halloween and Día de los Muertos.

As developers, we work on top of layers of dead abstractions—abandoned languages, defunct systems, and silent processes. PhantomShell turns your terminal into a digital séance. Every command you enter (ls, cd, git, rm, kill, python) is intercepted by local open-weight AI personas (such as Ada Lovelace, the Uncaught Kernel Panic of '89, and Forgotten Lisp Daemons) who whisper back eerie commentary, cryptic lore, and cautionary reflections.

Everything runs completely offline and air-gapped on your machine with zero cloud model API costs or telemetry.

Demo

The application boots into a nostalgic, haunted CRT screen complete with phosphorescent scanlines, chromatic flicker, and haunting whisper transcripts:

[ Developer Terminal Command ]  -->  [ Local Spectral Agent ]  -->  [ Eerie CRT Whisper Log ]
      (e.g., git commit / rm -rf)            (Zero Cloud Egress)              (Haunted Commentary)

Running locally at http://localhost:5004:

Haunted Commentary: Run git commit and hear the shell whisper: "Committing your sins to immutable history... HEAD is permanently detached from the mortal realm."
Terminal Séance: Channels early computer pioneers and forgotten operating system daemons.
Air-Gapped Spirit: 100% private, runs in the dark with no internet required.

Code

The source code is open source under the MIT License:

basantnema31 / phantom-shell

PhantomShell 👻

A Haunted AI Terminal Possessed by Forgotten Code & Ancient Spirits

Built for the Hacktoberfest Open-Source AI Challenge: Week 4 — "Ghost in the Machine"

🎃 Concept & Theme Inspiration

Halloween and Día de los Muertos remind us that the boundary between past and present is delicate. In computer science, billions of lines of forgotten code, abandoned languages, and crashed processes linger in dead repositories and unallocated drive sectors.

PhantomShell is an offline, spooky AI-infused terminal environment that simulates a system "possession." As you execute commands (ls, git, rm, cd, python, kill), an open-weight ghost agent whispers haunting commentary, ancestral computing memories, and eerie philosophical reflections back into your shell.

⚡ Features

💀 Spectral Terminal Interface: Retro CRT monitor aesthetic with scanlines, phosphorescent green glow, and flickering screen simulation.
🕯️ Eerie Command Whispers: Intercepts standard POSIX and developer commands to deliver…

View on GitHub

How I Built It

Python Flask Core: Minimalist local backend handling command routing and spectral response synthesis.
Retro CRT Aesthetic: Built with Tailwind CSS, custom CSS scanline layers, phosphor glow animations, and keyboard navigation.
Offline Open-Weight AI Architecture: Designed to hook into local quantized models (e.g. Qwen2.5, SmolLM) for unpredictable, atmospheric persona generation without network lag.

Why Open Innovation Matters

In the spirit of Ghost in the Machine and Día de los Muertos:

Preserving Computing History: Proprietary cloud APIs eventually get sunset, deprecate models, and vanish. Open-source code and open-weight models ensure that digital art and experimental creations remain preserved and runnable decades into the future.
True Dark Mode (Works with the Lights Off): An authentic spooky experience shouldn't fail because an internet router disconnected. Open models run natively in the dark on edge hardware.
Privacy of the Hearth: Your terminal history, family memories, and personal code stay strictly on your local disk.

Built with 🎃 and ❤️ for Hacktoberfest 2026.

Giving AI Agents On-Call Memory: Building a PagerDuty Connector for Cognee

Basant Nema — Fri, 23 Oct 2026 15:45:42 +0000

The Problem: The Disconnected Incident Room

When production breaks at 3 AM, PagerDuty pages the on-call engineer. Responders assemble, diagnose the issue, mitigate the failure, and acknowledge or resolve the incident.

Thousands of critical context bits are generated in that frantic window:

Which service degraded first?
Who was the incident commander?
What was the urgency level?
What raw alerts fired from monitoring systems?

Yet once resolved, this rich operational history disappears into closed ticket archives. When your team asks an AI agent "What triggered our last payment gateway degradation?" or "Who usually leads recovery on our Kafka clusters?", the agent is clueless because that operational context was never connected to its memory graph.

In this post, we explain how we built a production-grade PagerDuty data-source connector for Cognee to bridge this gap.

What is Cognee?

Cognee transforms raw unstructured text into structured, searchable Knowledge Graphs and vector embeddings for AI agents. Rather than running blind RAG over uncurated chunks, Cognee builds an explicit entity-relationship memory graph so agents can query complex operational dependencies.

Connector Architecture & Design

Connecting PagerDuty to Cognee required solving several real-world requirements:

1. Document-First Synthesis

Cognee extracts entities from natural prose. Instead of dumping arbitrary JSON schemas, our connector synthesizes PagerDuty incident payloads into structured Markdown:

Incident title & unique ID
Status (Triggered, Acknowledged, Resolved)
Urgency level (High, Low)
Impacted service attribution
Incident commander and on-call responders
Associated alert events and monitoring triggers

2. Offset-Based Pagination

PagerDuty v2 REST API exposes /incidents paginated with limit (max 100) and offset. The connector iterates until more=false or no records remain, ensuring complete historical coverage without skipping records.

3. Rate Limiting with Exponential Backoff

PagerDuty APIs enforce rate limits. Our HTTP client automatically catches HTTP 429 and 5xx errors, extracts the Retry-After header when available, and falls back to an exponential backoff strategy (2^attempt seconds) up to 5 retries.

4. Forget-on-Delete Lifecycle

Using write_disposition="replace", Cognee maintains a fresh snapshot of all active and resolved incidents. If false-alarm incidents are deleted or retracted upstream, Cognee's orphan_cleanup purges their entities automatically.

Quick Demo: Ingesting PagerDuty with Cognee

`python
import asyncio
import os
import cognee
from cognee_community_connector_pagerduty import pagerduty_source

async def main():
# Configure connector with high-urgency filter
source = pagerduty_source(
api_token=os.environ["PAGERDUTY_API_TOKEN"],
urgencies=["high"]
)

# Ingest and construct Knowledge Graph
await cognee.add(source)
await cognee.cognify()

# Query operational memory
answer = await cognee.search("Who resolved the last payment outage and what service was affected?")
print(answer)

if name == "main":
asyncio.run(main())
`

Quality & Testing

We wrote a suite of 27 offline unit tests using standard library mocks covering:

Markdown rendering across all status and urgency permutations
Robust fallback when responders or services are unspecified
Client URL building and query-parameter serialization
Rate-limit backoff header handling
End-to-end dlt pipeline row generation

Get Involved

GitHub PR: #485 on topoteretes/cognee-community
GitHub Issue: #6288 on topoteretes/cognee
Cognee Core: topoteretes/cognee

If your team uses PagerDuty, try ingesting your operational history into Cognee and let us know what you think!

Building Outage Memory for AI Agents: Better Stack Connector for Cognee

Basant Nema — Fri, 23 Oct 2026 15:04:49 +0000

Building Outage Memory for AI Agents: Better Stack Connector for Cognee

High availability is the bedrock of any software system. Monitoring tools like Better Stack (Better Uptime) track endpoint heartbeats, SSL validity, API responsiveness, and on-call paging around the clock.

Yet, when incidents happen, the knowledge is often trapped in incident dashboards and alert history logs.

By integrating Better Stack with Cognee, we can transform infrastructure telemetry and outage reports into queryable knowledge graphs for AI engineering agents.

Why Connect Better Stack to Cognee?

Autonomous AI coding agents, DevOps assistants, and support bots frequently need infrastructure context:

"Which API endpoints failed health probes during yesterday's release?"
"What was the root cause of the last 502 Bad Gateway alert?"
"How long did it take between monitor alert triggering and engineer acknowledgment?"

With the better_stack connector for Cognee, this telemetry becomes part of the AI's long-term memory.

How It Works

The connector lives in packages/connector/better_stack/ within cognee-community.

1. Ingestion Pipeline

The connector calls Better Stack's REST API v2 (/incidents and /incidents/{id}/timeline), handling pagination and exponential retry backoff on HTTP 429/5xx responses.

2. Narrative Prose Extraction

Each outage report is structured into markdown format for Cognee's entity extraction:

# Better Stack Incident: API Gateway 502 Bad Gateway

- **Status:** resolved
- **Started At:** 2026-10-12T08:00:00Z
- **Resolved At:** 2026-10-12T08:14:00Z

## Root Cause & Description
Upstream backend timed out during deployment rollback.

## Chronological Timeline
- **[2026-10-12T08:00:00Z]** Triggered - Monitor check failed 3 consecutive times
- **[2026-10-12T08:02:00Z]** Acknowledged - Engineer on-call acknowledged via Slack
- **[2026-10-12T08:14:00Z]** Resolved - Rollback completed and healthy probes returned HTTP 200

3. Entity Graph Linking

Because the source specifies cognee_document_source = "better_stack", Cognee treats each outage report as a first-class knowledge document. The graph links endpoints, error codes, and resolution steps so agents can recall operational history instantly.

Getting Started

import asyncio
import cognee
from cognee_community_connector_better_stack import better_stack_source

async def main():
    source = better_stack_source()
    await cognee.add(source)
    await cognee.cognify()

    results = await cognee.search("Which services experienced downtime last week?")
    for res in results:
        print(res)

if __name__ == "__main__":
    asyncio.run(main())

Operational observability meets AI memoryâ€”ensuring your agents never forget past system lessons.

Giving AI Agents Operational Memory: Connecting incident.io to Cognee

Basant Nema — Fri, 23 Oct 2026 15:00:01 +0000

Giving AI Agents Operational Memory: Connecting incident.io to Cognee

Modern software reliability hinges on incident response. During a critical outage, engineers jump into channels, declare an incident, mitigate root causes, and record post-mortems and remediation items.

Tools like incident.io have become the gold standard for tracking this lifecycle. But what happens after the incident is resolved?

In most organizations, that vital operational wisdom is siloed. When an on-call engineer or an autonomous AI agent encounters a similar timeout, degraded cluster, or memory leak weeks later, it has zero contextual memory of the past outage.

In this post, we explore how building a dedicated data-source connector for Cognee bridges this gap, feeding real-time incident data into an AI agent memory graph.

What is Cognee?

Cognee is an open source memory and knowledge-graph layer for AI agents. Rather than dumping unstructured text into naive vector stores, Cognee processes raw enterprise documents, extracts entities and relationships, and indexes them into a unified knowledge graph.

With three asynchronous calls:

await cognee.add(source)
await cognee.cognify()
results = await cognee.search("What caused the recent billing outage?")

agents can recall complex relationships across different tools.

Why Connect incident.io?

When an outage strikes, incident.io records:

Incident Attributes: Severity (Critical, Major), lead responders, components affected, and executive summaries.
Chronological Timelines: Real-time updates with timestamps capturing investigative milestones.
Action Items: Follow-up tasks with assignees and completion states.

By ingesting this into Cognee, engineering teams and AI assistants can answer operational queries like:

"Who was the lead responder on the last database connection pool exhaustion?"
"What remediation actions were decided after our Cloudflare 502 outage?"
"Are there recurring outage patterns affecting our payments service?"

Technical Architecture & Ingestion Flow

The incident_io connector lives in cognee-community/packages/connector/incident_io/.

1. Document Mode Routing

Instead of pushing raw tabular database rows, the connector tags its dlt source with:

setattr(source, DOCUMENT_SOURCE_ATTR, "incident_io")

This signals Cognee's ingestion pipeline (resolve_dlt_sources) to treat each incident as a rich Markdown prose document, passing it directly through LLM entity extraction and knowledge-graph linking.

2. Markdown Synthesis

Each incident is flattened into structured, human-readable markdown with clear headings:

# Incident: Database Connection Pool Exhaustion

- **Status:** resolved
- **Severity:** Major
- **Lead:** Alex Mercer
- **Opened:** 2026-10-10T14:00:00Z
- **Resolved:** 2026-10-10T14:45:00Z

## Summary
Primary Postgres pool was saturated causing 504 Gateway Timeouts.

## Timeline & Milestone Updates
- **[2026-10-10T14:05:00Z]** Investigating high latency on api-gateway.
- **[2026-10-10T14:40:00Z]** Increased max connections in PgBouncer; service stabilized.

## Remediation & Follow-up Actions
- [x] Add alert threshold for PgBouncer pool saturation (Assignee: DevOps OnCall)
- [ ] Perform query audit on long-running analytics jobs (Assignee: Data Team)

3. Full Snapshot & Forget-on-Delete

Using write_disposition="replace", Cognee maintains an exact mirror of current incidents. If an incident or draft report is permanently deleted or expunged in incident.io, it naturally drops out of the active snapshot and Cognee's orphan_cleanup purges the corresponding nodes from both graph and vector storage.

Quickstart

import asyncio
import cognee
from cognee_community_connector_incident_io import incident_io_source

async def main():
    # Ingest incident.io data
    source = incident_io_source()
    await cognee.add(source)

    # Build the knowledge graph
    await cognee.cognify()

    # Search past incident memory
    answers = await cognee.search("How did we resolve the pool saturation issue?")
    for ans in answers:
        print(ans)

if __name__ == "__main__":
    asyncio.run(main())

Conclusion

Operational intelligence is one of the most valuable forms of company knowledge. Connecting incident.io to Cognee transforms static post-mortems into an active, queryable memory graph that empowers both developers and AI agents to resolve outages faster.

VaultMind: The 100% Offline AI Knowledge Box for Disasters & Air-Gapped Expeditions

Basant Nema — Mon, 19 Oct 2026 14:26:57 +0000

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

What I Built

VaultMind is an offline-first, air-gapped AI Knowledge Box and semantic retrieval engine designed for environments where cellular connectivity and the public internet are completely absent—such as remote expeditions, disaster relief camps, and grid blackout scenarios.

Modern AI assistants rely heavily on always-connected cloud APIs. When communication towers fail or field researchers travel into remote wilderness, access to vital knowledge (field medicine, solar setups, radio calling channels, emergency protocols) vanishes.

VaultMind runs quantized open-weight language models and local vector embedding search directly on edge devices (laptops, rugged tablets, and single-board computers) with zero internet dependencies and 0 KB network egress.

Demo

The user interface provides instant local semantic search across pre-loaded guides, document ingestion, and privacy telemetry:

[ Ingested Field Manuals ]  -->  [ Local Dense Vector Store ]  -->  [ Air-Gapped Semantic Search ]
       (Offline Storage)               (Local Quantized Embeddings)            (Real-Time Response)

Running locally at http://localhost:5003:

Resilient Memory: Pre-loaded with essential survival, emergency power, and communication protocols.
Local Ingestion: Allows field workers to drop new procedural docs and instantly index them offline.
Air-Gapped Guarantee: All semantic calculations occur in-memory without contacting external servers.

Code

The code is 100% open-source under the permissive MIT License:

basantnema31 / vault-mind

VaultMind 📦

100% Offline AI Knowledge Box & Resilient Semantic Memory

Built for the Hacktoberfest Open-Source AI Challenge: Week 3

🧭 The Vision & Problem

When cellular networks fail, off-grid expeditions travel beyond coverage, or natural disasters compromise internet infrastructure, standard AI search tools (like ChatGPT, Perplexity, or Claude) instantly become inaccessible.

Critical knowledge—such as field first-aid instructions, emergency water filtration methods, or power inverter schematics—must be available offline and air-gapped.

VaultMind is an offline-first AI Knowledge Box that runs compact open-weight language models and dense vector embeddings entirely locally on edge devices (laptops, rugged tablets, and single-board computers).

⚡ Key Highlights

📴 Zero-Egress Vector Search: Run semantic question-answering without sending a single byte over the public internet.
🧠 Open-Weight Core: Powered by quantized models (such as SmolLM, Qwen2.5, or Llama-3.2-1B).
💾 Portable Knowledge Base: Export and import compact JSON/binary vector packages for disaster preparedness.
🛡️ Privacy & Resilience:…

View on GitHub

How I Built It

Backend Architecture: A clean, lightweight Python Flask microservice that implements an in-memory vector similarity index.
Offline Model Support: Designed to pair with compact open-weight models (e.g., Qwen2.5-Coder-1.5B, SmolLM-360M, or Llama-3.2-1B).
Edge UI: Tailored with a low-power, dark-mode dashboard optimized for high-contrast visibility on rugged portable field displays.

Why Open Innovation Matters

Open innovation is what makes a project like VaultMind possible:

True Fault Tolerance: Closed proprietary models cannot operate when internet cables are severed. Open-weight models empower developers to build software that works when society's infrastructure fails.
Sovereignty & Security: First responders and expedition teams maintain total custody over critical data without exposing telemetry to third-party providers.
Hardware Accessibility: Open-source AI can be quantized to run on modest \$35 Raspberry Pis and decade-old laptops, democratizing knowledge preservation globally.

Built with ❤️ for Hacktoberfest 2026.

ReceiptVault: The 100% Offline AI Bookkeeper for Freelancers Under Strict NDAs

Basant Nema — Tue, 13 Oct 2026 14:26:27 +0000

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

What I Built

ReceiptVault is a zero-data-leakage, offline-first AI accounting and invoice parser designed specifically for freelancers, consultants, and boutique agencies working under strict client Non-Disclosure Agreements (NDAs).

Standard cloud accounting software either charges hefty recurring fees or relies on closed cloud AI APIs where confidential client bills, hourly rates, and project scopes risk being ingested for model training or data logging.

ReceiptVault runs quantized, open-weight language models locally on your computer. You drop receipt text or invoice OCR, and it instantly extracts line items, dates, vendor metadata, and tax categories into an audit-ready ledger with zero outbound network traffic.

Demo

The user interface provides instant local parsing, privacy badges, and one-click tax CSV export:

[ Receipt Ingestion Panel ]  -->  [ Local Quantized Model ]  -->  [ Encrypted Tax Ledger ]
      (Offline / Air-Gapped)           (Zero Cloud Telemetry)            (Audit-Ready CSV Export)

Running locally at http://localhost:5002:

Categorization: Automatically flags software subscriptions, subcontractor payouts, and business expenses.
Privacy Assurance: 100% of data processing remains in-memory on the local host.
Export: Instant tax deductible summary formatted for accountants and tax season.

Code

The project is completely open source under the MIT License:

basantnema31 / receipt-vault

ReceiptVault 🔐

Zero-Leak, Local-AI Bookkeeping & Invoice Parser for Freelancers

Built for the Hacktoberfest Open-Source AI Challenge: Week 2 — "Side Hustle"

💼 The Problem & Why Someone Would Pay For It

Freelancers, agency owners, and independent contractors regularly sign strict Non-Disclosure Agreements (NDAs) with clients. They cannot upload confidential invoices, receipts, project milestones, or subcontractor bills to cloud LLMs (like OpenAI or Anthropic) without risking breach of contract or leaking proprietary pricing.

Yet, manual bookkeeping takes 4 to 8 hours per week and standard accounting software charges $30–$60/month.

ReceiptVault solves this with a privacy-first, offline open-weight AI architecture:

🛡️ Zero Data Egress: All parsing and entity extraction runs locally using open-weight models.
⚡ Automated Categorization: Classifies expenses into standard tax categories.
📊 One-Click Tax Export: Generates clean, audited CSV ledger ready for accountants.
💰 Monetization Viability: Freelancers happily pay a one-time $29–$49 lifetime license or $9/mo offline desktop utility…

View on GitHub

How I Built It

Core Engine: Lightweight Python Flask service that interfaces with local open-weight models (such as Qwen2.5-Coder and SmolLM).
In-Memory Ledger: Structured entity extraction capturing vendor, date, invoice IDs, subtotal, and tax rates without external database dependencies.
Frontend Dashboard: Clean dark-mode dashboard tailored for quick review, manual override, and bulk CSV generation.

Why Someone Would Pay For It (The Side Hustle Thesis)

Freelancers spend an average of 4 to 6 hours every month sorting receipts, matching expenses, and categorizing invoices for tax season. More importantly:

NDA Compliance is Worth Real Money: Freelancers risk thousands of dollars in breach-of-contract penalties if client project invoices leak to cloud LLMs. An air-gapped solution solves this pain point completely.
Predictable Pricing: A one-time $29–$49 desktop license or a modest $9/month subscription offers compelling ROI compared to SaaS platforms that cost $30–$60 every single month.

Why Does Open Innovation Matter?

Open innovation was crucial to making ReceiptVault both technically viable and economically practical:

True Confidentiality: Closed API vendors cannot offer air-gapped guarantees for small desktop utilities. Open-weight models ensure that user data stays strictly on the user's hardware.
Zero Marginal Inference Cost: By running on local hardware, the product incurs $0 in per-token API costs. This makes low-cost one-time licenses profitable.
Model Sovereignty: Developers and users have the freedom to swap or fine-tune models to adapt to local regional tax rules without platform lock-in.

Prize Categories

Featured Category: Side Hustle Challenge (Primary Entry)

Built with ❤️ for Hacktoberfest 2026.

NaturePulse: An Offline AI Companion to Get You Outside

Basant Nema — Wed, 07 Oct 2026 15:50:36 +0000

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

What I Built

NaturePulse is an offline-first eco-trail and bio-sound guide. It uses an open-weight acoustic model running entirely on your local machine to identify species from ambient trail sounds. The goal is to get people to look away from their screens and up into the canopy by providing quick, localized nature prompts without needing an internet connection.

Demo

You can run the app locally and explore its interface.

Code

The project is open source and available under the MIT license on GitHub:

basantnema31 / nature-pulse

NaturePulse 🌲

Your Screen-Free, Offline Eco-Trail & Bio-Sound Companion

Built for the Hacktoberfest Open-Source AI Challenge: Week 1 — "Touch Grass"

What It Does

NaturePulse is a 100% offline nature companion that uses open-weight AI acoustic pattern matching to help hikers, birders, and outdoor explorers identify local wildlife species without needing an internet connection on the trail.

The goal is simple: minimize screen time and maximize time outside. You open the app before you leave, and it runs entirely on your local machine — no API calls, no telemetry, no signal required.

Why Open-Source AI Was Essential

Zero Signal on Trails: Cloud AI APIs are useless without connectivity. Open-weight models run locally.
Data Privacy: Nature journals, GPS data, and wildlife observations stay on your device.
No Subscription Cost: Free to run indefinitely on any laptop or Raspberry Pi.
Model Swappability: Easily swap in a fine-tuned bird-call…

View on GitHub

How I Built It

NaturePulse is built with a lightweight Python Flask core. It's designed to interface with local open-weight acoustic models (like BirdNET or similar audio classification models) to process soundscapes locally. It returns species identification alongside actionable prompts to encourage the user to explore their immediate environment.

Why Does Open Innovation Matter?

Open innovation was essential for NaturePulse for three main reasons:

Zero Signal on Trails: Cloud AI APIs are useless in the woods. By running an open-weight model locally, the tool works perfectly offline.
Data Privacy: Your location, trail history, and audio recordings stay on your device, avoiding surveillance capitalism in the great outdoors.
No Subscription Costs: Open models run for free on your hardware, making the tool accessible to anyone.

Prize Categories

Featured categories (Touch Grass Challenge)

Built with ❤️ for Hacktoberfest 2026.

Building PocketSage: A Completely Private Local AI Companion for a Friend

Basant Nema — Fri, 02 Oct 2026 07:22:03 +0000

Building PocketSage: A Completely Private Local AI Companion for a Friend

The Inspiration

A close friend of mine wanted a personal AI assistant to organize daily thoughts and journal securely, but had strict data privacy concerns regarding cloud-hosted LLM providers. To solve this, I built PocketSage during the Hacktoberfest Launch Weekend Challenge ("Build for a Friend").

Why Open-Source & Open-Weight AI was Essential

Using open-weight models and a local-first architecture was non-negotiable for this project:

Zero Data Leakage: Sensitive personal thoughts stay on the device and are never sent to external servers.
Offline Resilience: Works seamlessly without an active internet connection.
No Subscription Costs: Runs locally without API quota limits or monthly costs.

Technical Execution & Open-Source Code

PocketSage is built with a minimal Python Flask core paired with local inference endpoints:

@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    user_message = data.get('message', '')
    # Processed 100% locally with zero external network traffic
    response = process_thought_locally(user_message)
    return jsonify({"response": response})

Open-Source Repository: PocketSage on GitHub (MIT License)

Handing It Over

The project has been packaged as a lightweight repository complete with an MIT License and quickstart guide so my friend can run it locally with zero friction!

Built for the Hacktoberfest Launch Weekend Challenge.

G-Force: The Quantum Gravity UI Spec (Parody)

Basant Nema — Sat, 11 Apr 2026 06:10:46 +0000

What I Built

I built G-Force: The Quantum Gravity UI, a satirical project showcasing the (fictional) upcoming "CSS Gravity Level 1" specification.

Instead of a standard layout, this dashboard uses Matter.js to simulate real-world physics for your UI. After a "Quantum Training" phase (collecting entropy from mouse movements), the AI agent (Gemini) accidentally activates the gravity module, causing the entire dashboard—headers, buttons, and stats—to physically detach and tumble into a pile at the bottom of the screen.

Demo

Live Demo on GitHub Pages

Code

GitHub Repository

How I Built It

Matter.js: For real-time 2D physics and collision detection.
Vite & Vanilla JavaScript: To handle the high-performance DOM-to-Physics body mapping.
Glassmorphism & Neon Design: To create a "Premium AI Startup" aesthetic that makes the eventual collapse even more hilariously unexpected.
CSS3 Transforms: Synchronized with the physics engine at 60fps for smooth, heavy tumbling.

Prize Category

I am submitting for:

Best Google AI Usage: For the mock "Gemini Gravity Stabilizer" and the "Entropy Training" phase where the user must physically generate random data to "calibrate" the AI.
Best Ode to Larry Masinter: The UI features a floating red 418 Teapot that acts as the "Emergency Fix." When clicked, it "boils" the viewport, generating anti-gravity "steam" that sends your UI floating back into the air.
Community Favorite: Because every developer has felt like their CSS layout was fighting against gravity.

Built with ❤️ for the DEV April Fools Challenge 2026.