gdmcode

GDMCode turns an ordinary laptop into a private, offline coding teacher - explaining ideas, checking practice, and helping learners build without cloud access.

Comment

Inspiration

A learner should not need an expensive computer, a credit card, or perfect internet just to hear a patient explanation of what a function does.

I kept thinking about the ordinary laptop a student already has: 8 GB of RAM, integrated graphics, an unreliable connection, and a battery that may matter more than any benchmark. Most coding assistants are designed as if the cloud is always there. When it disappears, the teacher disappears with it.

GDMCode began with a stubborn question: what would a coding teacher look like if it had to live on that laptop, respect its limits, and still help a complete beginner make something they are proud of?

That changed the project. I stopped treating the model as the product. The real product had to be the learning space around it: calm explanations, small experiments, visible safety boundaries, and a place where being confused is not treated like failure.

What it does

GDMCode turns a compact local model into an offline programming studio.

A learner can open /learn, understand a basic concept, read a worked example, answer quick checks, and try code in a bounded practice workspace. Progress is saved on the device. The Build tether sits beside a code snippet and streams a focused explanation without silently writing files or running arbitrary commands.

The Offline/Online control is real, not decorative. Offline is the default and the tool continues to teach with no cloud request after installation. Online capabilities are an explicit choice for moments when connectivity is available.

Under the learner-facing UI, GDMCode also provides an authenticated local API, verified model lifecycle, typed lesson data, permission gates, and commit-or-rollback repository edits. A small model can still make mistakes; the harness is designed so those mistakes do not automatically become actions.

How we built it

The local core is written in Rust and extracted from our Grok Build-based coding harness. It manages connectivity policy, the llama.cpp process, model/checksum verification, authenticated loopback requests, SQLite state, streaming responses, and transactional repository changes.

The learner interface is a lightweight PWA built with purposeful HTML, JavaScript, and CSS. It is served by the local daemon and works without a web framework or remote frontend. Lessons arrive as validated LessonIR and QuizIR structures; the model never gets to invent executable page markup.

For the submitted model, we fine-tuned the 4B candidate for beginner-focused programming help, converted it to GGUF Q4_K_M, and pinned the exact artifact with SHA-256. A credential-free downloader fetches it from an immutable public HTTPS path, verifies every byte, and only then moves it into place. The application and the model are separate downloads so neither a multi-gigabyte weight file nor private training material enters the Git history.

Challenges we ran into

The difficult work lived between the demo moments.

We had to make a useful model fit a modest machine, recover from long training and conversion runs, distinguish genuine improvement from overfitting, and keep cloud machines from sitting idle. We had to make Offline mode fail closed across the transport and tool layers—not merely change a badge in the UI.

We also had to decide what the model must never control directly. Raw generated HTML, arbitrary shell execution, and unreviewed repository writes would make a flashy demo, but they would make a poor teacher. Building typed output, bounded checks, one-time local authentication, snapshots, verification, and rollback took longer. It was also the work that made GDMCode worth building.

Finally, small-computer evaluation is unforgiving. A result measured on a cloud VM is not a result measured on the competition laptop. We kept those records separate and left unknown scores as NOT MEASURED instead of turning hope into a benchmark.

Accomplishments that we're proud of

We built a real local product, not a sequence of mock screens.

  • The GDMCode binary runs on Windows and is packaged reproducibly for Ubuntu.
  • The learning PWA, quizzes, preferences, and progress live on the learner's device.
  • The 4B GGUF has a frozen checksum and a credential-free public download path.
  • Offline policy is enforced beneath the interface.
  • Practice checks are bounded and honest about what they did.
  • Repository changes have an explicit preview, verification, and rollback boundary.
  • The open-source handoff excludes private datasets, credentials, AWS state, and personal workbench history while preserving upstream attribution.

What I am proudest of is quieter: a beginner can open the tool, see the words “OFFLINE · LOCAL,” and know the lesson will not vanish when the connection does.

What we learned

A small model becomes far more useful when the product gives it a clear job. “Answer anything” is a weak teaching interface. “Explain this concept at my level, show one example, ask me to predict it, then let me test the idea” is a learning loop.

We learned that safety can feel humane instead of restrictive. Showing what is local, what was checked, and what needs permission gives the learner confidence without hiding the limits of the model.

We also learned that reproducibility belongs in the user experience. Checksums, an idempotent downloader, local state backups, deterministic packages, and truthful benchmark labels are not paperwork around the product. They are how someone on another computer can trust that they received the same GDMCode we built.

What's next for gdmcode

First, we will finish the exact Ubuntu 22.04 participant-profile run and use the measured memory, thermal, throughput, and learning-quality results to tune the final defaults.

Then we want to deepen the beginner path: functions, parameters, collections, recursion, classes, debugging, and small projects that end with something the learner can show another person. We will add languages and examples with local educators rather than treating translation as a substitute for teaching.

GDMCode will remain installable and offline-first. The public source will make the harness inspectable; the smaller 2B option will remain documented for lower-resource machines; and gdmcode.com will become the simple doorway for people who should not need to understand GGUF files or Rust workspaces before they can start learning.

Built With

Share this project:

Updates