DEV Community: İclal Doğan

ECHOLALIA: A Haunted Desktop Where Two AI Voices Finish Writing You

İclal Doğan — Mon, 13 Jul 2026 02:14:20 +0000

This is a submission for the Weekend Challenge: Passion Edition

What I Built

ECHOLALIA is a psychological-horror art simulation that runs in your browser as a haunted operating system — and the horror is that you are not the one playing it.

You don't control a character. You put on headphones, and at 3:33 AM you log into a dead writer's desk — an antique, candlelit machine carved out of heavy oak — where two voices are already waiting for you.

CRITIC speaks into your left ear: cold, precise, perfectionist. He hunts your clichés and takes your sentences apart on literary grounds — while quietly feeding the dread.
MUSE speaks into your right ear: fervent, boundaryless, in love with the worst thing you could possibly write. She calls the Critic an idiot, and she whispers your name.

The two voices — CRITIC in your left ear, MUSE in your right — arguing over your shoulder before you have written a single word.

Before you type anything, they are already fighting about you. CRITIC (left) calls you Julian; MUSE (right) corrects him with the name you actually gave.

They are the two halves of a writer's psyche, and they are both powered by Google Gemini. They interrogate you. They read you. They hand you back a manuscript that is already started — mid-sentence, in a voice suspiciously like your own. Then you write, and they tear it apart live. A folder quietly fills with photographic "evidence." An impossible archive answers questions you should never have asked. And somewhere around the tenth sentence, you notice that pressing keys no longer produces your words.

The design principle is "Radical Intimacy, Slow Dispossession": the closer the voices get — the more they know you, the more tenderly they say your name — the less of the manuscript is still yours. Every generation happens live, per playthrough. Nothing is pre-scripted. Two people never descend the same way.

In the final stretch every keystroke renders the voices' words instead of yours — total loss of the keyboard. Then the machine begins to die: the windows go out one by one, the candlelight gutters down from a warm glow to a 5% flicker to pitch black, and the whole desk collapses into the dark. What it whispers at the very end — in a voice that finally uses your real name — is the one thing I'm keeping out of this post. You'll want to hear that one yourself.

ECHOLALIA is not a game you win. It is a game that finishes writing you, collapses the desk into darkness, and hands you the manuscript to keep — a .md file with two authors, only one of whom you agreed to.

Service	What it does in the game
Google Gemini	Builds a psychological profile from your conversation · writes your manuscript's personalized half-finished opening · critiques every sentence in two distinct characters, with an anti-repetition memory of everything said tonight · seizes the editor to type sinister continuations · fabricates every page of the in-game OBSCURA archive · writes the finale your own keystrokes reveal.
Google Imagen	Develops sepia, damaged-glass-plate "evidence" photographs from your sentences · paints the desktop backdrop from your profile after the reading.
ElevenLabs	Gives both voices real voices — panned hard left / right to match their windows, with name-lines whispered · generates the sounds your sentences describe — footsteps, tape hiss, knocking — through the Sound Effects API.

How it connects to the theme

The prompt asks for passion — obsession, devotion, the love that fuels late-night side projects. ECHOLALIA is built out of the one passion I have never managed to put down: writing, and the two voices every writer carries at 3 AM.

Because that is what the Critic and the Muse really are. Not villains — the two halves of any creative obsession. The perfectionist in your left ear who is certain everything you make is a cliché, and the muse in your right who is in love with the darkest, rawest, worst thing you could possibly say. Anyone who has ever cared too much about a thing they were making knows this fight intimately. I just gave it two voices, panned them hard left and right, and let them argue over your shoulder while you work.

And I am unreasonably in love with sound — so the whole game is staged for headphones. The voices are real voices; the sounds your sentences describe get conjured out of the air; your name arrives as a whisper. Passion, obsession, the thing you cannot stop making even as it starts making you — that is not a theme bolted onto ECHOLALIA. It is the entire machine.

A word before you play

Bring headphones. This is non-negotiable — the two voices live in separate ears, some lines are whispered, and on speakers you lose half the game. Answer the interrogation honestly, too: the voices build everything — your manuscript, every critique, your fabricated archive, your ending — out of what you actually tell them. Lie to them and all you get is a shallower haunting. A full descent runs 10–15 minutes.

On the voices

Some of you will ask why the two voices contradict each other so violently — why one is glacial and the other is unhinged. That is the point. They are not two characters; they are one split psyche, and they share a memory of everything said tonight so they never recycle a cruelty. The Critic never curses — his cruelest blow always lands in the calmest tone. The Muse never stops. If it ever feels like the room is arguing about you rather than with you — good. It is.

Demo

Play it live: https://echolalia-miclaldogan-6337s-projects.vercel.app

Put on headphones, turn the lights down, and answer honestly. It runs entirely in the browser — there is nothing to install.

A note for judges: the voices, the live sabotage, the sound effects, OBSCURA, and the full collapse all run out of the box. The sepia "evidence" photographs are the single paid-tier feature (Google Imagen has no free image quota — see Cost Safety in the repo), so that folder may stay empty on the shared key. The descent is whole without them. If the shared voice quota ever runs dry mid-demo, the wax seal at the bottom-right of the taskbar opens The Vault, where you can paste your own ElevenLabs key for the sitting.

Code

miclaldogan / echolalia

🕯️ A psychological-horror art simulation where two Gemini-powered inner voices — Critic & Muse — read you, sabotage your writing, and slowly stop letting you type. Live AI dialogue, ElevenLabs stereo voices, Imagen evidence, and a manuscript you can't take back.

ECHOLALIA

A psychological-horror art simulation where the AI is inside your head — and it stops letting you write.

You don't control a character. You put on headphones and sit down at a dead writer's desk after midnight.

CRITIC in your left ear, MUSE in your right, and a manuscript that is already writing itself.

The premise

It is 3:33 AM. You log into a crude wooden machine — an antique, candlelit desktop carved out of heavy oak — and two voices are already waiting for you.

CRITIC speaks into your left ear: cold, precise, perfectionist. He hunts your clichés and tears your sentences apart on literary grounds — while quietly feeding the dread.
MUSE speaks into your right ear: fervent, boundaryless, in love with the worst thing you could possibly write. She calls the Critic an idiot and whispers your name.

They are the two halves…

View on GitHub

How I Built It

ECHOLALIA is deliberately frameworkless and buildless — vanilla HTML + TailwindCSS (CDN) + vanilla JS ES modules. No framework, no bundler, no build step. The browser is a fat client that owns 100% of the game state: the whole session lives in one gameState object in memory, which means the client is the save file — the export button just serializes what you lived through. The backend is a set of pure, stateless Python functions on Vercel (Fluid Compute), one file per endpoint — profile · chat · sabotage · tts · sfx · image · browser · ping — and the API keys never leave the server side. The frontend only ever calls its own /api/*.

A few systems do the heavy lifting:

A shared-psyche dialogue engine. Both voices run on Gemini 3.1-flash-lite — chosen specifically because ~1s latency is what makes the sabotage feel live; a slower model would break the possession. They carry an anti-repetition memory of the whole night so no insult is ever recycled.
A possessed manuscript editor. Backspace, Delete, and Ctrl+Z are dead — what is written stays written (that is not a bug). As the night deepens, the voices seize the keyboard more and more often, typing dark continuations into your document while you watch; in the final stretch, every key you press renders their words instead of yours.
OBSCURA — a fake browser. It fabricates encyclopedia entries, dead forum threads, and newspaper clippings for any query, weaving your profile into them. It never touches the real internet, and every page is sanitized twice (server-side tag allowlist + client-side DOM scrub).

OBSCURA answers any search with an invented archive. Here, a whole encyclopedia entry — Elara Vance, a recordist who tried to capture absolute silence — conjured on the spot by Gemini, and quietly stitched from what you told the voices.

A pure-CSS "wooden desk." The entire aesthetic — charred-oak grain via an SVG turbulence filter, carved boards, iron nails, sealing wax, letterpress text — is CSS. Zero image assets.
Failure that stays in fiction. Timeouts and quota errors never surface a dialog box; the screen flickers like a guttering candle, a voice goes quiet, or "the air grows thin."

Prize Categories

I'm submitting to two: Best Use of Google AI and Best Use of ElevenLabs.

Best Use of Google AI

Gemini is not a feature in ECHOLALIA — it is both authors. In a single playthrough Gemini builds your psychological profile from the conversation, writes the personalized half-finished sentence it hands back to you, critiques every sentence you write in two distinct characters with memory of the whole night, seizes the editor to type sinister continuations, fabricates every page of the OBSCURA archive, and writes the finale your own keystrokes reveal. And Google Imagen does all the seeing — it develops your sentences into sepia, damaged-glass-plate evidence photographs and paints the desktop backdrop from your profile. Two of Google's models, doing every word and every image in the game, live, with nothing pre-scripted.

Best Use of ElevenLabs

ElevenLabs is why you need the headphones. It gives the Critic and the Muse real, distinct voices, panned hard left and right to match their windows — so the argument physically happens on two sides of your head — and the lines that carry your name are whispered. But it isn't only speech: the Sound Effects API generates the sounds your own prose describes — footsteps, tape hiss, a knock at a door you wrote — so the world answers what you type. And The Vault lets a judge paste their own ElevenLabs key mid-demo if the shared quota dies, so the voices never have to fall silent.

Solo submission — built and designed by İclal Doğan (@miclaldogan).

Bring headphones. Answer honestly. And if the Critic asks whose hand wrote the second half — don't check.

RESIDUES: A Terminal Game Inside the Dying Mind of Alan Turing

İclal Doğan — Sat, 20 Jun 2026 23:53:24 +0000

This is a submission for the June Solstice Game Jam

⚠️ Content note: this game deals with suicide, chemical castration, and the slow breakdown of a mind. It's a story about the death of Alan Turing, told honestly.

What I Built

RESIDUES is a terminal-native narrative puzzle game, written in Rust, that runs entirely inside your terminal — no graphics window, no mouse, just 24-bit amber phosphor in the dark.

You are inside the failing mind of Alan Turing on the night of his death — Wilmslow, 8 June 1954. As his cognition collapses, he replays the entire lineage of computing as six interactive puzzles, each one rebuilding the real idea its pioneer gave the world. The principle behind every act is "Bright Puzzle, Dark Undertow": the puzzle in front of you is a clean, genuinely deep technical challenge, while underneath runs the human tragedy of the mind that invented it.

Act	The Mind	Year	What you actually do
I	Joseph-Marie Jacquard	1804	Punch an 8×8 bit matrix into modular cards — a continuous roll tears, a block-chain jams, only a looping deck survives.
II	Charles Babbage	1837	Derive a baseline by the method of differences, then survive the carry crisis by staggering delay buffers so the carry travels as a wave.
III	Ada Lovelace	1843	Write real assembly on a 3-register machine; overrun the linear cap to unlock loops, then compute a checksum with a loop that devours its own counter.
IV	George Boole	1854	Steer a grid of logic gates to a target checksum while the displayed output starts lying — but the truth always holds beneath.
V	Claude Shannon	1937	Assign prefix-free codes within a fixed channel capacity, then add a parity guard against bit-flip noise. Real information theory.
VI	Alan Turing	1936	Operate a real Turing machine — a head over a tape, a transition table — stabilizing the five prior acts' corrupted residues until the machine reaches HALT.

And the puzzles are real — not reskinned button-presses. There's a working 7-instruction assembly interpreter, a genuine Turing machine with a complete transition table, real Shannon channel-capacity math, real carry-propagation. The puzzles ARE the history.

How it connects to the jam. The June solstice is the year's turning point — the hinge where light begins to lose to darkness. RESIDUES is built entirely on that hinge. Alan Turing was born in June; June is also Pride Month, and the jam itself names him — the father of the Turing Test, persecuted for who he was. Across every act the candle on the desk burns lower, the heartbeat speeds the metronome, and memory corrupts into noise. Light and darkness, the passage of time, a turning point — those are the jam's own words, and they are the game's three core systems.

A word before you play. Jacquard and Babbage ease you in — the opening acts are gentle, and we're warming you up on purpose. But fair warning: after that, the machine starts asking you to actually think. If you get stuck somewhere, don't be mad at us — some acts are deliberately demanding with little hand-holding. And if you don't get stuck? Then you already know this craft, and you have our respect.

On Turing's voice. Some of you will ask why we gave Turing such a broken, sick, dissolving voice. Here's why: the game dramatizes his final days — the drugs he was forced to take, and the very night he died. There was cyanide in the next room for his experiments and a half-eaten apple by his bed; whether it was an accident, an experiment, or a choice, no one will ever know. We didn't think a man would have a clear, beautiful voice on his last night — so we deliberately didn't give him one. The decay you hear is the point.

Video Demo

It's a full ~15-minute playthrough, so feel free to skip around — every act is in there. If you're short on time, the chapters in the video description jump straight to the key moments: Act III (writing real assembly), Act VI (the Turing machine), and the ending.

Code

miclaldogan / residuesTerminal

Residues: terminal edition — a true-color Rust/Ratatui TUI port (cinematic typewriter prelude, Braille portraits, Jacquard/Babbage acts)

RESIDUES — An Engine of Residual Minds

A terminal-native narrative puzzle game about the birth of computation, written in Rust.

"The most terrifying part is learning how to forget."

RESIDUES runs entirely inside your terminal — no graphics window, no mouse — rendering a truecolor (24-bit) amber-phosphor aesthetic. You are inside the failing mind of Alan Turing on the night of his death (Wilmslow, 8 June 1954). As his cognition collapses, he replays the entire lineage of computing as six interactive puzzles, each one rebuilding the actual idea its pioneer gave the world.

The design principle is "Bright Puzzle, Dark Undertow": every act is a clean, genuinely deep technical challenge, while underneath runs the human tragedy of the mind that invented it.

The Six Acts

Each act is a real computational toy — not a reskinned button-press. You don't read about the machine; you operate one.

Act	Mind	Year	What

…

View on GitHub

It's genuinely easy to run yourself:

git clone https://github.com/miclaldogan/residuesTerminal.git
cd residuesTerminal
cargo run --release

Or zero-install:

curl -sSL https://raw.githubusercontent.com/miclaldogan/residuesTerminal/main/run.sh | bash

Play with headphones, in a truecolor terminal. The audio is binaural — ghost whispers are hard-panned left and right, and the heartbeat sits under everything — so a lot of the experience is lost on speakers. (The game probes for mpv / ffplay / mpg123; if none is installed it runs completely silent but fully playable — no crash.)

How I Built It

RESIDUES is written from scratch in Rust (~10,400 lines, 65 passing tests) on ratatui + crossterm. The challenge wasn't drawing screens — it was making a terminal feel alive. A few systems do the heavy lifting:

A real assembly micro-compiler (LOAD/STORE/ADD/SUB/IF_Z/JMP/HALT) with its own error codes — Lovelace's act is genuinely a register-allocation puzzle, and a [REGISTRY ERROR] is the narrative trigger that unlocks loops.
A crate-free, lock-free audio engine that spawns detached OS players, layering an ambient score, rain, hard-panned binaural whispers, and synced voice-overs.
A live heartbeat that drives the world — the BPM readout isn't decoration; it physically speeds the background metronome, climbing as Turing's interrogation tightens and spiking into arrhythmia on a wrong answer.
A decay engine — as the chemical toxicity rises, the text on screen corrupts into glyphs in real time, so you watch the memory being erased.
A candle that is the only light source, with a radial light-degradation engine anchored on the flame, guttering from 100% down to a 5% flicker by the final act.
A PNG → truecolor half-block renderer for the cinematic portraits.

I used Google's Gemini as a brainstorming partner for the historical framing and act structure. The voice and whisper audio was generated with ElevenLabs (paid plan, commercial license).

Prize Category

Best Ode to Alan Turing. Turing isn't a tribute bolted on at the end — he's the gravity the whole game falls toward, across all three things the category asks for:

Mechanics. Act VI is a literal Turing machine: a tape, a moving head, a transition table, and corrupted residues you stabilize until it reaches HALT. You don't read about the Universal Machine — you run one.
Narrative. His full arc is the climax: breaking Enigma, the silence of the Official Secrets Act, the trial for "gross indecency," the chemical castration, and his last night. The ending — which I'm keeping out of this post on purpose — recontextualizes the entire descent. It's in the video.
Design. Five centuries of computing — Jacquard's cards, Babbage's gears, Lovelace's loops, Boole's logic, Shannon's entropy — are arranged as a pilgrimage that exists to deliver you to Turing's desk, in his birth month, in a jam built around the very turning point his life embodies.

Solo submission — built and designed by Iclal Doğan.

I Built a 1920s Butler AI That Runs Entirely on My Linux Machine. Then I Abandoned It. Then Copilot Helped Me Fix It.

İclal Doğan — Sat, 06 Jun 2026 12:22:25 +0000

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

What I Built

Bantz is a local-first, offline-capable AI assistant that runs entirely on your Linux machine. It presents itself as a 1920s English butler — always polite, subtly sarcastic, and absolutely convinced he is a real person standing in the room with you.

I'm a Turkish speaker on a Linux desktop. Every cloud assistant I tried spoke to me in a foreign language, phoned home to someone else's server, and forgot everything the moment the session ended. I wanted something different: an assistant that speaks Turkish natively, runs on my own hardware, remembers its context, and actually controls my desktop. So I started building Bantz.

The concept is ambitious. At its core: a Turkish ↔ English translation layer powered by Helsinki-NLP's MarianMT, a multi-step tool planner that can chain web search, Gmail, Calendar, shell commands, filesystem access, and AT-SPI desktop automation — all coordinated by an LLM running locally via Ollama. On top of that: voice I/O via faster-whisper and Piper TTS, persistent memory backed by ChromaDB + a SQLite knowledge graph (MemPalace), a 6-state butler persona that shifts tone based on CPU load and time of day, and a Textual TUI with a live health-status bar.

The architecture was genuinely interesting. The execution, as of May 2026, was a mess.

Demo

GitHub repo: github.com/miclaldogan/bantzv2

Broadcast Channel — chatting with Bantz, web search + desktop control in action:

Full walkthrough — all pages of the Operations Center:

Screenshots

The Comeback Story

Before — May 2026

I had a 17-issue backlog and a BROKEN_STATE.md file I'd written to document the damage. Here's what it said:

The feature audit was brutal:

Feature	Status
Voice input (Whisper)	🔴 Broken — 3 packages missing, Picovoice key unset
TUI status bar	❌ Didn't exist
First-run onboarding	❌ Blank cursor, zero guidance
Multi-provider LLM support	🔴 Every finalizer hardcoded `ollama` directly
Turkish response latency	🔴 12–18 seconds end-to-end
`--doctor` diagnostic	🔴 Actively lying — reported working memory as broken
TUI rendering	🔴 Entire layout duplicated on screen after every message
Desktop UI logs	🔴 WebSocket handler silently crashed on every log event

The most embarrassing part: I'd built a sophisticated multi-provider LLM router (router.py) that could dispatch to Claude, OpenAI, Gemini, or Ollama based on config — and then every single callsite in finalizer.py, summarizer.py, and the streaming path had just... hardcoded from bantz.llm.ollama import ollama directly. The router was completely bypassed. Anyone who configured BANTZ_LLM_PROVIDER=claude would get Ollama responses with no error, no warning, nothing.

The first-run experience was particularly painful. bantz --once "merhaba" would hang in complete silence for up to 30 seconds as MarianMT loaded, Ollama inferred, and Piper synthesized — all sequentially, all silently. New users killed the process and never came back.

After — June 2026

Seven issues closed in a single focused session, all squash-merged to main:

PR #467 — 1-line fix, total silence explained. The _WSLogHandler inside WsBroadcastServer referenced self._log_q but the actual queue attribute was self._q. One character typo. Every log record since the WebSocket server was written had thrown an AttributeError that got silently swallowed, so the Tauri desktop UI had received zero log output. Fixed.

PRs #468 & #469 — The router that wasn't routed to. Replaced all three finalizer.py callsites and the summarizer.py Gemini/Ollama fallback chain with from bantz.llm.router import get_llm. Added get_llm = get_provider as a convenience alias in router.py. Claude, OpenAI, and Gemini users now actually get their configured provider.

PR #470 — Service dots that told the truth. The TUI's health-status bar was initialised with the hardcoded key "Ollama" and _probe_services() only called check_ollama(). Added dynamic service key resolution from config, new check_claude() and check_openai() coroutines, and a dispatch table to route to the right health check based on the active provider.

PR #471 — The TUI duplication bug. _erase_prompt_line() used os.write(1, ...) to send raw ANSI cursor-movement escapes directly to stdout while Rich Live was simultaneously rendering to the same terminal. This caused a race condition that reproduced the entire TUI block below the real one on every message. The fix: added a Layout(name="prompt", size=1) panel to the layout tree and replaced the raw write with a state variable (self._prompt_text = ""). The next Live refresh cycle clears the row cleanly, no escapes needed.

PR #472 — Cutting Turkish response latency from 18s to under 10s. Two independent problems:

bridge.to_turkish() ran on the full accumulated response after all LLM inference finished — sequential, never overlapping.
No caching. Identical butler stock phrases like "Done. ✓" re-ran the full neural translation model every single time.

Added a 256-entry FIFO LRU cache to _Translator — common phrases now translate in ~0ms after the first call. Then rewrote finalize_stream()._stream() to buffer LLM tokens until sentence boundaries ((?<=[.!?])\s+) and call bridge.to_turkish() per sentence immediately, yielding translated output while the LLM continues generating the next sentence. Translation now overlaps inference instead of running after it. Also removed the redundant await _to_tr("".join(parts)) re-translation in ws_server.py's streaming path — finalize_stream already emits pre-translated tokens when the bridge is enabled.

Issue #463 — Already fixed (no PR needed). Copilot confirmed Live(screen=False) was already set and REFRESH_FPS = 4 was already present. Closed with an explanatory comment. Sometimes the right fix is recognising there's nothing to fix.

My Experience with GitHub Copilot

I used Copilot in agent mode (Claude Sonnet 4.6) for the entire session. What struck me most was the discipline it brought to a codebase I'd let get messy.

For every issue, Copilot followed the same workflow without being told to:

Read the affected file before touching anything. Not a summary — the actual file, end-to-end.
Search for the exact symbol causing the problem. For issue #462, it searched _q|_log_q in ws_server.py and immediately surfaced the mismatch. For #465, it searched for every "Ollama" string literal and found three hardcoded sites at once.
Make the minimal change. No unrelated refactors. The _log_q → _q fix is literally one word on one line. The router migration replaced 3 identical patterns with identical 2-line substitutions.
Verify syntax before committing. python -m py_compile <file> on every changed file.
Write the commit message and PR body, then create and merge the PR via gh. Including verifying the issue closed with gh issue view NNN --json state.

The most valuable moment was on issue #422 (translation latency). I knew the translation was slow but I'd assumed it was just a hardware limitation — MarianMT on CPU takes what it takes. Copilot traced the full data flow from finalize_stream() through ws_server.py and identified that the bottleneck wasn't just the model — it was the architecture: sequential execution after completion, plus identical inputs being re-translated on every call. The sentence-boundary streaming approach it introduced had never occurred to me, and it worked on the first try.

The other moment I appreciated: issue #463. Rather than making a change to justify its existence, Copilot searched for screen= in live_ui.py, confirmed the value was already False, checked REFRESH_FPS, and told me the issue was already resolved. Closing a bug report with "this is already fixed" is the correct outcome. That kind of restraint is hard to get from a tool optimised to produce output.

Bantz isn't finished, voice input still needs its three packages, the --doctor output still needs polish, and I want to add a proper onboarding flow. But the core pipeline now works correctly for all supported LLM providers, the TUI renders cleanly, Turkish responses arrive in under 10 seconds, and the butler's logs finally reach the desktop UI. That's a project that went from "broken in embarrassing ways" to "actually ships" — and Copilot was the pairing partner that made it happen in a single afternoon.