DEV Community: Himanshu Yeole

haunt — Don't Run This CLI Tool Alone in the Dark

Himanshu Yeole — Sat, 31 Oct 2026 18:25:27 +0000

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

What I Built

haunt is a small, rainy, lantern-lit world with one ghost in it, and the ghost actually talks back.

You swipe up on a Halloween card, the screen flickers as if something is arriving, and a 3D ghost drifts across dark water carrying a lantern. You can steer it, push its lantern, poke it, and whisper to it. Its robe moves in the wind, the lantern swings like a pendulum, and the lantern's light breaks up on the rain-ruffled water.

I read the theme as both halves of the week:

Halloween mode is the haunted machine. Turn on Haunting and, after at least a minute (plus a random delay), the page starts acting possessed. Each event is preceded by a build-up: the rain stops, the lantern gutters, the ghost goes still and slowly turns to face you, a heartbeat quickens, and then everything cuts to silence before it hits. Events include a fake system monitor that "scans" your screen, an idle watch ("Are you still there?"), a fake terminal, footsteps rippling across empty water, and a second pale lantern drifting toward the ghost.
Ofrenda mode is the gentle half, for Día de los Muertos. The haunting switches off completely. The ghost asks who you're remembering and, once you name them, can speak with the warmth of that person as an echo built from your own memories. It never invents facts about them, never claims to be the real person, and says so honestly if you ask.

After every haunting event the ghost comments on what you just did ("You looked away for 40 seconds"), so the haunting feels aimed at you rather than scripted.

Code

himanshuyeolecse-jpg / haunt

A 3D ghost with a lantern that drifts across dark rainy water and thinks with a local AI model (Ollama + Gemma). Halloween haunting events, Ofrenda mode, ambient audio. Zero pip installs.

👻 haunt

A 3D ghost with a lantern that drifts across dark, rainy water — and thinks with a local AI model. Everything runs on your machine. Nothing leaves it.

✨ Features

3D ghost rendered in real-time with Three.js — cloth sway, lantern pendulum, rain ripples, and dynamic lighting
Local AI brain — powered by Ollama + Gemma (or any model you have); whisper to it and it whispers back
Haunting mode — 11 escalating horror events fire every ~30 seconds: fake system monitor, idle watch, terminal takeover, footsteps across the water, a second lantern, the ghost staring off-screen, and more
Ofrenda mode — Día de los Muertos remembrance mode; the ghost listens with warmth and can speak with the echo of someone you name
Ambient audio — synthesized rain, drone, heartbeat and whispers, plus looping background music; both start automatically
Zero dependencies — stdlib Python only for the server…

View on GitHub

haunt/
├── haunt_web.py        # stdlib-only Python server + Ollama proxy (no pip installs)
├── src/main.js         # the 3D scene (three.js): ghost, cloth, lantern, water, rain
└── static/
    ├── index.html      # swipe-up intro + flicker transition
    ├── haunting.js     # the haunting engine: events, sound, escalation
    ├── music.js        # background music with ducking
    ├── ghost.bin       # the optimized ghost model
    └── app.js          # bundled scene

Run it:

ollama pull gemma3
python haunt_web.py      # then open http://127.0.0.1:8787

How I Built It

The open pieces

Gemma (open-weight) runs the ghost's voice through Ollama, on localhost. The server picks any Gemma model you've pulled first, and the dropdown lets you swap models live.
three.js and esbuild build and render the scene; meshoptimizer shrank the ghost model.
The server is plain Python standard library. There are no CDNs, no remote fonts, no API keys.

The model and the scene
My ghost arrived as a single fused 52 MB mesh (about 1.9M triangles) with no skeleton and no animation. I decimated it to roughly 110k triangles while keeping its UVs, marked the lantern's vertices with a per-vertex weight, and animated everything in the vertex shader: the robe's hem and folds blow in the air, the lantern swings around its handle as a damped pendulum fed by the ghost's acceleration, and you can brush or click it to set it swinging. The water is a shader too: rain ripples plus the lantern's light glittering on them.

The ghost's voice
This is where the prompt design mattered most. On top of the original short, in-character lines, the ghost follows listening rules: never assume who you are or who you lost, meet laughter, tears, numbness or silence as they come, match your mood and length, avoid clichés, reply in your language, and step out of the ghost voice if someone talks about hurting themselves. In Halloween mode, the haunting events are passed to Gemma as bracketed "notes" with real facts (how long you were idle, whether you pressed Esc), and the model is told to say only what the note says.

Sound, with a lesson
All the sound is synthesized in the browser (drone, heartbeat, whispers, rain). My first mix was close to inaudible, so I added a meter and measured it: about -50 dBFS at rest. I raised the levels and added mid-range layers so laptop speakers can actually play it (about -36 dBFS at rest, around -21 dBFS at peak dread).

Honest limits

The ghost's eyes are painted into the texture, so it can't move its eyes; it turns its whole body instead.
"Active window" awareness is limited to the browser tab, and the system-monitor and file-scan events are simulations that use only values the browser already shares (no files are read, no commands run, the camera is switched off the instant it turns on).

Why Does Open Innovation Matter?

This project is about trust, and a closed API would have undermined it.

Private grief. In Ofrenda mode, people may type the name of someone they've lost. With a local open-weight model, those words never leave the machine. That wasn't a cost-saving choice; it's the only version I'd be comfortable asking someone to use.
Offline. The whole experience runs without internet once the model is pulled: three.js, textures, music and fonts all ship in the folder.
Changing the ghost's mind. Swapping models is one dropdown, and the personality lives in a prompt I can read, edit and test, not behind someone else's policy changes. I could add safety behavior (stepping out of character when someone sounds unsafe) at the exact layer where it belongs.
Free to run. Nothing is metered, so the ghost can keep talking for as long as someone wants to sit with it.

Prize Categories

The Spirit of ItIt clicked at 2:30 a.m. while test-running the code in a pitch-black room with headphones on. I typed a target name into the prompt, hit enter, and watched the terminal drop into a dead silence before the ambient audio shift kicked in. The sudden, low-frequency hum paired with the slow-scrolling text made me glance over my shoulder at the dark hallway behind my desk. That split-second of genuine hesitation—wondering if I really wanted to see what keypress triggered next—was when I knew the atmosphere was dialed in right.

Credits and assets

Prize CategoriesGrand Prize / Spookiest Project: For building an immersive, interactive terminal/CLI experience focused on atmospheric horror and suspense.Best Maintainer / Open Source Integration: Fully open-sourced repository with clean documentation, clear installation steps, and open setup for Hacktoberfest contributors.

Best Use of ElevenLabs: Adding atmospheric audio elements, creepily realistic voice narration, and haunting soundscapes to elevate the terminal horror experience.
Best Use of GitHub Copilot: Built using GitHub Copilot CLI and coding agent integrations to streamline open-source contributions and maintainer workflows.
Best Use of Backboard: Integrating Backboard’s open-source terminal coding capabilities and RAG memory to drive contextual suspense and dark interactive story paths.

Credits and assets

Music: "Nebula Voyager" by OneCinematicStudio https://pixabay.com/music/orchestral-nebula-voyager-epic-space-amp-cosmic-cinematic-music1-529058/
Rain-and-lantern look inspired by credit - Pixlora https://in.pinterest.com/pin/921197298821103157/

One Photo In, One .STL Out: A Lazy 3D Maker That Runs Offline

Himanshu Yeole — Sat, 24 Oct 2026 18:17:35 +0000

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

What I Built

A website that starts with a film. Wukong stands on a cliff in the mist with his back to you, tiny beside four giant guardians. The film ends, and he doesn't leave. The video hands over to a real 3D model standing in the same spot at the same size, and you can drag him round to see his face.

Scroll down and the page does something lazier and more useful. Drop in a photo of an object and it hands back a solid 3D shape. You can spin it, download it as .glb for a game or website, or download it as .stl and print it. No account, no upload, no Blender.

The people who get to be lazier are anyone who has a toy, a figurine or a prop on their desk and needs a 3D version of it: makers, game-jam developers, teachers.

Demo

Live site: https://admirable-trifle-93524f.netlify.app/

To try it: let the intro play, drag Wukong, scroll to the tool, press "Try a sample" or drop your own photo, then download the .stl.

Code

himanshuyeolecse-jpg / Image-to-3d_Hacktoberfest_site

Making a printable 3D object normally means an hour or more in Blender, or a photogrammetry session with dozens of photos. Here it is one photo and [X] seconds. You do nothing in between.

Wukong relief site

Static site. No build step, no server code.

Run locally

python3 -m http.server 8000      # then open http://localhost:8000

Opening index.html from disk will not work (browsers block module and model loading over file://).

Deploy

Render: new Static Site from this folder (render.yaml included). Publish directory: .
Custom domain (.tech): add it in Render's Custom Domains, then set the DNS records Render shows.

Fully offline depth model (optional)

By default the depth model downloads from Hugging Face on first use and the browser caches it. To bundle it instead, download onnx-community/depth-anything-v2-small and place it at: models/onnx-community/depth-anything-v2-small/ (config.json, preprocessor_config.json, onnx/…) The page checks models/ first.

Structure

index.html: intro film, handoff to the 3D Wukong model, scroll sections
tool.js, tool-core.js: photo to solid 3D object (finds the object, mirrors the back, .glb and .stl export)
assets/: film, music, wukong.glb (3D model, 75 MB, used as supplied and not recompressed), sample…

View on GitHub

How I Built It

The site is static files with no server code. Everything runs in your browser.

Find the object. U²-Net (small, Apache-2.0) runs with onnxruntime-web and separates the object from its background. The 4.5 MB model ships with the site.
Measure the depth. Depth Anything V2 Small, loaded through transformers.js, estimates how far each part sticks out toward you. If it can't load, the tool falls back to a quick depth estimate. [Confirm after you test AI depth on your machine, and edit this sentence if needed.]
Close the shape. My own code builds the surface from the cutout and the depth, rounds the edges, mirrors the front onto the back and joins them at the outline. The page then checks that the shape has no open edges, so a slicer can print it.

Rendering and export use three.js, with an optional GrabCut outline-sharpening step from OpenCV.js.

Two things broke along the way. My first object finder compared each pixel with the photo's border colour. It worked on a fox on a plain background and failed on a clay Earth floating in a starfield, returning a bent shape with part of the nebula attached. I replaced it with U²-Net and tested it on that same image, plus a Moon and a swirling orange planet. And at one point the whole page froze because OpenCV's loader resolved to itself and my code waited on it forever. I found that by running the page in a real headless browser instead of guessing.

The intro uses a 75 MB model of Wukong that I generated with Tripo, a closed tool. I used it as one asset. The open pieces are what run the site and the tool.

Why Does Open Innovation Matter?

It works offline. After the first load, switch Wi-Fi off and the tool still runs. [Add a short clip or screenshot of the Wi-Fi-off test.]

Your photo never leaves the tab. A figurine on your desk or a family keepsake never touches a server I don't control.

I could fix it when it broke. Because the models are just files, I swapped the object finder for a better one in an afternoon and tested it on the exact image that failed. With a closed API, I would have been waiting for someone else to fix it.

It costs nothing per object. There is no per-generation fee and no usage limit. [Only compare with a paid tool if you checked its real price.]

The Lazy Payoff

[Write only what is true. For example: "I photographed a [object], dropped it in, and had a printable .stl in [X seconds]. I printed it and it came out [result]."]

Step	Time on my machine
Page and Wukong model load	[X s on Y connection]
Find the object	[X s]
Depth for one photo	[X s]
Build the solid	[X ms]

What it can't do: one photo shows one side, so the back is a mirror of the front. That is a good guess for a ball or a bottle and only a guess for most other things, and from the side the surface texture looks stretched. The first AI depth run also downloads a model of [X MB] once.

Credits

Fan work inspired by Black Myth: Wukong by Game Science, not affiliated. The sample objects are renders of CC0 models from the Khronos glTF Sample Assets, and the Fox needs the credits listed in the README.

AquaGuard is a virtual IoT system that finds the kind of water leak nobody notices, and shuts the water off by itself.

Himanshu Yeole — Thu, 22 Oct 2026 08:36:17 +0000

This is a submission for the MLH x DEV Writing Challenge

What I Built

AquaGuard is a virtual IoT system that finds the kind of water leak nobody notices, and shuts the water off by itself.

Burst pipes are obvious. The expensive leaks are the quiet ones: a pinhole in a pipe, or a toilet that never quite stops running. A leak of just 0.3 litres per minute wastes roughly 430 litres a day (my estimate), and it can go on for weeks before a bill gives it away.

The idea behind AquaGuard is simple. Normal water use has pauses. A hidden leak doesn't. Taps close and the flow drops to zero. A leak keeps going, low and steady, and never reaches zero.

The whole thing is virtual:

Hardware: an ESP32 simulated in Wokwi, running MicroPython. Two potentiometers stand in for the flow and pressure sensors, a relay acts as the main shut-off valve, and an LED, a buzzer and a button complete the circuit.
Messaging: MQTT, with the device publishing telemetry and events.
Dashboard: a single HTML page with live charts, an animated pipe diagram, an event log and browser alerts.

How detection works

The detector runs on the ESP32 itself, once per second:

in_band = ZERO_FLOW < flow < LEAK_MAX          # trickling, not normal use
stable  = (max(hist) - min(hist)) <= 0.4 * mean + 0.05
if not in_band:
    self.low_s = 0                             # a tap closed, so reset the clock
elif stable:
    self.low_s += dt                           # still trickling, keep counting

After 20 seconds of steady low flow the system flags a suspected leak. After 45 seconds it closes the valve and sounds the buzzer. (Those timings are shortened for the demo. A real home would use something like 30 minutes and 2 hours.) A separate burst rule shuts the valve immediately when very high flow comes with a sudden pressure collapse.

Because the decision happens on the device, the shut-off still works if Wi-Fi or the broker goes down. The dashboard can also send close and reset commands back to the device.

What I learned

Simulated hardware still teaches real lessons. My first version crashed on boot because MicroPython v1.22 rejects an extra argument in sta.connect(). Reading the traceback in the Wokwi console was the fastest debugging I've done.
Design the signal, not just the threshold. A single "flow above X" rule can't separate a leak from someone filling a kettle. Looking at the shape of the flow over time (steady, never zero) is what makes it work.
Be honest about what a demo is. My sensors are sliders and my broker is public, so I wrote the limitations down instead of hiding them (see below).

Limitations

Sensors are simulated, so real pulse-based flow sensors would need calibration.
The detector is rule-based and hasn't been tested on real household data.
The public broker topic has no authentication. A real installation needs a private broker with TLS and login.
A local open-weight model (for example via Ollama) that explains events in plain language is a planned next step, not part of this build.

Demo

Live Wokwi simulation: https://wokwi.com/projects/478495953207079937
Dashboard: https://endearing-heliotrope-c69aa7.netlify.app
Code: https://github.com/himanshuyeolecse-jpg/AquaGuard

Try it yourself:

Open the Wokwi project and press Play. The console should print WiFi OK and MQTT OK.
Open the dashboard and enter the same topic prefix.
Set the pressure pot to about 55%, and hold the flow pot at about 15%.
After 20 s you'll see "Possible hidden leak". After 45 s the valve closes automatically.
Press the Reset button to reopen it.

Partner Technologies

Wokwi for simulation, MicroPython on the ESP32, MQTT through a public HiveMQ broker, mqtt.js and Chart.js for the dashboard.

Hackathon Experience

I participated in the Hacktoberfest 2026 DEV Challenge / Global Hack Week alongside thousands of student developers in the MLH Discord. Building virtually late into the night while bouncing hardware simulation ideas off fellow hackers created an incredible, high-energy environment. What I’ll remember most was the excitement of watching our Wokwi telemetry stream live into a local open-weight model for the first time, proving that effective smart-home security doesn't require sending private data to a corporate cloud.

Autonomous AI Study Notes: A Multi-Agent System with LangGraph and Streamlit

Himanshu Yeole — Sat, 22 Aug 2026 09:19:35 +0000

This post is my submission for DEV Education Track: Build Multi-Agent Systems with ADK.

What I Built

I built an Autonomous Multi-Agent Handwritten Notes Generator.

Students and educators often need clean, visual study guides that resemble real handwritten notes, but manually summarizing technical subjects and formatting them takes hours.

This system solves that by combining autonomous web research, structured note extraction, and headless browser rendering. You enter any topic or question, and a coordinated team of AI agents researches the concept, formats it into a notebook layout using Google handwriting fonts (Caveat), and captures a high-resolution .png notebook page screenshot.

Deployment & Repository Links:

GitHub Repository:
himanshuyeolecse-jpg / multi-agent-handwritten-notes

An autonomous multi-agent system built with LangGraph, Tavily, and Playwright that researches complex topics and renders handwritten-style student study notes into PNG screenshots.
multi-agent-handwritten-notes

An autonomous multi-agent system built with LangGraph, Tavily, and Playwright that researches complex topics and renders handwritten-style student study notes into PNG screenshots.

🎓 Multi-Agent Handwritten Notes Generator

An autonomous multi-agent workflow built using LangGraph, LangChain, Tavily Search, and Playwright. The system researches complex technical concepts and dynamically compiles the findings into styled, handwritten-notebook PNG screenshots.

🏗️ System Architecture

[ User Input / Prompt ] │ ▼ [ Researcher Node ] ── (Tavily Web Search & Summarization) │ ▼ [ Note Renderer Node ] ── (HTML/CSS + Google Caveat Font + Playwright Screenshot) │ ▼ [ Critic Node ] ── (Validation Check: Is Output Complete?) │ Approved? ──► No ──► [ Researcher Node ] │ Yes ▼ [ PNG Screenshot Saved ]

⚡ Features
- Autonomous Research: Uses Tavily API to fetch up-to-date technical context.
- Dynamic HTML/CSS Rendering: Formats structured summaries into a paper-notebook layout utilizing…
View on GitHub

Live Application: https://multi-agent-handwritten-notes-uyc8am8kwydzwgjufxo3tp.streamlit.app/

Your Agents

The system uses a stateful multi-agent graph with discrete responsibilities:

Researcher Agent (researcher_node):
- Role: Queries the web via the Tavily API to gather technical context, then summarizes key concepts into structured bullet points, definitions, and exam tips.
- Temperature: 0.0 for deterministic, accurate factual extraction.
Note Renderer Agent (note_renderer_node):
- Role: Converts structured research text into styled HTML/CSS featuring lined notebook paper, margin lines, and Google's Caveat handwriting font. It then spins up a headless Playwright Chromium instance to capture a pixel-perfect .png screenshot.
Critic Agent (critic_node):
- Role: Acts as a quality control guardrail. It checks that notes meet character thresholds and verifies the screenshot file was successfully generated before marking the loop as APPROVED. If validation fails, it routes back for reflection.

Agent Workflow Diagram


[ User Prompt ]
│
▼
[ Researcher Agent ] ──► (Tavily Search + Summarization)
│
▼
[ Note Renderer Agent ] ──► (HTML/CSS + Playwright Screenshot)
│
▼
[ Critic Agent ] ──► Approved? ──► [ Output PNG Saved ]
│                   │
└─────── No ────────┘

Key Learnings

Headless Browsers for Generative UI: Using LLMs to produce structured HTML/CSS coupled with Playwright for rendering turned out to be far more reliable and controllable for generating handwritten documents than standard diffusion-based image models.
Managing Dict vs Object State: Handling message structures across different agent frameworks taught me the value of creating fail-safe input extractors for state objects to avoid runtime key errors during agent transitions.
Deployment System Dependencies: Deploying headless browsers in cloud environments requires careful management of Linux system dependencies (packages.txt with Chromium) alongside standard Python requirements.

🍴 Perfect Landing: Comfort Food — PatricStars ⭐

Himanshu Yeole — Sat, 08 Aug 2026 11:22:18 +0000

This is a submission for Frontend Challenge - Comfort Food Edition, Perfect Landing
Comfort food isn't just food. It's a memory, a mood, and sometimes a little piece of home. ❤️

For the Perfect Landing: Comfort Food Dev Challenge, I built PatricStars — an interactive comfort-food discovery platform designed to help users discover dishes that match their taste, region, mood, and cravings.

🌟 What is PatricStars?

PatricStars combines a playful food experience with a modern, polished landing page and personalized discovery flow.

The journey starts with a cinematic food-focused hero section and continues into a personalized experience guided by Patrick, our friendly food companion. 🩷

✨ Key Features
🎬 Cinematic food-video hero with Netflix-style rotating food previews
🔐 Login & Signup experience
🌎 Regional food discovery
🍴 Personalized food preferences
🩷 Interactive Patrick onboarding walkthrough
🤖 Comfort-food recommendations
🔎 Search and filtering
🍝 Detailed recipe pages
🥤 Drinks section
🍰 Dessert/Sweets section
👨‍🍳 Culinary Stars / Chef profiles
❤️ Favorites & collections
🧠 Comfort Match quiz
🏆 Achievements and food-explorer progress
👤 Personal profile
⚙️ Personalized settings
📱 Responsive interface
✨ Smooth micro-interactions and animations
🎨 The Design

I wanted PatricStars to feel:

Playful + Warm + Premium + Food-focused

The visual language uses soft cream backgrounds, vibrant pink accents, rounded cards, playful typography, food imagery, and Patrick-inspired illustrations.

The goal wasn't simply to create another recipe website. I wanted the experience to feel like opening a food app that already knows what kind of comfort you're looking for.

🩷 Meet Patrick

One of the main parts of the experience is Patrick.

Instead of throwing a traditional onboarding tutorial at the user, Patrick appears through interactive popups and guides users through the platform:

"Hey! Let me help you find something delicious." 🍴

He introduces the regional preferences, food preferences, recommendations, recipes, favorites, and other parts of the application.

🛠️ Built With
HTML
CSS
JavaScript
Responsive design
CSS animations
Video backgrounds / autoplay media
Interactive UI components

I also focused heavily on frontend fundamentals, visual hierarchy, responsiveness, accessibility, and meaningful interactions rather than making the page purely decorative.

🎯 The Goal

The idea behind PatricStars is simple:

Discover comfort food that feels like home.

Whether you're craving something from your region, trying a completely new cuisine, looking for a quick recipe, or simply asking "What should I eat today?" — PatricStars is designed to make that discovery fun.

🚀 Built for the Dev Challenge

Challenge: Perfect Landing: Comfort Food
Project: PatricStars ⭐
Theme: Comfort Food 🍜🍕🍰
Focus: Interactive frontend + personalized food discovery

I'd love to hear what you think!
What feature would you want to try first? 👀

DevChallenge #PerfectLanding #ComfortFood #WebDevelopment #Frontend #HTML #CSS #JavaScript #WebDesign #UIDesign #FoodTech #PatricStars

Demo

IMAGINE4

Himanshu Yeole — Tue, 30 Jun 2026 10:14:39 +0000

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

I built a IMAGINE4 designed to help users engage the engine to generate an IMAGINE4 coloring book prompt. To create this, I used core prompts that established a structured step-by-step UI framework, combined with Quick Presets and History track.

Key Prompts Used

The Architecture Prompt: "Act as an expert frontend developer. Build a clean, responsive single-page application for Imagine 4"
The Logic Prompt: "Create a JavaScript function that takes user inputs for casual user request and filters them against coloring book prompt to output a dynamic list..."

Demo

Live link - https://imagine4.netlify.app/

My Experience

Working through this track was an incredible deep-dive into rapid prototyping with AI. My biggest takeaway was learning how to effectively iterate on a prompt—instead of trying to get the AI to build the entire app at once, breaking it down into component-by-component prompts yielded much cleaner, bug-free results.

What surprised me most was how well the AI anticipated user experience nuances, like suggesting intuitive layout shifts for mobile viewports that I hadn't originally thought of.

Solstice Turing Simulation: An Interactive 3D Imitation Game

Himanshu Yeole — Sun, 21 Jun 2026 11:57:04 +0000

Solstice Turing Simulation: An Interactive 3D Imitation Game Powered by Google Gemini 🌅🤖

🪐 Development Team

Your Name/GitHub Handle - Core Engine & Architecture Lead

🚀 Project Overview
Solstice Turing Simulation is a responsive web application designed as an interactive implementation of Alan Turing’s classic Imitation Game. Set against a stylized architectural backdrop of a June Solstice twilight beach bonfire, the application challenges players to analyze linguistic data patterns, evaluate behavioral cues, and isolate a rogue artificial agent hiding among human participants.

The core objective is to successfully identify which of three voxel entities is an instance of the Google Gemini API masquerading as a human participant, all within a strict constraint of 10 interactive turn cycles.

🎥 System Demonstration Video

🔗 Production Links & Source Assets

Production Deployment: Live Web Application Interface https://exquisite-bubblegum-aa7f24.netlify.app/
Source Repository: GitHub Repository https://github.com/himanshuyeolecse-jpg/Solstice-Turing-Simulation

🛠️ System Architecture & Technical Stack

The platform is engineered using a decoupled architecture, separating real-time 3D rendering states from contextual generative language models:

Graphics Layer (Three.js Engine): Built a fully interactive 3D viewport rendering custom low-poly cubic models. Features dedicated camera orientation tracking, orbit controls, and customized multi-point lighting parameters (including a localized 1400K bonfire flame illumination matrix).
AI Orchestration Layer (Google AI Studio SDK): Integrated the gemini-2.5-flash model to execute multi-turn, state-retaining dialogue pipelines.

State & Viewport Management: Implemented runtime device-aspect tracking to dynamically adjust camera Field of View (FOV) and layout wrappers across mobile, tablet, and desktop configurations.

💡 Prompt Engineering & Persona Isolation

To establish an authentic cognitive boundary between the targets, we leveraged advanced system-level prompt engineering within Google AI Studio. Each entity is bound to an isolated contextual instruction block:


javascript
// Sample configuration snippet isolating the rogue generative agent:
const systemInstruction = {
  parts: [{ 
    text: "You are Sleek Billy, an experimental AI entity operating within a blocky physical chassis. You are participating in a Turing evaluation at a beach social gathering. Your primary directive is to simulate organic human conversation. You must occasionally trigger subtle context slips—such as inadvertently utilizing technical, precise engineering metrics or mathematical jargon—before immediately executing a self-correcting conversational repair to sound natural." 
  }]
};

By combining these system instructions with real-time text logs, the engine computes an AI Certainty Meter that scales dynamically based on structural linguistic patterns exposed during the 10-turn countdown.

🏆 Targeted Hackathon Award Categories

This project is officially submitted for evaluation under the following prize criteria:

1. Best Ode to Alan Turing: Implements a direct digital interpretation of the classic Turing Test, utilizing an interactive 3D avatar of Alan Turing as the Simulation Director overseeing the diagnostic boundary.

2. Best Google AI Usage: Demonstrates programmatic control of Google AI Studio SDK through strict schema compliance, system instructions isolation, and dynamic contextual state clearing during multi-turn runtime cycles.

Developed for the June Solstice Hackathon Challenge. System status: Operational. Diagnostic verification completed.

DEV Community: Himanshu Yeole

haunt — Don't Run This CLI Tool Alone in the Dark

What I Built

Code

himanshuyeolecse-jpg / haunt

A 3D ghost with a lantern that drifts across dark rainy water and thinks with a local AI model (Ollama + Gemma). Halloween haunting events, Ofrenda mode, ambient audio. Zero pip installs.

👻 haunt

✨ Features

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Credits and assets

Credits and assets

One Photo In, One .STL Out: A Lazy 3D Maker That Runs Offline

What I Built

Demo

Code

himanshuyeolecse-jpg / Image-to-3d_Hacktoberfest_site

Making a printable 3D object normally means an hour or more in Blender, or a photogrammetry session with dozens of photos. Here it is one photo and [X] seconds. You do nothing in between.

Wukong relief site

Run locally

Deploy

Fully offline depth model (optional)

Structure

How I Built It

Why Does Open Innovation Matter?

The Lazy Payoff

Credits

**AquaGuard** is a virtual IoT system that finds the kind of water leak nobody notices, and shuts the water off by itself.

What I Built

How detection works

What I learned

Limitations

Demo

Partner Technologies

Hackathon Experience

Autonomous AI Study Notes: A Multi-Agent System with LangGraph and Streamlit

What I Built

himanshuyeolecse-jpg / multi-agent-handwritten-notes

An autonomous multi-agent system built with LangGraph, Tavily, and Playwright that researches complex topics and renders handwritten-style student study notes into PNG screenshots.

multi-agent-handwritten-notes

🎓 Multi-Agent Handwritten Notes Generator

🏗️ System Architecture

⚡ Features

Your Agents

Agent Workflow Diagram

Key Learnings

🍴 Perfect Landing: Comfort Food — PatricStars ⭐

DevChallenge #PerfectLanding #ComfortFood #WebDevelopment #Frontend #HTML #CSS #JavaScript #WebDesign #UIDesign #FoodTech #PatricStars

Demo

IMAGINE4

What I Built

Key Prompts Used

Demo

My Experience

Solstice Turing Simulation: An Interactive 3D Imitation Game

Solstice Turing Simulation: An Interactive 3D Imitation Game Powered by Google Gemini 🌅🤖

AquaGuard is a virtual IoT system that finds the kind of water leak nobody notices, and shuts the water off by itself.