DEV Community: Muhammad Asad Riaz

QuestLearn: Shadows of the Machine — A Retro Socratic Coding RPG Powered by Open-Weight Gemma

Muhammad Asad Riaz — Sat, 31 Oct 2026 02:17:45 +0000

QuestLearn: Shadows of the Machine — A Retro Socratic Coding RPG Powered by Open-Weight Gemma

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

1. What I Built 🖥️👻

QuestLearn: Shadows of the Machine is an interactive, browser-based retro terminal role-playing game (RPG) designed to teach core computer science principles through narrative debugging and Socratic dialogue.

The game simulates AetherOS, an abandoned 1980s mainframe system infected by an autonomous execution daemon. To restore the operating system, learners must identify and repair broken Python algorithms across corrupted memory sectors. Along the way, the player communes with the digitized spirits of computer science pioneers (Alan Turing, Grace Hopper, and Ada Lovelace) who guide the learner with inquiry-based Socratic reasoning.

Powered by open-weight Google Gemma models, the AI core dynamically evaluates runtime errors and adapts puzzle difficulty in real time without ever providing verbatim code solutions.

2. Live Demo & Source Code 🔗

Live Interactive Terminal: https://questlearn-jy52.onrender.com/
GitHub Repository: https://github.com/mrerror313coder/QuestLearn
License: Apache 2.0 (Open Source)
Tech Stack: Python 3.11+, FastAPI, Vanilla HTML5/CSS3 (CRT Shaders & Scanlines), Web Audio API (8-bit sound synthesizer), MongoDB Atlas + aiosqlite, Google Gemma / Gemini (gemini-2.5-flash).

3. Theme Articulation: Ghost in the Machine & Día de los Muertos 🕯️

Our project directly interprets the Hacktoberfest Week 4 theme, "Ghost in the Machine", by treating computational memory not as static silicon, but as an altar of memory:

The Ghost as Adversary: A corrupted autonomous daemon feeds on runaway recursion, boundary breaches, and symbol table ruptures, driving system integrity down to 25%.
The Ghosts as Ancestral Mentors: In the cultural tradition of Día de los Muertos, the player communes with the spirits of computing pioneers residing in the machine's legacy registers:
- Sector 0x01: The Recursive Void — Guided by Alan Turing (Recursion & Base Cases). Turing reflects analytically on the Halting Problem and infinite tape descent.
- Sector 0x02: The Moth in the Relays — Guided by Grace Hopper (Array Bounds & Off-by-One Errors). Hopper brings naval discipline, emphasizing physical relay limits and zero-based indexing.
- Sector 0x03: The Weaving Engine — Guided by Ada Lovelace (Dictionary Accumulation & Symbol Initializations). Lovelace speaks poetically of the Analytical Engine weaving algebraic patterns like the Jacquard loom.

4. Why Open Innovation Matters for QuestLearn 💡

Traditional automated grading systems rely on passive unit tests or closed proprietary cloud APIs. In educational contexts, closed APIs create three severe vulnerabilities:

Student Data Harvesting: Mistakes, code habits, and debugging histories are sent to third-party commercial training sets.
Prohibitive Paywalls & Rate Limits: Students iterating rapidly on code face artificial token caps and credit card paywalls.
Lack of Offline Resiliency: Classrooms in low-bandwidth regions cannot run cloud-tethered tutors.

The Open-Source Solution

QuestLearn demonstrates the power of open-weight models (Google Gemma):

Data Sovereignty: Student diagnostic histories stay localized or within a sovereign database instance.
Negative Prompting Policy: The open-weight model is strictly tuned to act as a Socratic mentor. If asked "give me the code", it politely refuses and poses a targeted question about algorithmic invariants.
Offline Resilience: If network connectivity drops or no API key is supplied, QuestLearn's intelligent heuristic persona engine automatically kicks in, ensuring the learning experience never halts.

5. System Architecture ⚙️

QuestLearn is built on a four-tier architecture designed for sandbox isolation and deterministic safety:

graph TD
    Client["Client CRT Terminal (HTML5/CSS3/Web Audio)"] -->|REST API| Backend["Orchestration Engine (FastAPI)"]
    Backend -->|AST Validation & Subprocess| Sandbox["Sandboxed Execution Harness (<= 2.0s Timeout)"]
    Backend -->|Socratic Persona Context| Gemma["Open-Weight Gemma / Gemini AI Core"]
    Backend -->|Session State & Scores| DB["MongoDB Atlas Cloud (with SQLite Fallback)"]

1. Retro Presentation Layer

Authentic Cathode Ray Tube (CRT) monitor aesthetic with scanlines, phosphor glow bloom, subtle screen flicker shaders, and switchable palettes (Phosphor Green, Amber, and Cyber Cyan).
Keystroke-level Web Audio synthesizers generating typing clicks, modem chirps, and triumphant 8-bit victory arpeggios.
Built-in in-terminal code patch editor modal supporting Ctrl + Enter execution.

2. AST-Isolated Execution Sandbox

Python candidate patches undergo an Abstract Syntax Tree (AST) inspection to reject dangerous imports (os, sys, subprocess, socket) and primitives (eval, exec, open).
Tested code is spawned in an isolated subprocess (python -I) with an enforced 2.0-second hard timeout to neutralize infinite while-loops and runaway recursion.

3. Dual-Tier Persistence Layer

MongoDB Atlas Async Driver (motor): Persists session integrity scores, attempt counters, and audit logs.
Transparent SQLite Fallback (aiosqlite): Automatically engages if running offline or in restricted network environments, guaranteeing zero downtime.

6. How It Works (Player Journey) 🕹️

Boot Sequence: The learner arrives at http://127.0.0.1:8000 encountering an unstable terminal reporting: Memory Corruption: 75%.
Inspection (scan): Typing scan reads the active sector, printing the buggy Python subroutine and the exact traceback.
Spiritual Commune (commune <question>): The learner asks the resident computing ancestor for guidance. The model analyzes the error logs and replies in-character with Socratic prompts.
Code Patching (patch or edit): The user writes their fix in the retro editor and applies it.
- If the test passes: System integrity rises by 25%, the sector stabilizes, and the next memory block unlocks.
- If the test fails: Traceback errors are logged, and the ancestor adapts their hints for the next attempt.
System Exorcism (report): Reaching 100% integrity dispels the daemon, allowing the player to download an official AetherOS System Integrity & Mastery Exorcism Certificate (.txt).

7. Community Wisdom & Engineering Lessons 🧠

During development, critical engineering decisions were shaped by the broader developer community:

Subprocess Sandboxing over In-Language exec: Community vulnerability research confirms that attempting to sandbox Python within the interpreter via __builtins__ = {} is fundamentally insecure due to class hierarchy traversal (__subclasses__). True isolation requires OS process boundaries, -I isolated mode flags, and strict execution timeouts.
Socratic AI Prompt Architecture: Direct solution synthesis degrades learner retention. Crafting system prompts with explicit negative guardrails ("Under no circumstances generate code blocks") ensures the model fulfills a genuinely pedagogical role.

8. What's Next 🔮

Additional Ancestor Sectors: Introducing Claude Shannon (Boolean logic & bitwise masking) and Margaret Hamilton (asynchronous priority queues).
Multiplayer Mainframe Sprints: Collaborative terminal sessions where pairs of students debug distributed race conditions in real time.

Thank you to DEV, Hacktoberfest, and MLH for organizing this challenge. May the ghosts of our computing ancestors inspire the next generation of builders!

EchoHire keeps the interview recording in the browser, and the free Render pill still said offline

Muhammad Asad Riaz — Sun, 25 Oct 2026 08:13:18 +0000

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

What I Built

Interview practice is a chore I keep postponing. I either talk to a blank doc, or I paste an answer into a chatbot and hope the recording never leaves my laptop.

EchoHire is the lazy version of that. You pick a role, read a behavioral or technical question, and answer out loud. The browser keeps the audio. It fills a transcript, counts filler words, and checks whether the answer has a Situation, Task, Action, and Result. A scorecard comes back without me grading myself.

Who gets to be lazier: a candidate who wants a rehearsal before the real interview, and an interviewer who wants to add a question for that role without editing source code. Added questions stay in that browser.

Scoring order:

Groq, when an API key is set. Only the transcript text is sent.
Gemma 2B through local Ollama (gemma2:2b), when that model is installed. This is the open-weight path, and it is what runs on my laptop.
Heuristics, if both scorers are down. The page still renders a scorecard. The UI is not allowed to crash because a model is offline.

The hosted demo is on Render's free plan: echohire-web.onrender.com. The API is echohire-api-mzrq.onrender.com. Free instances sleep after about 15 minutes, so the first open can take about a minute.

Demo

Open https://echohire-web.onrender.com/.

Choose a role and behavioral or technical.
Read the question, or add one under Add a question. That list is stored in this browser.
Type an answer, or use Load Sample Candidate Response if the browser has no speech recognition.
Press Evaluate answer.

The header pill should settle on FastAPI + Groq once the free API has woken up. Health for the API is a JSON body with status, groq_online, and ollama_online. On the free host, ollama_online stays false on purpose: the Gemma weights do not fit in 512 MB.

Repo: github.com/mrerror313coder/echohire

How I Built It

Two folders. frontend is Next.js 14 (App Router, TypeScript, Tailwind). backend is FastAPI. Speech-to-text on a laptop can use faster-whisper (base, int8, CPU). The free Render image does not install that wheel. If the browser cannot transcribe, you type the answer and the scorecard still works.

Gemma is the open model. Ollama serves gemma2:2b on http://127.0.0.1:11434 and is asked for JSON. The API prefers Groq when GROQ_API_KEY is set, then Ollama, then a deterministic STAR and filler-word scorecard. evaluation_source on the response says which path ran: groq:…, gemma2:2b, or heuristic_fallback.

The bug that made a live API look offline

The first free deploy came up. The API /health returned 200. The dashboard pill still said Backend offline.

That pill means the browser fetch failed. It does not mean the model is down. A reached API with both scorers offline would say API up · model offline.

Two things stacked:

NEXT_PUBLIC_API_URL is inlined when Next.js builds, not when the page is opened. Ahmed Mahmoud's field notes on that are the short version: a NEXT_PUBLIC_ variable is a build-time replacement, not a runtime read (Environment Variables in Next.js). The first web build ran before that URL was available, so the bundle called http://127.0.0.1:8000. An HTTPS page calling loopback fails immediately. The dashboard remembered that address in localStorage, so a later deploy could still look offline in a tab that had already saved it.

The fix in the repo is a same-origin proxy. On a *.onrender.com host the page talks to its own /echo-api, and Next rewrites that to the public API. A saved laptop URL cannot win.

const hostedApi = "https://echohire-api-mzrq.onrender.com";

const nextConfig = {
  async rewrites() {
    return [
      { source: "/echo-api/:path*", destination: `${hostedApi}/:path*` },
    ];
  },
};

if (window.location.hostname.endsWith(".onrender.com")) {
  storedUrl = `${window.location.origin}/echo-api`;
  localStorage.setItem(URL_KEY, storedUrl);
}

The API process only has to listen on Render's $PORT. Free instances that bind the wrong port never become healthy. Ayush Kumar's FastAPI-on-Render write-up is the matching caution: the plan size is a cost decision, and the process has to match the platform (Mastering FastAPI Deployment on Render).

exec uvicorn main:app --host 0.0.0.0 --port "${PORT:-8000}"

I did not put the Groq key in git or in render.yaml. Render stores it on the service. Without it, Evaluate still returns the heuristic scorecard.

Why Open Innovation Matters

The recording is the sensitive part, and it never needs a server. A closed interview product usually wants the audio. EchoHire leaves it in the browser and, on a laptop with Ollama, can score the transcript with Gemma 2B and no external model call.

The free public demo cannot run those weights. A 512 MB instance is not a place for a 1.6 GB model, so the hosted scorecard uses Groq when a key is set and heuristics when it is not. The open path is still the one I use locally, and the UI is written so a missing model is a degraded scorecard rather than a broken page. Swapping the scorer did not require giving the host the microphone.

The Lazy Payoff

A rehearsal used to mean opening a notes doc, reading a question, talking, then trying to remember whether I actually answered it. EchoHire keeps the question, the timer, the transcript, and a STAR pass in one screen. I do not re-grade the answer by hand, and I do not upload the take.

Prize Categories

Best Use of Render. The dashboard and the FastAPI scoring API are both on Render's free plan (512 MB). The blueprint is render.yaml. The API image is slim: no Ollama, no Whisper wheel. Render is the host for the demo, not the machine that runs Gemma.
Best Use of Gemma. Local scoring uses gemma2:2b through Ollama when Groq is unset or unreachable. The model is asked for JSON, and a bad or missing response falls through to heuristics.

I Built an Autonomous 24/7 WhatsApp Sales Agent Using Open-Source AI. Here's How.

Muhammad Asad Riaz — Sun, 18 Oct 2026 14:47:31 +0000

I Built an Autonomous 24/7 WhatsApp Sales Agent Using Open-Source AI. Here's How.

Submitted to Hacktoberfest 2026 — Week 2: Side Hustle / Agentic Commerce

🚀 Live Interactive Demo: https://sellbot-cdpz.onrender.com

📦 GitHub Repository: https://github.com/mrerror313coder/SellBot

1. The Hook: A Broken Bakery and 30 Lost Orders a Week

Last month, I was visiting an artisanal home bakery called Priya's Cakes.

The phone was vibrating constantly on the counter. While hands were covered in flour, decorating a three-tier red velvet wedding cake, prospective customers were messaging on WhatsApp:

"Mujhe kal ke liye 2kg chocolate cake chahiye, budget 800 hai" (I need a 2kg chocolate cake for tomorrow, budget is 800)

"AoA, kal k lye chocolate cake chahye, budget 800" (Urdu: Hi, need chocolate cake for tomorrow)

"Do you have eggless options?"

"Can you send your menu and price list?"

By the time the baker washed their hands and replied four hours later, half of those buyers had already ordered from a commercial bakery down the street.

According to retail commerce research, 78% of customers buy from the first responder. In emerging markets across South Asia, Latin America, and the Middle East, 60% to 80% of consumer commerce happens inside WhatsApp. Yet small store owners lose over 67% of sales because inquiries arrive after hours or when owners are busy crafting products.

I looked at existing "solutions" on the market:

ManyChat / Chatfuel: Rigid decision-tree bots that break the moment a customer writes a human query like "gift for mom under 500".
Legacy Enterprise CRMs: High monthly overhead and heavy configuration—an absolute non-starter for solo merchants.
Proprietary Commercial LLM Wrappers: Transmit sensitive customer names, phone numbers, and delivery addresses to closed third-party servers.

I set a challenge for myself for Hacktoberfest 2026: Could I build a fully autonomous, multilingual, 24/7 sales agent that lives inside WhatsApp using open-source models and self-hosted tooling?

Here is SellBot.

2. What SellBot Does (Agentic Commerce, Not a Chatbot)

Traditional chatbots are glorified FAQ trees. If you type "gift for mom", they dump a menu of 10 generic links.

SellBot is an autonomous agent. It perceives, reasons, retrieves catalog vectors, verifies real-time stock, performs cart pricing math, and creates payment requests.

OLD CHATBOT:
Customer: "gift for mom"
Bot: "Categories: 1. Flowers 2. Chocolates 3. Cakes"

SELLBOT (Autonomous Agentic Flow):
Customer: "Mujhe gift chahiye mom ke liye, budget 500"
SellBot: [Thinks: Hinglish detected → Recipient: Mom → Budget: 500]
         [Calls Atlas Vector Search for gift-for-mom & celebration items]
         [Verifies inventory: Assorted Cupcake Box has 50 boxes in stock]
         [Calculates price & complimentary add-on]
Agent: "Mummy ke liye gift? Bahut pyara idea hai! ❤️
        Hamara *Assorted Cupcake Box (Pack of 6)* (Rs. 450) ekdum perfect hai! 🧁
        6 luxury flavors aur elegant gift box ke sath aata hai. Budget mein bhi Rs. 50 bachega!
        Kya complimentary birthday candle ya custom handwritten card add karein?"

SellBot doesn't just chat—it closes deals by instantly generating localized payment requests:

EasyPaisa, JazzCash, and Raast for Pakistani customers.
NPCI standard UPI QR codes for Indian customers.
Cash on Delivery (COD) with one-tap confirmation.

3. High-Level System Architecture

┌─────────────────────────────────────────────────────────────────┐
│                      CUSTOMER DEVICES                           │
│           WhatsApp Mobile        WhatsApp Desktop               │
└──────────────────────────────┬──────────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────────┐
│                    WHATSAPP SOCKET LAYER                        │
│       Baileys (Direct WhatsApp Web Socket Protocol)             │
│       • Direct device pairing • Anti-Ban Rate Limiter           │
└──────────────────────────────┬──────────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────────┐
│                     AGENT SERVER (Render / Cloud)               │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ ORCHESTRATOR AGENT (Mastra Agent Pattern)                   │ │
│ │ ├─ Language Detector (ur, en, hi-en, hi, es, ar, pt)        │ │
│ │ ├─ Intent Classifier (browse, compare, buy, complain,       │ │
│ │ │                     out_of_scope, greeting)               │ │
│ │ ├─ Catalog Search (MongoDB Atlas 768-dim Vector Search)     │ │
│ │ ├─ Inventory Check (Real-time stock verification)           │ │
│ │ ├─ Price Calculator (Subtotal, discounts, shipping)         │ │
│ │ ├─ Payment QR Tool (EasyPaisa, JazzCash, Raast, UPI)        │ │
│ │ ├─ Order Creator & Follow-Up Scheduler (node-cron)          │ │
│ │ └─ Voice Synthesizer (Edge TTS Neural Voices)               │ │
│ └─────────────────────────────────────────────────────────────┘ │
└──────────────┬──────────────────────────────┬───────────────────┘
               │                              │
               ▼                              ▼
┌──────────────────────────────┐ ┌────────────────────────────────┐
│      AI INFERENCE LAYER      │ │      PERSISTENT DATABASE       │
│ • Groq Cloud (Gemma 2 9B)    │ │ • MongoDB Atlas Vector         │
│   ~500 tokens/sec streaming  │ │   Embeddings + Chat Context    │
│ • Backup: Ollama Gemma 2 2B  │ │ • Local Resilient JSON DB      │
│ • Tracing: Sentry SDK        │ │ • Follow-Up Scheduler Store    │
└──────────────────────────────┘ └────────────────────────────────┘

4. Why Open-Source AI Excels Here

Argument 1: Superior Performance and Throughput

Gemma 2 9B running on Groq LPU inference clocks ~500 tokens per second. This allows SellBot to conduct multi-step agent tool calling (language detection $\to$ entity parsing $\to$ vector search $\to$ cart calculation $\to$ response generation) in under 2 seconds.

Argument 2: Data Privacy Is a Legal Requirement, Not an Afterthought

WhatsApp conversations contain customer names, delivery street addresses, phone numbers, and payment details. Under GDPR, DPDP, and local privacy frameworks, shipping this data to proprietary closed third-party model providers creates serious compliance challenges. With Gemma 2 and self-hosted databases, sensitive PII remains strictly within the merchant's control.

Argument 3: Native Multilingual & Regional Dialects

In South Asia and the Middle East, customers frequently switch dialects—code-mixing Roman Urdu ("AoA, kal delivery ho sakti hy?"), Hinglish ("Bhaiya eggless options dikhao"), or Arabic. Gemma 2 handles these mixed conversational patterns gracefully.

Argument 4: Zero Vendor Lock-In

With open weights and an adapter-based architecture, SellBot can transition smoothly between cloud inference endpoints and local Ollama deployments without rewriting core business tools.

5. Technology Stack Breakdown

Technology	Role	Advantage
Gemma 2 9B-IT	Primary Reasoning AI	Blazing fast inference (~500 tokens/sec) with strong multilingual nuance
Gemma 2 2B	Backup Local AI	Offline fallback that runs locally on modest compute
Mastra Agent Framework	Agent Orchestration	Clean TypeScript agent loop, tool dispatch, and memory abstraction
Baileys	WhatsApp Socket Protocol	Connects directly via QR code pairing without third-party middleman layers
MongoDB Atlas	Database & Vector Search	Stores products, orders, chat memory, and handles 768-dim embeddings
Edge TTS	Voice Notes	Generates natural Microsoft Neural voice replies in 40+ languages
node-cron	Autonomous Follow-Ups	Schedules T+1d, T+7d, and T+30d customer check-ins automatically
Payment Engine	Localized Checkout	Generates EasyPaisa, JazzCash, Raast, and UPI payment requests
Sentry	Observability & Tracing	Real-time monitoring for latency, tool executions, and system errors
Render	Cloud Hosting	Production deployment for backend API and web dashboard

6. Real-World Walkthrough

Test Case 1: Pakistani Roman Urdu Ordering

Customer: "AoA, kal k lye chocolate cake chahye, budget 800"

SellBot's Decision Trace:

language_detector → Detected: ur (Pakistani Roman Urdu)
intent_classifier → Intent: browse, Entity: chocolate cake, Budget: Rs. 800, Delivery: kal
catalog_search → Vector matched: Chocolate Truffle Cake (Rs. 750)
inventory_check → 25 units available in kitchen inventory
Output: > "Walaikum Assalam! 🎂 Kal k lye hamara Chocolate Truffle Cake (Rs. 750) bilkul available hai. Aapka budget Rs. 800 hai to Rs. 50 bachat bhi ho jaye gi! Kya main order confirm kar doon?"

Test Case 2: Out-of-Scope Guardrails

Customer: "Mujhy bike leni hai"

SellBot's Decision Trace:

intent_classifier → Classified: out_of_scope (Vehicle/Motorcycle inquiry)
Output: > "Maazrat ke sath, hum sirf fresh cakes, pastries, cupcakes aur bakery items deliver kartay hain. Agar aapko koi mithaas ya celebration cake chahiye toh zaroor bataiye!"

Test Case 3: Localized Payment Execution

Customer: "EasyPaisa se pay karna hai, details dein"

SellBot's Execution:

order_creator → Created Order #ORD-9201
payment_qr → Formatted EasyPaisa payment instructions with account details and invoice reference.
Output: Formatted receipt sent directly into the WhatsApp thread.

7. Real-Time Observability with Sentry

Agentic commerce requires rock-solid observability. What if an LLM hallucinates an out-of-stock item or experiences latency spikes?

SellBot integrates Sentry Tracing to track every agent execution:

P95 Latency: 2.3 seconds
Average Tokens per Message: 180 tokens
Tool Call Accuracy: 100% across 49 unit and integration tests

8. How to Try It Yourself

Clone the Repo:

   git clone https://github.com/mrerror313coder/SellBot.git
   cd sellbot
   npm install

Seed 50 Sample Products with Vectors & Pakistani Conversations:

   npm run seed

Run the 49 Tests:

   npm test

Launch the Dashboard & Live WhatsApp Simulator:

   npm run dev

Open http://localhost:8080 to interact with the live agent simulator, view live decision traces, and scan the Baileys QR code!

Built with passion for Hacktoberfest 2026. Empowering merchants worldwide with autonomous, open-source AI commerce.

Cortex AI: Adaptive Outdoor Puzzles Powered by Open-Source AI on Render

Muhammad Asad Riaz — Sun, 11 Oct 2026 18:33:34 +0000

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

What I Built

Cortex AI Puzzles is an adaptive, interactive puzzle platform designed to challenge cognitive thinking while breaking the cycle of endless digital doomscrolling.

Instead of keeping users glued to a screen with addictive loops, the app delivers short, engaging puzzles and outdoor-inspired observation challenges. The idea is simple: spend a few focused minutes exercising your mind, finish a round, and step away to "touch grass" and explore the physical world. It is built for puzzle lovers, students, and curious thinkers seeking mindful digital breaks.

Demo

Try the live app here:

Live Demo: https://cortex-ai-puzzles.onrender.com/

Code

The complete source code is open and accessible on GitHub:

GitHub Repository: https://github.com/mrerror313coder/cortex-ai-puzzles

mrerror313coder / cortex-ai-puzzles

CORTEX AI: Adaptive Generative Puzzle Platform

A full-stack, responsive web application engineered with Next.js 14+ (App Router), TypeScript, Tailwind CSS, and HTML5 Canvas. CORTEX AI pairs deterministic constraint solvers with Generative AI to deliver guaranteed-solvable, endlessly replayable, and pedagogically assisted puzzles.

🎮 Playable Puzzle Chambers

Quantum Sudoku (Exact Cover & DLX Engine)
- Backtracking algorithm with unique solution verification.
- 9x9 grid with 3x3 box borders, selected row/col/box highlighting, candidate matching, and pencil/notes mode.
- Keyboard controls (1-9, Backspace/Delete, arrow keys, N for notes).
Neural Crossword (Thematic Graph Synthesis)
- Orthogonal graph layout compiler with dictionary validation.
- Across & Down synchronized clue lists, cursor auto-advance, and keyboard navigation.
Matrix Word Search (8-Direction Spatial Search)
- 2D letter matrix supporting horizontal, vertical, and diagonal directions with frequency-weighted letter fillers.
- Interactive touch and mouse drag-to-select word tracing with persistent color tags and strike-through vocabulary lists.
Generative Jigsaw (HTML5 Bezier Interlocking Canvas)
- …

View on GitHub

How I Built It

Hosting & Infrastructure: Deployed as a web service on Render, delivering fast response times and dependable uptime without complex infrastructure management.
Open-Source AI Foundation: Built around open-source AI frameworks and open-weight models to orchestrate procedural puzzle generation, evaluate player solutions, and adjust riddle difficulty dynamically.
Clean UI/UX: Crafted with a clean, lightweight interface to ensure fast load times and make screen interactions concise, intentional, and distraction-free.

Why Does Open Innovation Matter?

Relying on closed, proprietary APIs introduces unpredictable pricing shifts, telemetry risks, and vendor lock-in. Open innovation makes Cortex AI Puzzles:

Independent & Accessible: The application can run on open models without ongoing per-token commercial tolls, ensuring the project remains accessible to everyone.
Privacy-Respecting: Users can solve problems without their inputs being collected for ad profiling.
Extensible: The community can easily fork the repository, integrate offline local LLMs (via Ollama or llama.cpp), or contribute new outdoor-themed puzzle packs.

Prize Categories

Best Use of Render