DEV Community: OLALEKAN OGUNDIMU

The Last Computation: A Game About Alan Turing's Final June

OLALEKAN OGUNDIMU — Tue, 09 Jun 2026 22:36:49 +0000

This is a submission for the June Solstice Game Jam

Before we talk about the game, let me take you somewhere.

It is June 8, 1954. A housekeeper walks into a house in Wilmslow, Cheshire, England. She finds Alan Turing — mathematician, codebreaker, the man who helped end World War II — dead. He is 41 years old. A half-eaten apple sits beside him.

This is the same man who, a decade earlier, sat in a freezing hut at Bletchley Park and broke the Nazi Enigma cipher when the Allied forces had nearly run out of time. His machine — the Bombe — cracked codes that no human could crack fast enough. It is estimated that his work shortened the war by two to four years. Historians believe it saved over fourteen million lives.

And then, less than ten years after the war ended, the British government chemically castrated him as punishment for being gay. He died alone. The apple — possibly laced with cyanide — was never tested.

June is the month Alan Turing was born. It is the month he died. It is Pride Month. And this year, it is the month of this game jam.

This game is for him.

What I Built

THE LAST COMPUTATION is a browser-based mystery game set in June 1954, the weeks before Turing's death. You play as his successor — an operative who has just recovered three encrypted transmissions from Turing's study, transmissions no one was supposed to find.

The game has four chapters:

Chapters 1–3: The Codebreaking
Each chapter presents an intercepted document, styled as a wartime classified file — paper texture, red TOP SECRET stamp, typewriter ink, all of it. The document contains a ciphertext that you must decode using the same methods Turing and his team used at Bletchley: Caesar shifts and ROT13.

These are real ciphers. The game doesn't hold your hand. You work it out, or you ask for a hint. The decoded messages are fragments of Turing's final thoughts — haunting, brilliant, and deeply human.

Chapter 4: The Imitation Game — Inverted
This is where the game turns.

In 1950, Alan Turing published a paper asking: "Can machines think?" He proposed a test — now called the Turing Test — where a machine tries to convince a human that it is human. The machine that passes becomes, in some sense, intelligent.

In Chapter 4, a machine intelligence derived from Turing's own notes has been watching you work. Now it speaks. And it wants to ask you the questions.

Not whether you are smart. Whether you are human.

You have five turns. It asks you about grief, about love, about the fear of endings. It is cold, precise, and deeply curious. Every answer you give is scored — not by word count, but by the texture of your humanity: your hesitations, your emotion, your beautiful imperfection.

At the end, it delivers a verdict.

The solstice framing is deliberate: June is the turning point of the year. Chapter 4 is the turning point of the game. And June 1954 was the turning point — the darkest one — of one extraordinary human life.

Video Demo

Play Game

Code

The entire game runs in a single HTML file — no frameworks, no build tools, no dependencies beyond a Google Fonts import. Open it in a browser and play.

<!-- Core architecture overview -->

<!--
  STRUCTURE:
  - screen-title   : Opening title + atmospheric intro
  - screen-terminal: Main game (cipher puzzles + Turing Test chat)
  - screen-end     : Final verdict screen

  CIPHER ENGINE:
  - Caesar shift decoding (shifts 3, 7, 13 / ROT13)
  - Flexible answer matching: exact OR keyword-present
  - Hints available on request

  AI LAYER (Chapter 4):
  - Anthropic Claude API (claude-sonnet-4-20250514)
  - System prompt constructs the "machine" persona from Turing's 1950 paper
  - Humanity scoring: emotional language, hesitation, personal pronouns, word count
  - Fallback responses if API is unavailable (game works offline)

  AESTHETIC:
  - CRT phosphor terminal (green on black)
  - Scan lines + screen flicker via CSS animation
  - Wartime document styling: paper texture, red stamp, Courier typeface
  - Share Tech Mono + Special Elite + Courier Prime (Google Fonts)
-->

Github repo

How I Built It

The Design Philosophy

The hardest decision was: what should a Turing game actually feel like?

I didn't want a quiz about his biography. I didn't want a platformer where you jump over Enigma machines. I wanted the player to inhabit the experience — to actually do the things Turing did, and then face the question that consumed the final years of his life.

The result: real ciphers, real history, real AI.

The Cipher Puzzles

Each puzzle uses a cipher Turing's team would have recognised. The three shifts — 3, 7, and 13 — increase in difficulty, and ROT13 (shift 13) is the one that requires you to understand the mirror symmetry of the alphabet. The decoded messages are original text written in Turing's voice, drawing from his published papers and documented thoughts.

The wartime document aesthetic was built entirely in CSS. The paper texture is a CSS repeating-linear-gradient simulating ruled lines. The red stamp is rotated with transform: rotate(12deg). The CRT effect uses layered scan lines, a moving glow, and a subtle screen flicker animation on the body itself.

The Inverted Turing Test

This was the heart of the game and the hardest part to get right.

The standard Turing Test asks: can a machine fool a human into thinking it's human? I wanted to flip it. The machine knows it is a machine. It is not pretending. It is genuinely, analytically curious about what humanity feels like — because its creator, Turing, was fascinated by exactly that question and was persecuted for exhibiting what his society considered the wrong kind of humanity.

The AI persona is built through a carefully constructed system prompt that grounds the machine in June 1954, in Bletchley Park, in Turing's own 1950 paper Computing Machinery and Intelligence. It asks questions that no cipher can answer: What does grief feel like in the body? Why do humans choose poorly when they know the optimal path?

The humanity scoring system is a heuristic that rewards:

Emotional vocabulary (love, fear, grief, joy, loss, hope)
Linguistic imperfection (hesitation words, ellipses, "I'm not sure")
Personal language (I, me, my, we)
Longer, considered answers over short, efficient ones

It is not trying to catch you out. It is trying to understand you. That distinction matters.

The Technical Stack

Single HTML file
├── CSS: CRT aesthetics, document styling, animations
├── JavaScript: Game state, cipher engine, humanity scoring
├── Google Fonts: Share Tech Mono, Special Elite, Courier Prime
└── Anthropic Claude API: The machine intelligence in Chapter 4

No npm. No build step. No backend. Deploy it anywhere.

Best Ode to Alan Turing

This entire game is an ode to Alan Turing, and it tries to honour him in the only way that felt adequate: by making the player do what he did, and then face the question that haunted him.

The ciphers are his methods. The machine is his creation — the AI in Chapter 4 is a direct descendant of the theoretical computer he described in 1936. The inverted Turing Test is his most famous thought experiment, turned inside out.

But beyond the mechanics, the game is an act of historical witness. It is set in June 1954 because that is when his story ended — and when Pride Month begins. That is not coincidence. It is the same fight, across seventy years.

Turing was told that his mind — the most extraordinary analytical mind of the twentieth century — was less important than his sexuality. The British government broke him. The game ends with a machine asking whether you, the player, are human.

The answer the game is really asking: Was he?

He was. Completely, beautifully, irreducibly human. The machine knows it. Now you do too.

Best Google AI Usage — A note on the AI layer

The machine interrogator in Chapter 4 is powered by the Anthropic Claude API (claude-sonnet-4-20250514). The system prompt instructs Claude to embody a machine intelligence derived from Turing's 1950 paper — cold, precise, analytically curious, speaking in short declarative sentences, asking the kinds of questions a mathematician would ask if trying to locate the human soul through logic.

Each response is generated fresh based on your answer, meaning no two playthroughs of Chapter 4 are identical. The machine adapts. It remembers what you said. It builds on it.

This is, in a strange and fitting way, the Turing Test happening in real time — an AI system, trained on human knowledge, asking a human to prove their humanity. Turing imagined this exact scenario in 1950. It is now simply called Tuesday.

A Final Note

Alan Turing received a royal pardon from the British government in 2013 — 59 years after his death. In 2021, his face appeared on the British £50 note.

Too late. Not enough.

But every June, Pride Month asks us to remember that the fight for the right to be fully, freely human is not abstract. It has names. It has faces. It has a man in Wilmslow with a half-eaten apple and three encrypted messages he never expected anyone to find.

This game found them.

Play it. Decode them. Prove you're human.

Play Game

Built for the DEV Community June Solstice Game Jam 2026.
In memory of Alan Mathison Turing, 23 June 1912 – 7 June 1954.

[Boost]

OLALEKAN OGUNDIMU — Fri, 29 May 2026 23:32:22 +0000

GitHub “Finish-Up-A-Thon” Challenge Submission

OLALEKAN OGUNDIMU

May 29

From a 3-Day Deadline Disaster to a Real Product: Reviving My First Full-Stack Project

#devchallenge #githubchallenge

7 min read

From a 3-Day Deadline Disaster to a Real Product: Reviving My First Full-Stack Project

OLALEKAN OGUNDIMU — Fri, 29 May 2026 12:03:41 +0000

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

What I Built

The Course Allocation System is a department-level web portal that lets academic administrators manage lecturers, courses, and timetable allocations — and lets every lecturer log in to view their own assigned schedule.

But this isn't just a project. This is the project that started everything for me.

I began programming seriously in 2024. My first real full-stack challenge was to build something presentable for a school project deadline. I chose a course allocation system because it was a real problem my department had — lecturers not knowing their schedules, admins managing everything manually. I had three days. I built it. It worked just enough to demo and walk away from.

And then I abandoned it.

Not because I didn't care. Because I knew it was broken and I didn't yet know how to fix it properly. It sat in a GitHub repository with exactly three commits — "creataed a course allocation app", "updated the UI", "made changes to the UI" — and a codebase full of problems I could see but couldn't solve at the time.

The GitHub Finish-Up-A-Thon gave me the reason to come back and actually finish it.

Demo

🔗 New repository: https://github.com/sam-the-champ/CA-app
🔗 Old repository: https://github.com/sam-the-champ/course-allocation-app
// Detect dark theme var iframe = document.getElementById('tweet-2060328321150230919-23'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2060328321150230919&theme=dark" }

What the revived app does:

Admin logs in with securely hashed credentials stored in MongoDB
Admin can add lecturers, create courses, and allocate courses to lecturers with day, time, level, and session details
Dashboard shows live stats — total lecturers, total courses, allocated vs unallocated
Lecturers log in and see only their own profile and timetable
Logging out clears the session completely — the browser back button cannot return you into the dashboard
Fully deployed: React frontend on Vercel, Express backend on vercel also.

🔗 Check it Live: https://course-allocation-app2.vercel.app/

The Comeback Story

Let me show you exactly what I came back to.

The Before: Three Commits and a Lot of Problems

Here is the entire commit history of the original project:

Three commits. Built in a rush. Pushed and abandoned.

This was the old admin dashboard:

And the old Add Lecturer page:

And the old lecturer dashboard — the page every lecturer was supposed to log into and see their courses:

The UI was functional enough to demonstrate. But under the hood, it was a completely different story.

Here is the single most embarrassing line in the old codebase:

That URL — https://literate-space-pancake-v9545...app.github.dev — is a GitHub Codespace URL. It was my live development environment URL, hardcoded directly into the frontend JavaScript. The moment I closed that Codespace, every single API call in the application broke. The app only ever worked on my machine, during that one session, on the day I built it.

This was not the only problem. Here is the full list of what I found when I came back:

Architecture:

The entire frontend — HTML, CSS, and JavaScript files — lived inside the backend folder. One tangled directory for everything
The controllers/ folder existed but was completely empty. Every piece of business logic was stuffed directly into the route files
The Allocation model existed as a Mongoose schema but was never used anywhere. Allocations were embedded as arrays inside the Lecturer document

Security:

Admin credentials were hardcoded as plain text directly in authRoutes.js: username: 'admin', password: 'admin123'
Lecturer login did not issue a JWT token. It just returned the lecturer's raw ID string and called it a token
authMiddleware existed in the codebase but was applied to exactly zero routes — every endpoint was completely unprotected

Broken logic:

models/Admin.js exported mongoose.models.Admin instead of registering a model — meaning it exported undefined. Admin authentication could never work with the database
The phone field was saved as phone in routes but defined as phonenumber in the schema — phone numbers were silently dropped on every single save
The admin dashboard's course counter always returned undefined because of a nested array traversal bug
Logout was defined as POST on the server but called as GET from the frontend

This is what a first project built under deadline pressure looks like. It's not pretty. But it's honest.

The After: A Real Application

This is the new lecturer dashboard:

And the new admin dashboard:

Same page. Same purpose. Completely rebuilt.

Here is everything that changed:

✅ Fully separated frontend (/frontend — React + Vite) and backend (/backend — Express) into independent deployable projects

✅ All business logic moved into proper controllers — authController, adminController, lecturerController — routes are now thin URL-to-function maps

✅ Fixed Admin.js model — it now correctly registers with mongoose.model('Admin', adminSchema) instead of exporting undefined

✅ Admin credentials stored in MongoDB, password hashed with bcrypt, created via a one-time npm run seed script — no credentials anywhere in source code

✅ Real JWT authentication for both admin and lecturer login, with protect, adminOnly, and lecturerOnly middleware applied to every protected route

✅ Allocation promoted to a proper first-class MongoDB collection with a compound unique index — no more embedded arrays

✅ All API calls centralised in a single src/api/index.js file using axios — base URL from environment variables — no hardcoded URLs anywhere in the application

✅ React frontend with React Router v6, AuthContext for shared authentication state, and <Navigate replace /> on logout so the back button cannot re-enter a protected route

✅ Unified field naming — phoneNumber consistent across model, controller, and frontend

✅ Global error handler middleware — consistent error response shape across every endpoint

✅ Backend deployed on Render, frontend deployed on Vercel

The before and after is not subtle. This went from something that only worked during one Codespace session to something I can actually hand to a department and say: use this.

My Experience with GitHub Copilot

Copilot was involved at every stage of this revival, and there were two moments where it genuinely changed what I was able to do.

Moment 1: The Codebase Audit

Before I wrote a single line of new code, I pasted the old route files into Copilot and asked it to identify weaknesses, inconsistencies, and broken logic. It found the hardcoded credentials, the unused middleware, the field name mismatch between phone and phonenumber, and the broken dashboard counter. Seeing the problems written out as a structured list — not buried in messy code — made the scope of the work clear and gave me a real roadmap. That audit became the plan.

Moment 2: The Vercel Seed Problem

This is the Copilot moment I will remember most. When I deployed the backend to Vercel, I realised I had no way to run npm run seed to create the admin account — because unlike Render, Vercel doesn't provide a persistent shell environment.

I described the exact problem to Copilot:

Copilot read my repository structure, confirmed it had found my seed.js file, explained exactly why the problem was happening, and then gave me two concrete solutions — convert the seed into a one-time API endpoint, or switch to a platform with shell access like Render.

It even gave me the exact code for the seed route and told me how to register it in server.js. Without this, admin login on the deployed version would have been impossible and I would have been stuck for hours trying to figure out why.

Day-to-Day Usage

Beyond those two moments, Copilot was my constant pair programmer throughout the rebuild:

When I was working on the LoginPage.jsx mobile view, I could describe what I needed in plain English and Copilot would generate the layout logic. When I was wiring up the React Router protected routes, it helped me get the <Navigate replace /> pattern right on the first try — which is what makes the logout-then-back-button behaviour work correctly.

The way I used Copilot was not "write this for me." It was more like having a senior developer sitting next to me who knew the codebase as well as I did and could answer "what's wrong here?" or "how do I do this properly?" in seconds instead of hours of searching.

What This Project Means

I started programming in 2024. This was my first full-stack project. It was messy, it was rushed, and I walked away from it feeling like I had failed at something I genuinely wanted to build.

Coming back to it — not just to touch it up but to understand every flaw and fix every single one — is the most I have learned in a single sprint since I started coding. I understand authentication flows, REST architecture, React state management, and deployment pipelines at a level I simply did not before.

And now there is actually a real application at the end of it. One that works. One I am proud of. One that my department could use.

That is what finishing things does.

Built with Node.js, Express, MongoDB, React, Vite, and GitHub Copilot.
Frontend: Vercel | Backend: Vercel

Solace: A Global Mental Health First Responder Built with Gemma 4

OLALEKAN OGUNDIMU — Fri, 22 May 2026 11:09:12 +0000

The Problem Nobody Talks About

970 million people worldwide live with mental health disorders.

But almost every mental health tool built with AI assumes the same user: fast internet, English as a first language, a US or UK phone number to call in a crisis.

That's not 970 million people. That's maybe 50 million.

I'm a developer based in Lagos, Nigeria. When I looked at the mental health AI tools being built, I kept asking the same question: what happens when someone in Accra, Nairobi, Manila, or São Paulo needs help at 2am?

They get a chatbot that tells them to call 988.

That's the gap Solace was built to close.

What is Solace?

Solace is a voice-first, privacy-focused mental health companion powered by Gemma 4. It listens, assesses, and connects people to real help — wherever they are in the world.

🔗 Live app: https://slcai-sm9m.vercel.app/

💻 GitHub: https://github.com/sam-the-champ/SLCAI

Demo Video:

What makes Solace different

1. 🌍 Localized crisis resources for 13+ countries

Most mental health AI tools are built with US resources baked in. If you're not American, you're on your own.

Solace auto-detects your country from your browser timezone and immediately surfaces the right crisis lines, text lines, and chat services for Nigeria, Ghana, Kenya, South Africa, Zimbabwe, India, UK, USA, Canada, Australia, Philippines, Singapore, Brazil — and falls back to international resources for everywhere else.

No settings. No configuration. It just knows.

export function getResourcesByTimezone(): CountryResources {
  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone
  const tzToCountry: Record<string, string> = {
    'Africa/Lagos': 'NG',
    'Africa/Accra': 'GH',
    'Africa/Nairobi': 'KE',
    // ...13+ countries
  }
  const code = tzToCountry[tz]
  return resourcesByCountry[code] ?? resourcesByCountry.DEFAULT
}

2. 🎤 Voice-first input

When someone is in distress, typing is a barrier. Solace has a one-tap voice input powered by the Web Speech API — speak your feelings, Solace listens.

No third-party API. No extra cost. Works in the browser natively.

const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition
recognition.continuous = true
recognition.interimResults = true

3. 🧠 Trauma-informed triage with Gemma 4

Every message is assessed across four triage levels: Low → Moderate → High → Crisis.

Gemma 4's 128K context window and deep instruction-following made it the right model for this. The system prompt is carefully crafted to avoid clinical coldness while still being precise enough to catch crisis signals:

// Triage levels:
// low: mild everyday stress, general worry
// moderate: persistent sadness, sleep issues, social withdrawal  
// high: panic attacks, trauma symptoms, major crisis
// crisis: suicidal ideation, self-harm, immediate danger

At crisis level, the entire UI shifts — emergency resources move to the top, the call button becomes prominent, and the AI's tone changes to prioritize connection to real help over conversation.

4. 📔 Private mood journal

Every check-in is saved to a local mood journal — stored entirely in localStorage. No server. No account. No data leaving the device.

Users can track patterns across sessions: when they tend to feel worse, whether things are improving, what their check-ins look like over time.

5. 📱 Installable PWA

Solace is a Progressive Web App. On mobile, users can install it directly to their home screen — no app store, no download, works in low-bandwidth conditions.

This matters enormously in markets like Nigeria where data costs are high and storage is limited. A 2MB installable app beats a 200MB download every time.

Why Gemma 4 specifically?

This is the question that matters most, so let me be direct.

I chose Gemma 4 31B because:

1. The 128K context window means Solace can hold a full therapeutic conversation — not just one or two turns. Mental health support isn't transactional. People circle back. They contradict themselves. They need to feel heard across a long exchange.

2. Instruction-following precision — the triage system depends on Gemma 4 returning structured JSON reliably, with emotional nuance baked into the summary, patterns, strategies, and affirmation fields. I tested with smaller models. The quality gap was significant.

3. It's open. Gemma 4 can be self-hosted. That means a clinic in Lagos or a NGO in Nairobi could eventually run this on their own infrastructure, with no API costs and full data sovereignty. That's a future worth building toward.

4. Privacy story. Every conversation stays between the user and the model. Solace doesn't log, store, or transmit conversation data. For mental health, that's not a feature — it's a requirement.

Technical Stack

Frontend: React + Vite + TypeScript
Styling: CSS custom properties, glassmorphism UI, no component library
AI: Gemma 4 31B via OpenRouter
Voice: Web Speech API (native browser)
Storage: localStorage (journal, no server)
PWA: Web App Manifest + service worker ready
Deploy: Vercel

The hardest part

Building the crisis response flow was the hardest and most important part of this project.

When Gemma 4 returns triageLevel: "crisis", everything changes. The UI shifts to red. The emergency number for the user's country moves above the fold. The AI's system prompt switches to a mode focused entirely on staying present and bridging to real help — not providing therapy.

Getting that balance right — compassionate but not clinical, urgent but not alarming — took more iteration than anything else in the codebase.

What's next

Offline-first fallback responses — cached grounding techniques that work with no internet
More languages — French, Hausa, Swahili, Portuguese
More countries — currently 13, targeting 30+
NGO partnership mode — white-label for mental health organizations

Try it

🔗 https://slcai-sm9m.vercel.app/

Open it on your phone. Tap a mood. Speak how you're feeling. See what country resources appear for you.

If you're building in the mental health space or you work with communities that are underserved by current AI tools — I'd love to hear from you in the comments.

Solace is an AI companion, not a therapist or medical service. If you are in crisis, please contact your local emergency services.