How the kitchen ran. Who got to change the menu. What happened when you proposed something, and what happened when someone else proposed the exact same thing without asking.

Play it here.

Why a receipt #

The whole game is one long receipt printing out of a thermal printer. You tap, the next line prints. There are choices sometimes.¹

Receipts are also just a really good format for this kind of story. They don't have opinions. They record transactions: what was given, what was received, how long it took, what it cost. The gap between the numbers on a receipt and the experience they represent is where the whole game lives.

The printer #

I wanted it to feel like a physical thing, not a web page with text on it. There's a CSS thermal printer at the bottom of your screen with a slot, a status light, and a little model number.² Paper feeds upward as you tap, with that jerky steps() CSS timing that thermal paper actually has. The sound is Web Audio API, a bandpass-filtered noise burst for the print head and a low-frequency rumble for the paper feed, both synthesized on the fly so there's no audio file to load.

When you open the game, the screen is empty. Just the printer sitting at the bottom in a dark void. Then only a small strip of paper appears. It grows as you tap, and when there's more paper than screen, it starts scrolling. Lines print one by one within each section, and if you get impatient you can tap again to skip to the end of the current block.³

I won't spoil what happens at the end, but the printer does something different. You'll know when it's over.

What I won't say #

If you've worked somewhere like this, you'll recognize it. If you haven't, maybe you'll understand something about what it's like, and consider yourself lucky.

The numbers at the end are real, by the way. All of them.⁴

Play Thank You For Your Service

You build the right thing. It gets validated. Then it gets overridden. Nobody disagrees with the technical argument, but accepting it costs more right now than ignoring it. Ignoring it costs more later, but later is someone else's problem.

I've watched this happen at every company I've worked at. Different teams, different bosses, different cultures, same pattern. The standard advice is always "communicate better, get buy-in, frame it differently." I've tried, and the outcomes don't change, because the problem isn't communication. It's structural.

Here are the mechanisms.

Comfort Over Correctness #

Fixing things creates disruption. Not fixing things is invisible until it breaks. Organizations pick invisible.

A code quality tool that tracks whether issues are accumulating or shrinking. One number, never measured before. It doesn't change rules or add warnings, just makes the existing count visible. One extra command when the count changes.

The person who admits they don't look at warnings votes against the tool.¹ It gets removed before the trial period starts. The warnings keep accumulating, nobody notices, because nobody was looking. That was the problem the tool solved.

The cost of a small disruption is immediate and obvious. The cost of not fixing things shows up months later as a bug, an outage, a pattern nobody can trace back to any one decision. Every individual choice to go with comfort is defensible. The accumulated result is nobody's fault specifically. It just happens.

Correctness wins when the cost of ignoring it becomes impossible to miss: an outage, a customer complaint, data loss. Until then, comfort wins every time. The person trying to prevent the outage is "adding process." The outage itself is "unexpected."²

When someone asks for your input before building ("does this approach seem reasonable?"), the same technical expertise that creates friction elsewhere becomes an asset. Compromises happen. Ideas improve. The difference isn't the people. It's the direction: being asked to evaluate vs. presenting something already built. One is collaboration. The other triggers the comfort reflex.

Consensus As Veto #

Improvement often requires buy-in from the people whose behavior would change. They vote against the change. The process designed to be fair becomes a wall.

The person who introduced the workaround votes against the clean solution. The person who doesn't follow quality standards votes against the tool that makes violations visible. They're protecting their current workflow, which makes sense for them individually. But improvement can't happen through consensus when the consensus group includes the people who'd have to improve.

"Discuss before shipping" sounds reasonable. In practice, when you're discussing with people who resist the category of change you're proposing, the outcome is predetermined. The discussion isn't evaluation, it's a veto dressed as process.³

You notice this when the standard is applied selectively. The same people who required pre-approval for your small tooling change ship their own changes without discussion. The rule exists to slow down the unfamiliar, not to govern change in general.

When I had full autonomy over a project, it grew for years and got industry recognition. My idea, my execution, no approval chain, same person, same skills. The thing that makes me effective is the thing consensus processes kill: acting on technical judgment without waiting for permission from people who don't share it.

Responsibility Without Authority #

You're the person who understands the systems. When something breaks at night, you fix it. When an architectural decision needs making, your judgment is what the team relies on. But formally, your judgment carries no more weight than anyone else's vote. Often less, because proposing change is inherently uncomfortable for everyone else.

Someone reports a performance problem. You profile it, fix the bugs you find, and realize the real issue is architectural. So you build the architectural fix. Working prototype in a few hours. Your boss sees it, says he's sold, then tells you to spend a week debugging library internals instead. Not because he thinks you're wrong, but because he's not ready to absorb the change.

When you try to verify the reported symptoms before committing that week, you're told you're being dismissive. Asking questions about the problem reads as denying it exists.

The gap between responsibility and authority is where burnout lives. You own the consequences of bad decisions you can't prevent. When you try to prevent them, you're "creating friction." When you don't, the problems you predicted arrive on schedule and you fix them at 4 AM.

Disproportionate Response #

Reactions don't scale with the actual impact of a change. They scale with how uncomfortable it makes people.

A tool that adds one step to a build pipeline: multi-day conflict. A prototype on a hidden URL affecting nothing in production: "I can't evaluate this right now." A database field instead of a magic string: emoji vote, including from a non-programmer who prefers spreadsheets as a database.⁴

The pushback tells you nothing about the size of the change. It tells you how much the status quo is valued. Small improvements get the same resistance as large ones, because the threat isn't the change itself. It's the precedent that things can be changed.

The Prescription That Doesn't Work #

The advice for this position is always the same: communicate better. Get buy-in. Frame it as their idea. Pick your battles. Show, don't tell.

I've tried all of these. Not casually. I've written case studies of my own communication patterns. Tried careful framing with historical context. Proposed explicit trial periods with exit criteria. Done live demos with hard data.

The framing was acknowledged and overridden. The trial was killed before it started. The demo convinced my boss, and he still chose the other path.

"Communicate better" assumes the problem is delivery. That a clearer message would produce a different outcome. But when your audience agrees with your message and still picks comfort, delivery isn't the issue. The outcome doesn't change no matter how you present it.

Most writing about this concludes either "I need better soft skills" or "my coworkers are idiots." Neither is right. The structure does this. Different people in the same positions would produce the same dynamic, and I know this because I've been in this position at multiple companies with completely different people. The pattern didn't change.⁵

The Nuance #

Not every pushback is wrong. Bandwidth constraints exist. A manager who can't evaluate three architectural changes in one week isn't failing, they're managing their capacity.⁶

But when correct work gets validated then deprioritized across multiple teams and years, the individual justifications stop being the point. Each one is defensible on its own. The pattern is the signal.

The people involved are usually reasonable, acting in good faith, doing what works for them. The outcome is still that correct technical work keeps getting pushed aside, no matter who's in the room.

What Changes It #

Authority matching responsibility. That's the only fix I've seen work. Either you get decision-making power that matches the decisions you're already making, or you find a place that treats your judgment as an asset instead of something to manage.

If you're in this position (relied upon, validated, powerless), you're not imagining it. And it's not a communication problem. "Just communicate better" is the advice equivalent of "have you tried not being depressed?"

Then in the last few months, I shipped a blog engine, a procedural music generator, games, and a bunch of tools. Not because I became more disciplined. Because I finally noticed what actually gets me to build things.

Pain #

The first pattern I recognized: when something annoys me enough, it gets built. No planning, no decision to start. The annoyance just hits a point where I'm already building before I've consciously decided to.

Sometimes it's a slow burn - weeks of friction piling up until one night it snaps and I'm deep in code at 2am. Sometimes it's instant - something breaks and I'm fixing it within minutes. The threshold varies, but the mechanism is the same: I don't need motivation because the pain is doing that job for me.

I built this blog's engine because I wanted to write and every existing option felt wrong. At work, when something breaks badly enough, it gets fixed that night - no willpower required.¹

I called this "pain-driven development" for a while. Pain provides activation energy. That felt like the whole story.

Play #

Then I accidentally built a procedural music generator over three sleepless nights because I asked "how insane can I make this?" I'm still expanding it with new genres and planning to use it for game audio. Nobody asked me to. Nothing was broken.

I started making small games because one evening I looked at something silly I'd made and thought "wait, I can make games out of this?" Now I have dozens of ideas and I keep coming back to it.

The feeling is different from pain. It starts with curiosity - "I wonder if…" or "what if…" - and then I can't stop pulling the thread. I lose track of time not because I'm frustrated but because I'm having fun. 3am doesn't feel like 3am. And there's something about it being mine - not work, not obligation, just something I chose to make exist - that keeps the energy going.

The actual pattern #

Both pain and play work as activation energy. What doesn't work is trying to manufacture it. "This would be useful someday." "I should really build that." Obligation without energy behind it. Those don't go anywhere.

I have ADHD². Executive dysfunction means the gap between "I should do this" and actually doing it can be infinite - unless something else closes it for me. Pain closes it. Play closes it. Deciding to be motivated doesn't.

The pattern isn't pain-driven development. It's that I don't decide to build and then find motivation. I notice energy that's already there - whether it hurts or it's fun - and ride it. The decision comes after the energy, not before.

A decade of nothing, and then a few months of shipping more than I ever have. The difference wasn't trying harder. It was stopping pretending I could force it.³

The font looked crisp on my Mac. Then a friend sent a screenshot from Linux. Blurry mess.

What's happening #

ArialPixel is designed on a 16×16 pixel grid (em=1024, 64-unit grid). It's outline-only, no embedded bitmaps. My page uses font sizes from 10px to 14px for body text.

When the font size doesn't match the design grid (multiples of 16px), the pixel grid doesn't align with display pixels. Modern browsers apply antialiasing to smooth the edges. Result: blur.

I dug into the font with FontForge.¹ The GASP table had empty hinting flags - no gridfitting instructions telling renderers how to snap to pixels. (I did gasp when I saw it. Sorry.)

Here's a sandbox comparing everything I tried:

The rabbit hole #

I tried a lot of things. None of them worked.

Font-level fixes: I fixed the GASP table to enable gridfitting - macOS ignored it. Embedded bitmap strikes at target sizes - browsers don't use embedded bitmaps.

CSS tricks: image-rendering: pixelated only works on images, not text. -webkit-font-smoothing: none - Chrome removed support years ago. font-smooth: never isn't even a real property, thanks outdated Stack Overflow answers.²

Rendering workarounds: Canvas with fillText() always antialiases, no way to disable. WebGL with GL_NEAREST sampling - the source was already antialiased by the time I could touch it. Manual pixel scaling (render large, scale down) - still blurry source.

Other pixel fonts: VT323, Silkscreen, Press Start 2P - tested them but they didn't fit the CS 1.6 aesthetic anyway. Too bold, wrong vibe.

Why nothing works #

Browser text rendering happens before CSS or JavaScript can intervene. By the time you can access the rendered text (canvas, WebGL), antialiasing has already been applied. There's no API to say "render this font without smoothing."

The only ways to get crisp pixel fonts are using sizes that match the font's design grid (16px, 32px, etc.), or rendering text as pre-made images. Neither worked for my use case - I needed readable body text at small sizes.

The solution #

Give up. Offer users a toggle.

html.hd-mode * {
  font-family: Tahoma, 'Segoe UI', system-ui, sans-serif !important;
}

The page now has an "HD Font" toggle in the footer. Users on displays where the pixel font looks bad can switch to Tahoma (which is what CS 1.6 actually used). Users where it looks fine keep the aesthetic.

Sometimes the pragmatic solution is admitting the technically "correct" solution doesn't exist.

I wanted more than light mode and dark mode.

Three days later I had a procedural music generator with nine genres, twenty radio stations, and fictional advertisements for Dumpster Diving Certification Courses.

This is the story of feature creep at 3am.

December 3rd, midnight #

I was tired. I should have gone to sleep. Instead, I started messing with adding some themes to this blog.

First came the silly ones. A hotdog stand theme with two modes: ketchup (red background, yellow text) and mustard (yellow background, red text). A terminal theme. A few others.¹

Then I started experimenting with randomly generated colors. And fonts. And then I asked myself a dangerous question:

"How insane can I make this?"

The answer was: very.

Three hours later, I had a Geocities theme. Everything randomized. Cursor trails. Particles. Canvas animations. Rainbow text. Marquees.² Up to four status bars on any edge of the screen, each with its own scrolling messages - visitor counters, ICQ numbers, AIM screennames like xX_cool_wolf69Xx, "Now playing: doom_e1m1.mid", webring links. Elements that flee when you hover over them.

I went to bed at 7:15am, still staring at my phone looking at the beautiful abomination I'd created. In my journal I wrote: "It's that good."

*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*
          ~*~ SITE FEATURES ~*~

  [x] Falling particles (snowflakes, leaves,
      hearts, or RACCOONS)
  [x] Sparkle trails following your cursor
  [x] Elements that EXPLODE into emoji
  [x] UNDER CONSTRUCTION banners
  [x] Spinning wireframe shapes
  [x] Matrix rain (with raccoons)
  [x] Demoscene fire effects
  [x] Click particles for POINTS
      (raccoons = 25 pts, combo multipliers!)
  [x] Random fonts (Comic Sans, Papyrus,
      Impact, Jokerman, Wingdings...)
  [x] 1-4 status bars in 19 styles
      (Windows 95, Vaporwave, Barbie...)

*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*

December 4th: the concert #

I woke up at 3pm. Grabbed coffee. Went to see Nemo³ at MeetFactory.

It was wonderful. One of my top three concerts ever, alongside Paradox (Thai rock band I saw completely randomly in Ayutthaya) and Barasuara (Indonesian band I saw completely randomly in a Jakarta shopping mall). Queer crowd. Good energy.

I got home around 11pm, grabbed a kebab on the way, and felt that post-concert creative high. You know the one. When live music leaves you buzzing and you need to make something.

Old Geocities pages had auto-playing MIDIs. Mine didn't have music.

That felt wrong.

I started looking into Web Audio API. Oscillator synthesis. How hard could it be to generate some bleeps and bloops?

From my journal, December 4th:

Started working on some improvements to the silly Geocities theme, and somehow added an entire procedurally generated music player with a lot of different genres and radios. Oops. Worth it to not sleep.

December 5th: nocturnal trash panda energy #

I didn't sleep much. Crashed around 4pm after a beer.⁴ Woke up at 11pm.

And then came what I call "nocturnal trash panda energy" - that 2am productivity mode where everything clicks and you can't stop even if you wanted to.

I added automix. Genre detection based on page content. A chaos slider. Nine genres: chiptune, MIDI, synthwave, lofi, vaporwave, ambient, techno, trance, happycore.

I didn't know basically anything about procedural music generation going in. Still pretty lost, honestly. But LLMs made it possible to experiment without years of music theory. Try things, see what sounds right, iterate.

*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*
           ~*~ RADIO STATIONS ~*~

  97.3  RACCOON FM - Nocturnal beats
  3.AM  DUMPSTER DIVE FM - We eat everything
  140.0 RAVE.NET - Maximum BPM, minimum sleep
  0.01  THE VOID - ...
  0.00  MIDNIGHT.GOV - Numbers. Only numbers.
  45.0  CAFE.FM - Take your time
  ???   PIRATE RADIO - Unauthorized broadcast
  1.800 HOLD MUSIC - Your call is important

         [ 20 stations total ]

*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*

December 6th: shipped #

Didn't sleep again. Shipped an initial version in the morning. Stopped by for chlebíčky.⁵ Kept listening to the generated music because it's genuinely fun.

Slept 3.5 hours in the afternoon. Woke up around 5pm and genuinely couldn't tell if it was morning or evening.

The music player has two modes:

Tape Mode 📼 - Your page becomes a mixtape. The music places you on a two-axis mood map (chill↔energy, dark↔bright) based on what it detects: time of day, page content, emoji types, visual chaos level. Code blocks push toward digital/bright. Long paragraphs are chill. 🦝 triggers nocturnal lofi vibes. 2-5am shifts everything darker and slower. Weekend nights add party energy. Flip to Side B and the whole mood inverts.

Radio Mode 📻 - Twenty stations with DJs, jingles, and commercials for fictional 90s web products. GuestBook Plus. MIDI Collection Pro. The Forbidden Cat Adoption Agency. Dumpster Diving Certification (licensed by actual raccoons).

Old posts get the worn-cassette treatment. Tape hiss. Vinyl crackle. The older the post, the dustier the sound. Archives should sound like archives.

The chaos slider #

There's a slider labeled CHAOS. Turn it up and everything gets weirder. More detuning. More wobble. Genre shifts. Turn it down for a calmer sound.

But where's the fun in that?

What's next #

This thing is becoming a playground. Some directions I'm excited about:

More ways to generate: Right now it reacts to page content or plays radio stations. I want modes for generating specific things - "give me 30 seconds of tense ambient" or "loop-ready chiptune for a game scene." Shareable song seeds so you can save and recall your favorites. Stem exports for mixing.

More genres: Rock/metal, drum & bass, trip-hop, eurodance, industrial, gabber, acid. The IDEAS.md has the full list.

More radio chaos: Dial-up modem handshake sounds between songs. ICQ "uh oh" notifications. Weather reports for the information superhighway. Time-locked stations that only broadcast at certain hours. Winamp skins for the player.

Game audio: I'm making small games and the procedural approach means I don't need to compose anything - just define parameters and generate. Background music, menu themes, sound effects.

More silly things: Easter eggs. A cursor theremin. Typing percussion. Whatever sounds fun at 3 AM.

No timeline. It'll happen when it happens. The whole thing is open source (MIT license). The code is a beautiful mess, like all good Geocities tributes.

Try it yourself: toggle "geocities" in the theme picker (footer). Not every Geocities page had auto-playing music, so neither does every refresh here - but you can always enable it manually with the checkbox below the theme buttons.⁶ Every refresh is different. Every page sounds different.

Welcome to the information superhighway.

~*~ Thanks for visiting! Please sign my guestbook! ~*~

~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~

         Thanks for visiting my page!!!
     Please sign my guestbook (coming soon)

            [  PREV  |  RANDOM  |  NEXT  ]
              ~ Raccoon WebRing ~

         Best viewed in Netscape Navigator 4.0
              at 800x600 resolution
                  16-bit color

  This site is a member of the Nocturnal Animals
  WebRing. To visit other sites in the ring,
  click PREV or NEXT. To visit a random site,
  click RANDOM.

  ICQ#: 222850657
  AIM: aviraccoon
  Last updated: December 2025

~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~

The first one is already out: The Review.

What if a life had a Steam store page? Patch notes from v0.0, locked achievements, reviews from different perspectives, and a sleep schedule DLC that's been "coming soon" for decades. Retro Steam aesthetic using cs16.css. Easter eggs for those who click around. It took one evening to build.

Why games though? #

Writing describes things. Games make you do things. There's something about interaction that hits different - you're not just reading about a situation, you're in it, making choices, feeling the consequences. That's interesting to me.

And the key word is small. A weekend web project, not a two-year commitment where I burn out halfway through and never touch it again. Ship something, learn something, move on.

The ADHD brain needs novelty #

Here's the thing - doing the same thing repeatedly kills my motivation. If I built ten games in the same engine with the same workflow, I'd abandon the project by game three. So each one uses whatever tech fits the idea:

• The Review was vanilla HTML/CSS with cs16.css for the retro Steam look
• Future ones might use Godot, Twine, canvas, WebGL, whatever

But it's not just about game engines. Everything around making a game is a learning opportunity - procedural music, pixel art, accessibility,² shader effects, narrative design. If I already know how to do something, it's less interesting. If I have to figure it out, I'm engaged.

This is probably terrible advice for anyone trying to ship games professionally. But I'm not doing this professionally.

I'm also open-sourcing the code (MIT license) while keeping the content itself copyrighted.³ If someone wants to learn from how I built something, or fork it for their own project, go for it. The code is the part I'm learning anyway - might as well share that.

No deadlines, no roadmap #

A game takes as long as it takes. Some will be done in an evening, some might take months, some ideas will never happen at all. No schedule, no pressure, no guilt when I don't ship for a while.

I have a bunch of ideas. Whether they become actual games depends on energy, interest, and whatever else is happening in life. No promises.⁴

Games will appear at raccoon.land/games when they exist. I'll write about the interesting technical problems when I feel like it. RSS if you want to follow along.

Who am I? #

I go by aviraccoon on the Internet. Avi in real life.¹

I'm nonbinary (using they/them pronouns), got untreated ADHD (attempts had been made), I'm a furry (a raccoon 🦝), therian,² living in Prague, Czech Republic.

I like digging deep into whatever I'm focused on at the time - be it a programming thing like improving existing systems, trying to make my ADHD more bearable, or finding a new special interest like safety systems in public transport. That's when I thrive. And often, these things are very much connected.

In my career, I'm a programmer/marketing/community/producer mix, around game dev for over 13 years at the time of writing. Now working on a site for seeing how PC and console games are selling (and always fighting with React, TypeScript and Go).
Before that, I spent a bunch of years working on Euro Truck Simulator 2, during which I made a project I'm proud of and will never shut up about - I started the Czech & Slovak Games Week sale to help local game devs, which is these days the largest multi-game non-Valve Steam event. I don't contribute to it anymore, but it was really fun to do.

I care about equal rights, protecting workers, and overall having strong ethics. I don't accept bullshit from people I'm around, and I expect the same from them.

Why does this blog exist? Why now? #

Because I have a bunch of things to talk about and I have no place for long-form posts like this.

Screaming into the void in short-form (fediverse, Bluesky) just doesn't fit me, I usually keep forgetting these things exist unless I have a terrible pun to write.³

I've been playing with the idea of having my personal blog over some time, but I never had enough time, energy, and motivation to do so.

Let's not count the previous attempt in February 2024 when I posted the welcome post, and never anything else again. I'm in a much better state to start blogging now without fearing I will do the same mistake as before. How? With a mix of a few things.

In June this year, I started collecting my thoughts in an Obsidian vault (appropriately called raccoon-life). I was journaling for years, but these notes were usually just a few sentences for a day, or even less. I changed my approach, now I write everything down. And I do mean everything.

Turns out that doing this helps a lot with my ADHD, I can write things down and then forget about them until I need them again. And it also helps me now with thinking about enough topics in advance so I can confidently say "yeah, this can work."

What am I going to chirr⁴ about #

Various stuff I'm interested in, things that fascinate me, help me, bother me, or otherwise affect me in any way.

One big topic will be ADHD and things and tools related to it, how I handle this when I can't get support of the system. That means talking in detail about my personal vault, how I process things in it (hint: it's a lot of automated processing, including LLMs, to help me).

Related to this is working on various projects which help me further. I build software when the level of annoyance with things I try to use reach "fuck it" levels, that includes for example creating my own task system as I need something custom.

Then I have a variety of ideas for blogs about my life in general, about working in game dev (maybe including some horror stories?), travel, being a furry and therian, and other things in life. And whatever else I feel like I want to scream into the void about.

Note that I will talk about my approaches to LLMs and similar, as that's very much connected to how I tend to do things overall, it's a tool I use to fight with my ADHD, it made programming fun, etc.
So if you're strongly against this stuff, no hurt feelings. I understand, it's everywhere and everyone's sick of it.

How I'm approaching this #

There will be no schedule. I sometimes have energy to do something an entire night, then I can't bother doing anything for a week. Chaotic good, let's say.

I may jump from topic to topic, keep things unfinished. No promises here. Even I can't force myself to do some things, and blog isn't something I'm supposed to force myself into, it must be fun for me. And I can't plan ahead much, that just creates guilt for me. Best posts will be the ones I write late at night without any planning, most likely.

So absolutely no promises about any kind of schedule or what I'll actually talk about.

Interested? Hit the RSS bell, err, button #

Look, there's no analytics, no tracking, no newsletter or anything. I want a good old site with no bullshit like this. It's all running on a very simple blog generator I built in one night for this purpose.

There's the main RSS feed and also per-tag feeds if you're interested only in specific areas.

Welcome to my corner of the Internet. One pizza for this raccoon = one post. (I may just eat the pizza without doing anything. I be like that sometimes.)