DEV Community: Mohammed Thaha

From a Phone in a "Cave" to Global Open Source: Why Google’s Gemma Models are a Lifeline for Budget Developers

Mohammed Thaha — Fri, 22 May 2026 07:40:07 +0000

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

Before you dive into reading this blog, I want to share one thing with you straight from the heart. I didn’t just write this blog directly using an LLM or any AI tool. I sat down and drafted every single bit of this story in my notepad first. Then, I put it into AI and said,
Hey, look, don’t add extra artificial content. Just help me organize my thoughts and put this info correctly so I can share my real experience.

TL;DR: The Quick Snapshot

The Core Story: How running lightweight open-source AI locally on a phone subsystem saved my engineering studies when internet network routing cut out completely.
Mobile Setup Stack: Compiling llama.cpp natively in Android Termux using release tag b4833 to bypass the common spawn.h Android error, executing an optimized 4-bit quantized Gemma 2B model.
Workstation Setup Stack: Host environment dual-booting Ubuntu Linux, compiling native builds with CPU optimization parameters to launch gemma-4-E4B-it via local web server endpoints.

The Budget Spec Sheet: Real World Hardware Configurations

A lot of tech blogs show local AI running on $3,000 developer rigs with dual RTX 4090 GPUs. That is not what this story is about. Here is the exact, modest hardware I used to build, compile, and run everything offline:

Specification	My Mobile Setup	My Workstation Laptop
Device Type	Android Smartphone	Everyday Dual-Boot Laptop
System Environment	Termux Terminal Emulator (F-Droid Build)	Ubuntu Linux (Boot Target for Focus Sessions)
Total Memory (RAM)	7.27 GB Total System RAM	8.00 GB RAM
Storage Allocation	N/A (Internal Android Storage)	191 GB NVMe SSD Base Partition (~21 GB Free)
Model Target	Google Gemma 2B Int4 Quantized (GGUF)	Google Gemma 4 (E4B Flavor)

As you can see from my telemetry screenshots below, both devices are running tightly under their memory ceilings, proving that Gemma doesn't require elite data centers just smart configuration!

What's Covered in This Blog

The Budget Spec Sheet
The Superpower of True Offline Coding
What Makes Gemma So Mind-Blowing?
Showcasing the Setup: Gemma Natively on My Phone!
Step-by-Step: Native Mobile Setup (Termux + spawn.h Fix)
My New Setup: Pure Focus Mode on Laptop
Step-by-Step: Compiling Gemma 4 on Ubuntu Linux
Final Thoughts & Acknowledgments

The Superpower of True Offline Coding

A lot of people ask me, Why do you care so much about running models offline when the cloud exists?

Because I remember my school days. I didn’t have a flashy, high-end laptop. I had a smartphone. I used Termux, Acode, and Anwriter to write code directly on my tiny screen. I still remember the absolute thrill of building my very first Tic-Tac-Toe game using pure HTML, CSS, and JavaScript, entirely offline.

Back then, the absolute biggest roadblock to studying and building things was documentation. If you wanted to learn or look up an error code, you needed an internet network to scroll through endless pages. If your network failed, your learning stopped.

But when you code or study completely offline with an AI tutor, a superpower unlocks: The noise disappears, and the barriers vanish.
Here is exactly what my brain looks like when the Wi-Fi is on versus when I cut the cord:

Image generated using Google Gemini

Now, that entire network problem is completely solved. Anyone can build anything and learn easily without spending a single penny on expensive internet plans or premium data subscriptions.

Historically, the problem with offline AI was hardware. Running a capable LLM required an expensive machine with massive amounts of VRAM. If you didn’t have the cash for a high-end gaming GPU, you were locked out.

Google just shattered that barrier. By releasing the Gemma model family under an open, commercially permissive Apache 2.0 license, they didn't just give us a powerful model; they gave every single student around the globe access to frontier-level AI on regular, everyday devices. When I spin up a Gemma model to help me generate Go code on an older, struggling laptop and watch it handle the logic flawlessly, I genuinely feel like Tony Stark.

"TONY STARK BUILT THIS IN A CAVE! WITH A BOX OF SCRAPS!" > —— Me screaming at my old laptop when the local Go code compiles perfectly. 😂

What Makes Gemma So Mind Blowing?

Google engineered these lightweight, open-weights models specifically to bring massive reasoning capabilities straight to accessible hardware.

In plain English? It means the model doesn't choke your device's RAM. Instead of needing a massive corporate data center to process complex logic, it uses ultra-efficient token processing and smart memory layouts. This drastically shrinks the hardware footprint, allowing you to feed it prompts without crashing your device or causing your phone to overheat like a hot potato.

Whether you are running a lightweight version on a smartphone or a larger variant on a laptop, you are getting incredible coding and debugging help completely locally.

Showcasing the Setup: Gemma Running Natively on My Phone!

To show you that this isn't just theory I actually live this setup. Check out this video of my actual screen while using it:

Seeing text stream into a mobile terminal screen like that when you are completely disconnected from the outside world is an unmatched feeling. It makes you realize that the barriers to education and software engineering are completely tearing down.

Just to be transparent with you guys on the dates: what you are seeing in that video above is my older mobile setup running the Gemma 2B model. I originally took this screen recording on May 16, 2026, after using the model heavily in Termux, and I just uploaded the clip to YouTube on May 20, 2026, to share it here. I wanted to show you this video because it proves just how smooth and massive the performance is even on a small phone. It makes you think—if a lightweight 2B model can do all this, how crazy is the new Gemma 4 going to be?

Recreating the Magic: Step-by-Step Native Mobile Setup

Want to turn your phone into an offline powerhouse running a model like Gemma 2B? Here are the actual commands to set up Termux and compile llama.cpp directly on Android:

Note: These images reflect the exact workflow from my mobile device. If the upstream repository receives new updates down the line, simply check their latest branch logs and run your build!

Step 1: Install Required Packages & System Headers

pkg update && pkg upgrade -y
pkg install -y git cmake clang make python ndk-sysroot wget

This installs all the essential tools required to compile llama.cpp natively inside Termux.

Step 2: Hitting the Nasty spawn.h Error

While compiling, I encountered a spawn.h error on Termux during the build process.

To fix this issue, I rolled back to a stable build tag and rebuilt the project.

# Roll back to a stable release build tag to bypass the spawn.h error
git checkout b4833

# Clear the old broken build artifacts
rm -rf build

# Reconfigure and trigger the compilation process using 4 threads
cmake -B build
cmake --build build -j4

This successfully compiled the project without errors on Android.

Step 3: Download and Run Your Offline Assistant

# Create a models directory inside llama.cpp
mkdir -p models
cd models

Download your preferred GGUF model and place it inside the models folder.

Example model used:
gemma-2-2b-it-Q4_K_M.gguf

Step 4: Launch Gemma 2B (Choose Web UI or Terminal Chat)

Option A: Launch the Local Web UI Server

./build/bin/llama-server -m models/gemma-2-2b-it-Q4_K_M.gguf -c 512 -t 2 -ngl 0

Leave Termux running, open your phone browser, and navigate to http://127.0.0.1:8080. Below is a screenshot of the clean interface running completely offline from my mobile browser setup:

Option B: Launch Interactive Chat in Terminal

./build/bin/llama-cli -m models/gemma-2-2b-it-Q4_K_M.gguf -c 512 -t 2 -ngl 0 -cnv

m → Path to the model
c 512 → Context size
t 2 → Number of CPU threads
ngl 0 → Disable GPU layers (recommended for mobile)

Once launched, the model runs completely offline on your Android device.
Below is a screenshot of the model running in my Termux terminal.

My New Setup: Pure Focus Mode (Minus the Distractions)

Right now, I am so eager to test Gemma 4 on my phone next, but for serious coding work, I've deployed it on my laptop setup instead.

I have a dual-boot machine running Windows and Ubuntu Linux, and for serious focus sessions, I always boot straight into Ubuntu.

And look, the beauty of llama.cpp is that you can host a local server and run the model directly inside a clean, beautiful browser interface on your local machine. It is absolutely superb. I get to pull up my project files, ask my local model questions, and have zero internet tabs open to distract me. Bye-bye internet, hello focus mode!

Step-by-Step Guide: Compiling Gemma 4 on Ubuntu Linux for High Performance

Step 1: Update System and Install Core Build Tools

sudo apt update && sudo apt install -y git build-essential cmake

Step 2: Download and Compile llama.cpp

git clone https://github.com/ggml-org/llama.cpp.git

cd llama.cpp

cmake -B build
# Build project (e.g., -j4 for 4 cores, or -j$(nproc) for all cores)
cmake --build build -j

Step 3: Create Directories and Download Gemma 4 GGUF

# Create the models directory inside llama.cpp if it doesn't exist
mkdir -p models 

# Download your preferred Gemma 4 GGUF flavor from Hugging Face into the models folder

Step 4: Launch Gemma 4 (Choose Web UI or Terminal)

Option A: Launch the Local

./build/bin/llama-server -m models/gemma-4-E4B-it-Q3_K_S.gguf -c 4096 --host 127.0.0.1 --port 8080

Once that server is running, you just open your browser, head to http://127.0.0.1:8080, and you have a stunning interface running 100% locally from your machine!

Here is exactly what it looks like when I boot into Ubuntu and run the Web UI interface. Look at how seamlessly it breaks down complex topics like Deep-First Search (DFS) and Breadth-First Search (BFS):

Option B: Launch Interactive Chat in Terminal

./build/bin/llama-cli -m models/gemma-4-E4B-it-Q3_K_S.gguf -p "Hi" -env

Here is a live screenshot of the terminal variant spinning up on my desktop. You can see htop running on the right side, showing how lightweight and light on resources the execution is on my CPU:

Looking at this laptop setup makes me feel incredibly grateful. I have to give a massive shoutout to Google. A while back, the high-quality technical information and support I got from the Gemma ecosystem actually helped me write high-value blogs on Dev.to. Those blogs gained traction, helped me clear technical hurdles, and ultimately allowed me to make the money I needed to finally step up from just a phone and get this laptop.

Final Thoughts: Thank You, Google

From tinkering with basic text editors in my school days to deploying advanced Go routines on an old, hardware-challenged laptop today, local execution has completely shaped my trajectory as a developer.

AI shouldn't just be a luxury for those who can afford massive monthly cloud subscriptions or elite hardware. By putting open-weights, highly compressed powerhouses like the Gemma family directly into our hands, Google has leveled the playing field for student developers everywhere who are suffering through hardware or internet constraints.

Thank you, Google, for making things easy for me from my childhood all the way to right now. You always clear the path for devs who are trying to learn and grow.

Now, go clone the repository, download the weights, shut off your internet, and go build something awesome in your own cave!

Before I close this blog completely, I want to say one last thing. I just wanted to share the true happiness and pure excitement of a kid coding from his phone and moving up to a laptop. I hope this story inspires other budget developers to realize that they don't need elite hardware to build amazing things. Thank you so much for reading, and good luck with your own builds!

Deal Agent Forge: AI-Powered Tech Builder with Conversational Intelligence

Mohammed Thaha — Tue, 03 Feb 2026 19:44:27 +0000

This is a submission for the Algolia Agent Studio Challenge: Consumer-Facing Conversational Experiences

What I Built

Deal Agent Forge is an AI-powered conversational configurator that simplifies building Gaming PCs, Professional Drones, and Solar Power Systems by giving users rapid, accurate recommendations without overwhelming technical research.

Instead of manually checking specs, compatibility, and prices across multiple sites, users interact with a chat-based assistant that:

Understands natural language requirements
Retrieves relevant product data instantly
Guides users through build recommendations
Checks compatibility and cost-performance tradeoffs
Suggests optimized configurations based on context

Demo

Live Demo: Deal Agent Forge
GitHub: Github Link
Video Demo:

Key Features in Action:

ProductLens Exploration
Browse curated builds with tag-based filtering and intelligent search
Conversational Product Discovery
The Algolia-powered chatbot provides intelligent recommendations and answers complex technical questions
Interactive 3D Components
Explore components with interactive 3D models powered by Three.js

How I Used Algolia Agent Studio

I used Algolia Agent Studio to power Deal Agent Forge with fast, contextual, retrieval-backed responses.

Data & Indexing

I built a curated index of 103 tech products covering PC components, drone parts, and solar equipment. Each record contains structured specs, category tags, performance indicators, and contextual metadata all optimized for retrieval.

Users also have a “Report Issue” feature to flag incorrect details. When issues are reported, I update the dataset in Supabase and sync corrections to Algolia, keeping data fresh and reliable.

This approach aligns with the retrieval-first ethos: the agent retrieves grounded facts from structured data rather than hallucinating answers, reducing errors and improving usefulness.

Conversational Intelligence

Prompt engineering ensures context awareness: the assistant remembers preferences across exchanges

Retrieval ensures responses are up-to-date and data-grounded

Integration with Algolia’s InstantSearch Chat widget creates a smooth frontend experience

By combining search-native retrieval and LLM reasoning, the assistant feels like talking to an expert tech consultant powered by real data.

Algolia Agent Studio and My Index

InstantSearch Chat Integration

The frontend uses Algolia's InstantSearch Chat widget with custom styling to match the teal glassmorphism theme:

<InstantSearch
    searchClient={searchClient}
    indexName="Deal_Agent_Forge_Data"
>
    <Chat agentId={agentId} />
</InstantSearch>

Why Fast Retrieval Matters

Fast retrieval is the backbone of Deal Agent Forge’s performance and is at the heart of Agent Studio’s design philosophy.

Real-World Impact

Instant Compatibility Checks — millisecond-level retrieval avoids slow or incorrect replies
Accurate Pricing & Specs — no stale or hallucinated answers
Smooth Conversations — users never experience lag while the agent fetches context
Better Decisions — structured data retrieval leads to precise recommendations

This matches the evolving trend in industry — retrieval-first architecture — where agents rely on structured search systems to reduce hallucination, control costs, and improve quality rather than depending solely on generative output.

Technical Architecture

Frontend:

React 19 + Vite
InstantSearch Chat widget for conversation UI
Three.js for 3D previews
TailwindCSS for design coherence

Backend:

Supabase for database management

Algolia for fast retrieval and conversational grounding
Continuous sync between Supabase and Algolia for real-time updates
Indexing & Retrieval:

Semantic and structured indexing

Hybrid relevance: specs, tags, categories, price, compatibility
Contextual prompt routing to Algolia data

Final Impact

Deal Agent Forge turns the complex process of tech configuration into a guided, interactive, data-driven experience — removing guesswork and replacing it with contextual, accurate assistance.

It demonstrates how Agent Studio + retrieval-centered data architecture enables highly practical conversational agents with real utility beyond demos, aligning with the latest trends in AI agent design.

Boosting Goose Performance on Windows — Real Benchmarks, Power Tweaks, and Results

Mohammed Thaha — Wed, 29 Oct 2025 17:06:26 +0000

If you’ve downloaded Goose for Windows and launched it straight from goose.exe, you’ve probably noticed it runs smoothly — until your system starts feeling heavy. Browser tabs, sync apps, and background services all fight for the same CPU and RAM Goose needs to perform well.

In this article, I’ll share my real-world performance optimization journey running Goose on a Windows laptop, including actual PowerShell benchmarks, configuration fixes, and verified results. No deep system hacks — just practical, reversible tweaks that made Goose run significantly faster and more responsive.

System Overview — The Starting Point

Before tuning anything, I gathered raw system data to understand what was slowing Goose down. Here’s the baseline snapshot captured via PowerShell and Task Manager:

Top Processes by CPU Usage

OneDrive — 1118.29s CPU time
Explorer — 327.04s
Chrome — 54.87s (388 MB RAM usage)

Memory Stats

Total Physical Memory: 8 GB
Free Memory before optimization: ~1.02 GB
Active Power Plan: Balanced (default mode)

Interpretation:
The system was clearly under resource pressure. OneDrive and Chrome alone were consuming over half of the available CPU cycles and memory. The “Balanced” power plan was also holding back CPU clock speeds — a subtle but real performance bottleneck.

Step 1 — Switching to High Performance Mode

Windows ships with a “High Performance” plan that minimizes CPU throttling and keeps the processor active for heavy workloads. By default, most systems stay on “Balanced,” which reduces speed to save power.

To enable High Performance, I ran:

powercfg /list

Then activated it using the GUID shown for the High Performance plan:

powercfg /setactive SCHEME_BALANCED

Result:
After applying this, CPU responsiveness noticeably improved. Goose tasks launched faster, and background lag during AI or heavy workloads dropped by about 20–25% in practical feel.

Step 2 — Launching Goose at High Priority

Next, I made sure Windows gave Goose more CPU scheduling priority. The old PowerShell flag -Priority no longer works, so the correct modern way is:

Start-Process "C:\goose_application\dist-windows\goose.exe"
Get-Process goose | ForEach-Object { $_.PriorityClass = 'High' }

Result:
This ensured Goose ran smoothly even when other apps like Chrome or VS Code were open. Task Manager confirmed its priority was successfully elevated. The app felt much more responsive — especially noticeable when interacting with models or rendering outputs.

Step 3 — Freeing System Resources

One of the biggest slowdowns came from background services and sync apps.
Here’s what I did for quick and safe improvement:

Paused OneDrive syncing.
Closed Chrome tabs and other heavy browsers.
Stopped unnecessary background apps through Task Manager.
Cleaned temporary files and freed disk space.

After cleanup, free memory increased from ~1.02 GB to 3.4 GB — a huge improvement for an 8 GB system.

Step 4 — Rerunning Benchmarks After Optimization

After applying all the changes:

High Performance power plan activated
Goose launched at High priority
Background apps closed
Focus Assist enabled to reduce notifications

I rechecked performance and memory usage via PowerShell and Task Manager.

After Optimization Snapshot

Free Physical Memory: ~3.4 GB (vs 1.02 GB before)
OneDrive CPU usage dropped to negligible (paused)
Explorer and Chrome usage stabilized below 10% CPU
Goose process stayed active and snappy throughout session

Subjective Performance:
Goose now launched 2× faster and maintained consistent responsiveness under load. File operations, log access, and UI rendering were visibly smoother.

📁 Folder Organization Optimization

To prevent unnecessary scans and conflicts, I organized the Goose files neatly:

C:\goose_application
└─ dist-windows
   └─ goose.exe

📊 Before vs After Summary

Metric	Before	After
Free Physical Memory	~1.02 GB	~3.4 GB
Power Plan	Balanced	High Performance
Goose Priority	Normal	High
CPU Responsiveness	Moderate	Instantaneous
Launch Time	~5s	~2.3s
Background CPU Load	High (OneDrive + Chrome)	Low (paused OneDrive)

Overall Performance Gain:
≈ 2× faster launch, 20–25% smoother runtime, and noticeably lower stutter.

Extra Windows Tips

Keep at least 10 GB free space on your system drive.
Restart Windows every few days to clear memory fragmentation.

Conclusion — The Practical Takeaway

Goose performance depends less on hardware specs and more on how efficiently Windows allocates resources. By applying these simple yet impactful changes:

Switching to High Performance mode
Running Goose at High priority
Closing background apps
Keeping folder organization clean

you can make Goose feel significantly faster and smoother — even on a modest 8 GB laptop.

After all, a happy Goose is a fast Goose. 🦆⚡

🪶This blog is based on my personal understanding and hands-on benchmarks tested on my own Windows setup.

Building an STL-Based Tic-Tac-Toe Game for CP Solvers in C++

Mohammed Thaha — Tue, 12 Aug 2025 10:20:45 +0000

Competitive Programming (CP) is all about solving problems efficiently, and sometimes small projects like Tic-Tac-Toe can be a great way to sharpen your problem-solving mindset.
In this post, we’ll build a Tic-Tac-Toe game in C++ using STL (vector) and basic control flow — perfect for beginners in CP who want to brush up their coding fundamentals.

Why This is Useful for CP

STL Practice: Using vector for dynamic data handling
Logic Building: Win condition checks are similar to pattern-finding problems in CP
Input Validation: Good practice for handling constraints and edge cases
Fast Iteration: The game loop teaches efficient looping patterns

Step 1 — Representing the Board with STL

board stores the game state
currentPlayer keeps track of whose turn it is
isTie checks if the match ends in a draw

Step 2 — Printing the Board

We’ll create a clean, grid-like display for our board.

Step 3 — Player Moves with Validation

In CP, validating input is crucial. We’ll reject invalid moves and recursively retry.

Step 4 — Win & Tie Check Logic

We’ll check rows, columns, and diagonals.
This pattern-checking logic is directly applicable to CP problems involving matrices.

Step 5 — Main Function
We bring everything together in the game loop.

Output

Welcome to Tic-Tac-Toe!

 1 | 2 | 3
---|---|---
 4 | 5 | 6
---|---|---
 7 | 8 | 9

Player 'X', enter your move (1-9): 1

 X | 2 | 3
---|---|---
 4 | 5 | 6
---|---|---
 7 | 8 | 9

…and so on until the game ends.

🔗 Source Code on GitHub: View Here

Conclusion: This STL-powered Tic-Tac-Toe in C++ blends fun with fundamentals — vectors, loops, and logic checks — making it a quick win for CP practice. Clone it, tweak it, and try larger board variations for an extra challenge.