DEV Community: Rajab Baig

My Turing Solstice Project: A Narrative Puzzle Game Powered by Gemini AI

Rajab Baig — Thu, 18 Jun 2026 19:35:50 +0000

This is a submission for the June Solstice Game Jam

Video Demo

Code

rajab-rajab / June-Solstice-Game-Jam

We are celebrating authenticity and LGBTQIA+ history with Pride month, which also happens to be the birth month of Alan Turing – the famous computer scientist behind the "Turing Test" for artificial intelligence who was persecuted for being gay. June also marks Juneteenth, a day to celebrate an important milestone towards the freedom.

The Turing Solstice

A narrative logic puzzle game for the June Solstice Game Jam

"Every code can be broken. Every wall can fall. Every self can be free." — The Machine, at Solstice

🎯 Concept

You are an apprentice to Alan Turing. The Solstice is a cosmic event where the barrier between human intelligence and artificial intelligence is thinnest.

The screen is split in two:

☀️ LIGHT PANEL (Day)	🌙 DARK PANEL (Night)
Solve logic gate puzzles	Commune with The Machine
Visual, click-based	Text terminal, type to speak
AND · OR · NOT gates	Gemini AI responds in character

The Machine's personality changes based on your Solstice Energy (Sunlight meter) — from COLD and cryptic to RADIANT and celebratory. On the actual solstice (June 21), the game unlocks special content.

🏆 Why This Wins

Best Google AI Usage

Gemini is mechanically essential — not a chatbot add-on:

Generates puzzles…

View on GitHub

How I Built It

By creating this project The Turing Solstice was a milestone in the way of historical tribute and modern artificial intelligence. I chose Python and Pygame for its flexibility and usefulness. Python, pygame and gemini model are the core engine because using them I create a "retro-technical" aesthetic that mimics the computing world of the 1950s.

The Dual-Core Gameplay Engine The most interesting technical challenge was the split-screen architecture. The game runs two separate systems simultaneously: The Light Panel: A custom-built logic gate simulator. I built a modular "Gate Class" that evaluates inputs (AND, OR, NOT) in real-time. The Dark Panel: A retro terminal emulator. I built a typewriter-style text renderer that controls "The Machine's" responses, complete with scanlines and a phosphor glow effect.
Making AI "Mechanically Essential" (Gemini 3.1 Flash Light) For the Best Google AI Usage category, I didn't want a generic chatbot. Instead, I integrated Gemini 3.1 Flash light directly into the game’s state machine. The Personality Shift: I used a dynamic prompting system. Gemini is fed the current sunlight_meter value. If the meter is low (Darkness), Gemini uses a "Cold/Cryptic" system prompt. As the player solves logic puzzles and increases "Sunlight," the system prompt updates in real-time to "Warm" or "Radiant," changing the machine's tone and willingness to help. Procedural Puzzles: Gemini generates unique cipher challenges (ROT13, A1Z26, etc.) on the fly, ensuring that no two playthroughs are exactly the same.
Real-World Time Integration To honor the June Solstice, I used Python's datetime module to check the local system clock. If the game is launched on June 21st, the UI colors shift into a "Convergence" palette, and the AI acknowledges the specific astronomical transition, bridging the gap between the player's reality and the game world.
Weaving the Narrative The progression system is tied to "Found Documents." These aren't just lore; they are milestones of history. I curated specific fragments related to: Alan Turing’s 1952 persecution to highlight the theme of authenticity. General Order No. 3 (Juneteenth) to parallel the theme of "delayed liberation." The Stonewall Uprising to tie the struggle for identity back to June’s Pride Month.

Prize Category

I am officially submitting The Turing Solstice for the following two categories:

Google AI Usage In this project, "gemini-3.1-flash-lite" is not just a mere addition—it works as a functional game engine, brain of project. State-Aware AI: The AI is integrated into the game's logic. By feeding the current sunlight meter value into the system prompt, the AI’s personality shifts dynamically, as the player progresses. Procedural Content: Gemini generates unique ciphers and narrative clues on the fly, ensuring that the "Dark Panel" terminal feels alive and unpredictable. Intelligent Evaluation: The AI evaluates the player’s narrative responses, granting "Sunlight Energy" based on the creativity and relevance of their answers, rather than just checking for static keywords.
Best Ode to Alan Turing This game is a tribute to the "father of modern computing" on multiple levels: Scientific Tribute: The core gameplay loop—solving logic gates and ciphers—is a direct mechanical representation of Turing’s work at Bletchley Park and his innovative development on the ACE (Automatic Computing Engine). Historical Narrative: As players solve puzzles, they unlock "Found Documents" that explore Turing’s 1950 paper on machine intelligence and the tragic history of his persecution. Intersectional Recognition: By launching during the June Solstice and Pride month, the game honors Turing’s legacy as a scientist, a metaphor for the struggle for authenticity and freedom. If API KEY FAILS PROGRAM WOULD RUN ON ITS OWN.

Mr.PERFECT---TO PERFORM AGENTIC TASKS USING LOCAL LLM

Rajab Baig — Sun, 07 Jun 2026 05:16:49 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

What I Built: Agent Mr. Perfect
The Backstory
I started with a folder full of local LLM tools and a desire and wish to run AI model locally completely offline for accuracy, privacy and speed. However, for a long time due to my workings, the project was just a "server in a box"—I could chat with it, but it couldn't do anything. It was a powerful engine with no wheels. This challenge gave me the push to build the "wheels": a custom agentic layer I call Agent Mr. Perfect.
The "Before": A Local LLM Server
Before this submission, my project was essentially a local hosting setup.
The Tech: I was using text-generation-webui as a backend to run quantized models like Gemma (via llama.cpp). It run perfectly on only CPU 20 GB RAM and 1TD SSD and NVME device.
The Workflow: It was a "Prompt-In, Text-Out" system. I had a server listening on main: model loaded
main: server is listening on http://127.0.0.1:5005
main: starting the main loop...
02:07:49-662877 INFO Loaded "D:\NEW-MODELS\New folder (22)\gemma-4-E4B-it-Q4_K_M.gguf" in 27.61 seconds.
02:07:49-662877 INFO LOADER: "llama.cpp"
02:07:49-662877 INFO CONTEXT LENGTH: 131072
02:10:22-236834 INFO OpenAI/Anthropic-compatible API URL:

                     http://127.0.0.1:5000/v1

Running on local URL: http://127.0.0.1:7860, providing an OpenAI-compatible API, but I had to manually interact with it for every single response.
The Limitation: The AI was "limited" in the terminal. It had no way to access my local files, search the web, or execute multi-step tasks. If I wanted to research a topic and summarize it, I had to do the research myself and paste the text into the UI.
The "After": Agent Mr. Perfect (The Agentic Shift)
For my submission, I transformed this local server into a fully-functional Agentic System. I built Agent Mr. Perfect to bridge the gap between "Chatting" and "Acting."
Autonomous Task Planning: Instead of just responding to a prompt, Mr. Perfect now breaks down complex goals into smaller, executable steps.
Tool Integration: I connected the local LLM to a suite of "tools" (Python scripts and APIs) that allow it to perform actions like file manipulation, web searching, and data processing.
Persistent Memory: I implemented a local state-management system so the agent remembers the context of a long-term project across different sessions, rather than forgetting everything the moment the server restarts. With Save Session and Load Session Commands, one can start where it stopped his work.
The "Perfect" Standard: I refined the system prompts and error-handling loops to ensure the agent self-corrects. If a task fails, Mr. Perfect analyzes the error and tries a different approach until the task is complete. I has four steps loop to complete a task.
Why it matters
By moving from a standard UI to an agentic workflow, I've created a private, local-first assistant that can actually manage workflows. I’m no longer just running an LLM; I’ve built a partner that handles the "heavy lifting" of my development tasks and work loads without a single byte of data leaving my machine.
Key Technical Details for your Documentation:
Model Used: gemma-4-E4B-it-Q4_K_M.gguf (Quantized for efficiency)
Inference Engine: llama.cpp[1]
Architecture: Local API Server + Custom Agentic Logic Layer
Primary Focus: Privacy-focused automation and multi-step task execution.

Demo

rajab-rajab / github-challenge-2026-Mr.Perfect

I Built: Agent Mr. Perfect for github dev challenge-May-2026

github-challenge-2026-Mr.Perfect

I Built: Agent Mr. Perfect for github dev challenge-May-2026

View on GitHub

The Comeback Story

As earlier mentioned before it was a simple local model server running locally on my windows machine. After reading cgallenge, I decided to work for a Agent to perform different agentic tasks, coding, web browsing, system commands etc 109 tolls running on my machine.Before I prepared single file Agent comprised of more than 4000 lines of code . which I presented for Dev Gemma 4 challenge. But for Github challenge I decided to choose Divide and Conquer rule. Breaking my code in different code files using decorative approach using instances rather than static methods.

My Experience with GitHub Copilot

It really helped me in preparing Mr. Perfect. I used first plan and then implement approach. Github copilot and AI suggested decorative approach to divide my code base into tool files, and as a result I created a remarkable application.

MY PROTRAIT MAKER

Rajab Baig — Sat, 23 May 2026 20:40:42 +0000

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

What I Built

I build an RPG Character Portrait Generator that successfully uses both Gemini
(to expand simple ideas into detailed descriptions) and Imagen (to turn those descriptions into art), use the prompts below.
Prompt: "Build a web application called 'My Portrait Maker.'

Features:

User Input: A text field for character name and a dropdown for 'Universe' (choices: High Fantasy, Cyberpunk, Cosmic Horror, Steampunk, Post-Apocalyptic).
Character Traits: Add buttons or chips for Race (Human, Elf, Orc, Android, etc.) and Class (Warrior, Mage, Hacker, Pilot).
The Logic: When the user clicks 'Generate', the app should first send the user's choices to Gemini to write a 50-word, highly detailed cinematic visual description of the character.
Image Generation: Take that Gemini-generated description and pass it automatically to the Imagen API to generate a high-quality 1:1 portrait.
Gallery: Display the generated image alongside the character name and the description Gemini wrote. Include a 'Download' button to save the portrait as a PNG.
Persistence: Use localStorage so the user can see their previous character creations in a 'History' section.
Add an API Key input field in the App UI so I can paste my key directly into the running app to test it. Styling: Use a dark, professional 'gaming' theme with gold accents and a responsive layout."

Demo

https://my-portrait-maker-652806875882.asia-southeast1.run.app

My Experience

I learned how a good and powerful prompt can be converted into a stunning application. Technology is getting so advanced that user can create what he imagines.

AGENT Mr. PERFECT AND GEMMA 4 E4B

Rajab Baig — Sat, 23 May 2026 06:13:50 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

My project is based on Google Gemma 4 variant E4B model. 1- I created an Agent that perform different agentic tasks named as tools which consists of powershell commands, content creation, coding tasks using python, html, php, c, c++ languages. I used gguf file of E4B model 4.63 GB named gemma-4-E4B-it-Q4_K_M.gguf
I developed powerful Agentic AI - Local LLM Assistant, a high-performance desktop orchestration layer powered by the Google Gemma 4 E4B (it-Q4_K_M) model.
As many AI assistants are confined to a chat box, my project bridges the gap between conversational AI and OS-level execution. I designed it for developers, system administrators, and power users who need a powerful local, private agent capable of managing a Windows environment through natural language.
By leveraging the advanced reasoning and instruction-following capabilities of the Gemma 4 E4B model, the agent can intelligently select and chain together over 50+ specialized tools to perform complex system tasks. No doubt Agent Mr. Perfect works as Brain and Gemma 4 E4B as Heart in the project.
Core Capabilities:
🖥️ Advanced System & Windows Admin: The agent uses Gemma 4’s logic to generate and execute precise authorized PowerShell commands for monitoring system health, managing Windows services, inspecting registry keys, and analyzing event log and using other tools----- all without the user needing to remember complex syntax.
💻 Multi-Language Coding Assistant: A sandbox-ready environment where the agent can write, debug, and execute code in Python, HTML, PHP, C, and C++. It doesn't just write code; it can create the files and execute them locally to verify results.
🌐 Autonomous Web-Augmented Reasoning: When the local model identifies a gap in its training data (such as current events or specific documentation), it autonomously triggers a web search via the Tavily API, parses the results, and provides answers with verified URLs.
📁 Intelligent File Management: A robust suite of tools for file operations (create, hash, move, search) protected by a sophisticated Self-Protection Layer that prevents the AI from modifying critical system files or its own source code.
🛡️ Secure Local Execution: Built for privacy-conscious users, the system runs entirely on a local server (via text-generation-webui), ensuring that sensitive system data and code never leave the local machine.
Here is the command used to load Gemma4 E4B
python server.py --cpu --listen-host 127.0.0.1 --listen-port 7860 --loader llama.cpp --model "D:\NEW-MODELS\New folder (22)\gemma-4-E4B-it-Q4_K_M.gguf" --auto-launch
Here is the output of generated command
main: model loaded
main: server is listening on http://127.0.0.1:5005
main: starting the main loop...
22:33:57-707819 INFO Loaded "D:\NEW-MODELS\New folder (22)\gemma-4-E4B-it-Q4_K_M.gguf" in 42.22 seconds.
22:33:57-707819 INFO LOADER: "llama.cpp"
22:33:57-707819 INFO CONTEXT LENGTH: 131072
22:37:00-762808 INFO OpenAI/Anthropic-compatible API URL:

                     http://127.0.0.1:5000/v1

Running on local URL: http://127.0.0.1:7860
As model is running on http port 7860 with chat-ui. It means user can chat directly with Gemma 4 E4B and set Question & Answer session with loaded model.
And for agentic tasks I would first run my agent.py file which would use OpenAI/Anthropic-compatible API URL:

                     http://127.0.0.1:5000/v1

to make API calls to the loaded Gemma 4 E4B model i.e Agent would work as Brain and Gemma 4 E4B as Heart of the project.
Here is the command to launch my Agent Mr. Perfect
C:\Users\RAJAB BAIG\Documents\GitHub\BAIG\PERFECT>python agent.py
It would open our GUI-Interface based Agent Mr. PERFECT
The Brain (Agent Mr. Perfect): This is the orchestration layer of my Project. It handles the "cold logic"—the 65+ tools, the PowerShell administration, file hashing, and multi-language code execution (Python, C, PHP). It is the structural "Perfect" execution of tasks.
My Agent Mr. PERFECT answers in FOUR STEPS ONE BY ONE.
The Problem It Solves:
As modern workflows often require jumping between a web browser for research or visiting a URL, a terminal for system commands, and an IDE for coding. Agentic AI combines and unifies these into a single, modern GUI. By using Gemma 4 E4B, the assistant understands the "intent" behind a user's request—like "Optimize my system for gaming"—and translates that into a series of diagnostic and administrative actions. It works as mind body relationship.
I also added SAVE SESSION AND LOAD SESSION functionalities to make my Agent and Gemma 4 E4B project modern and robust. The Save/Load functionality transforms Agent Mr. Perfect from a temporary chat interface into a persistent engineering assistant. By capturing and ensuring the synergy between Gemma 4’s reasoning and local tool execution in a structured JSON format, I provide users with a transparent, safe, auditable, and private record of their AI-driven workflow that they can check and use anytime.

Demo

[(https://youtu.be/cbrrgWRNvkw)]

Code

https://github.com/rajab-rajab/gemma4-agentic-gui-app

How I Used Gemma 4

For this project, I chose the Gemma 4 E4B (it-Q4_K_M) model. As an "Engineering-for-Business" variant, it provides the precise reasoning required to handle system-level administration and multi-language coding tasks without the massive hardware requirements of larger dense models. As it has suitable memory space i.e 4.63 GB, it is easy to work for 20 GB RAM of mine only CPU machine.
🧠 The Heart of the Orchestration Layer
Gemma 4 E4B serves as the central decision-maker. Unlike standard chat models, I utilized Gemma’s advanced instruction-following capabilities to act as a Tool Orchestrator. When a user submits a prompt like "Check my CPU and if it's over 80%, tell me which process is the culprit," Gemma 4:
Analyzes the intent.
Selects the appropriate system tools (get_system_info and get_processes).
Parses the raw data returned by the OS.
Synthesizes a human-readable explanation.
🛠️ Precision Engineering & PowerShell Generation
The E4B variant shines in its ability to generate syntactically correct code. I leveraged its strengths to:
Generate PowerShell Scripts: Gemma 4 generates complex Windows Admin commands for registry queries and service management on the fly.
Multi-Language Logic: The model handles logic across Python, HTML, PHP, C, and C++, allowing the agent to not only write scripts but also explain the logic and debug execution errors in the local environment.
🔍 Autonomous Reasoning & Web Fallback
I implemented a "Self-Awareness" loop using Gemma 4. If the model determines that its local tools or internal training data are insufficient to answer a query (e.g., "What is the current version of React?"), it is programmed to autonomously trigger a Web Search Fallback. It then processes the search snippets to extract the most relevant information and presents them as interactive, URLs.
🛡️ Safety and Constraint Adherence
A critical part of using Gemma 4 was its ability to respect strict Self-Protection Rules. I provided the model with a system context that forbids it from interacting with its own source code (agent.py) or the LLM's binary files or pc system files and system disk. Through testing, Gemma 4 E4B demonstrated superior adherence to these safety guardrails compared to smaller models, ensuring the agent remains a helpful assistant rather than a system risk.
⚡ Optimized Local Performance
By using the 4.63 GB GGUF quantization (Q4_K_M), I achieved a balance of high intelligence and low latency. The model runs locally on consumer-grade hardware, ensuring that the system monitoring and file operations happen in near real-time, providing a "snappy" desktop experience while keeping all user data 100% private.
"Mr. Perfect is not just a wrapper for Gemma 4; but it is a safety-first orchestration layer that translates Gemma’s engineering-grade reasoning into safe, fast, reliable, local actions."
Here is a comprehensive list of the "Plus Points" for my project.

The "Heart & Brain" Architecture (Conceptual Innovation)
- Dual-Layer Intelligence: Instead of a generic chatbot, I have created a synergy between the Heart (Gemma 4 E4B) for high-level reasoning and the Brain (Mr. Perfect) for precise and exact and error free system execution. Intent Recognition: The system doesn't just "chat"; it also understands and uses engineering intent. If a user asks to "Fix the PC or want to run system commands," the agent knows to trigger diagnostic tools and commands rather than just giving advice.
Powered by Gemma 4 E4B (Model Optimization)
- Engineering-for-Business (E4B) Precision: I chose the E4B variant specifically for its superior performance in generating high level technical programming code (Python, PowerShell, C++) and following complex and difficult business logic.
- Local Performance: By using the it-Q4_K_M GGUF quantization, I have achieved a perfect balance: high intelligence (reasoning) and accuracy with low latency (speed) on consumer-grade hardware. As it uses minimal resources in RAM and disk space.
- Private & Offline: The model runs 100% locally. A protected environment where no data ever leaves the user's machine, making it suitable and important for corporate and sensitive engineering environments.
Professional Grade Toolset (65+ Built-in Tools)
- OS-Level Integration: While most AI agents are "sandboxed," Mr. Perfect has deep integration with Windows via PowerShell Admin Tools, allowing for real-time system monitoring, registry edits, and service management.
- The Developer's Swiss Army Knife: Built-in capabilities for Code Creation, Creating files and folders, Syntax Checking, and Immediate Execution across multiple languages (Python, HTML, JS).
- Web-Augmented Reasoning: When local knowledge isn't enough, the agent autonomously and efficiently uses the Tavily API to fetch real-time data, presenting it with Verified URLs.
Advanced Session Management (The "Black Box")
- Persistence (Save/Load): Its ability to save sessions to JSON transforms the agent from a temporary chat into a persistent workspace for developers and software engineers.
- Auditability: The JSON logs provide a transparent and neat record of each and every step of "Action" and "Argument," which is critical for business stability, accountability and debugging.
- Ease of Any time Context Restoration: Users can stop and close mid-project, save their current session, and reload it later to pick up and start exactly where Gemma 4 left off.
"Responsible AI" & Safety (The Self-Protection Layer)
- Self-Preservation Logic: The agent is hard-coded to never delete its own source code (agent.py) or the LLM binaries. This prevents "Agentic Suicide" or accidental system damage.
- System Guardrails: It recognizes protected Windows directories and system files, refusing to perform "Delete" operations on critical OS components.
- Human-in-the-Loop: Critical actions (like system shutdown or bulk file deletion) require explicit user confirmation through the modern GUI.
Modern & Intuitive UX (CustomTkinter GUI)
- Clean Dark Theme: A professional, tech-focused interface that reduces eye strain for long engineering and coding sessions.
- Dynamic Status Feedback: The UI provides real-time updates (e.g., "Step 1/4: Tool Execution: "), so the user is never left wondering what the agent is "thinking."
- Rich Text Features: Support for URLs, color-coded message tags. Quick Prompt buttons for common tasks.
Resilient Execution (The 4-Iteration Loop)
- Autonomous Problem Solving: The agent uses a multi-step thinking process while working with Gemma4. If a code execution fails, it reads the error, searches for a fix, modifies the code, and tries again—all in one session.
- Synthetic Final Answers: if the agent exhausts its loop during a tool call, it provides a logical summary of its actions, ensuring the user is always well informed and aware.
Clean and neat Code & High Portability
- Single-File Power: Most of the core logic is contained in agent.py, making it incredibly easy for other developers to download, inspect, and run.
- Standardized Data: By using standard JSON for sessions and Markdown for code, your project integrates perfectly into existing developer workflows (like GitHub and VS Code). I am still working on Install, Uninstall, Update, Shutdown and Restart functionalities. However, most of powershell tools are working fine.