I’m now having development dreams. And, somewhat concerningly, I’m not just dreaming up imaginary software projects. I’m apparently designing technically plausible software architectures in my sleep.

An entirely reasonable technology stack for an entirely unreasonable project

The particularly absurd part is that I seem to have been designing an actual, reasonably realistic technology stack for this entirely unreasonable undertaking.

Somehow, my subconscious had decided that porting Mario Kart 8 Deluxe to Godot was a perfectly reasonable engineering project. Not making a kart racer inspired by it. Not making a little proof of concept. Actually porting Mario Kart 8 Deluxe.

And apparently, dream-me had settled on a multi-language architecture. I distinctly remember thinking that C# would be involved on the Godot side, with Rust handling backend functionality through a native extension.

Which, to be fair, isn’t an especially ridiculous combination in isolation. Godot supports C# for gameplay and application logic, whilst GDExtension provides a way to integrate native code. Rust can be used to implement those extensions, exposing native functionality to the engine.

You could quite reasonably use C# for gameplay systems, UI, race management and general orchestration, whilst implementing performance-sensitive or lower-level functionality in Rust. There are legitimate reasons to separate those responsibilities, particularly in a project involving complex simulation and engine integration.

The problem is that I was apparently designing this architecture for a native port of a Nintendo Switch game.

Think about the technical implications for a moment.

You’re looking at recreating the kart physics, including acceleration curves, drift mechanics, mini-turbo charge levels, collision response, item interactions, vehicle statistics and all the little quirks that make Mario Kart feel like Mario Kart. You’d need to reproduce the race simulation, AI behaviour, track geometry, checkpoints, lap progression, item distribution and networking systems.

Then there’s the rendering side. Recreating the original game’s visual presentation, materials, shaders, lighting, post-processing, animation systems and UI behaviour. All while making sure the result actually behaves like the original rather than just looking vaguely similar.

And, presumably, you’d have to account for differences between Nintendo’s original engine and Godot’s scene tree, resource management, rendering pipeline and physics implementation.

This is already an absolutely ridiculous project to contemplate.

But apparently my subconscious had decided that it was worth pursuing, and had even started making architectural decisions.

Production builds, debug menus and UI fidelity

The last thing I remember was being concerned that the pause menu didn’t match the original ROM.

I also vividly remember seeing a debug menu still present in what was apparently a production build.

Yes. Apparently, dream-me was not only dealing with UI fidelity problems, but also shipping a release with development tooling still exposed. Somewhere in this imaginary project, nobody had properly separated the debug configuration from the production configuration, and I was apparently the person who had to notice.

I have absolutely no idea what the debug menu contained. I don’t remember whether it exposed frame counters, collision visualisation, kart statistics, item spawning, track selection or some other assortment of developer conveniences. But I distinctly remember seeing it and knowing that it shouldn’t have been there.

Let that sink in for a moment.

Not only was I dreaming about porting a proprietary Nintendo game to an entirely different engine, I was apparently far enough into development to have a multi-language architecture, a production build, a debug menu, and concerns about release configuration.

There are so many things wrong with this situation.

For one, why am I dreaming about software development in the first place? Surely sleep is supposed to be the one time when I’m not thinking about implementations, compatibility, architecture or whether something matches its original behaviour.

Secondly, why Mario Kart 8 Deluxe? Of all the things my brain could have chosen to work on, it picked a game with years of development behind it, an enormous amount of proprietary technology and a frankly unreasonable number of systems to reproduce.

And thirdly, why was I worrying about the pause menu and debug tooling?

I don’t even remember getting as far as worrying about deterministic physics, synchronising multiplayer simulation, reproducing the original game’s vehicle handling or dealing with the differences between the two engines’ rendering systems.

No. Apparently, my subconscious had progressed far enough to have a C# and Rust architecture, production builds, and UI fidelity concerns, but hadn’t remembered to remove the debug menu.

There’s something particularly absurd about waking up and realising that, somewhere in your head, you’ve apparently spent several hours working on a completely imaginary software port. Not only that, but you’ve managed to invent an entire engineering project with a reasonably credible technology stack, specific implementation concerns and release-management problems.

I think I’ve reached a new level of burnout

But there’s a slightly less funny side to this.

I’m genuinely starting to wonder whether I’ve reached a new level of burnout.

I feel rested. That’s the thing. I don’t feel particularly exhausted from the night’s sleep. I woke up feeling rested, and yet apparently my brain had spent some portion of that sleep designing a multi-language architecture for a hypothetical native port of Mario Kart 8 Deluxe.

What the fuck?

I don’t know whether to find that impressive, concerning, or both.

There’s something rather unsettling about the possibility that development has become such an ingrained part of my thinking that my brain doesn’t seem to distinguish between being awake and being asleep when it comes to engineering problems. I can apparently put the computer away, go to bed, and still end up spending my dreams thinking about rendering pipelines, native extensions and production configurations.

Somebody make me read about werewolves

I already have enough projects to work on while I’m awake. I don’t particularly need my subconscious opening another repository at five in the morning, designing a multi-language architecture, deciding that a complete Nintendo game needs a native Godot implementation, and then assigning me UI fidelity bugs and production-build regressions.

Somebody slap me and force me to read some werewolf stuff.

Seriously. I have an entire special interest in werewolves that I could be spending my time thinking about. I could be reading folklore, researching the Wulver, getting lost in mythology, or doing literally anything other than mentally architecting a hypothetical Nintendo game port.

Apparently, though, my brain would rather spend its downtime thinking about C#, Rust, GDExtension and whether a debug menu has accidentally made it into a production build.

Honestly, just send me to Skye or Lewis at this point. Get me somewhere with a bit of Atlantic weather, some dramatic landscape, and absolutely no expectation that I know what a compiler is. I’d quite happily disappear into the Hebrides for a while, read about werewolves, and let my brain remember that it is allowed to think about something other than software engineering.

Ideally, I would like to return without having designed another game engine in my sleep.

The poor fruit fly

It’s giving the September 2026 fruit fly connectome situation.

For anyone who missed it, researchers released an incredibly detailed wiring diagram of an adult male fruit fly’s central nervous system, mapping approximately 166,000 neurons and millions of synaptic connections. This wasn’t a conventional brain scan: it was a connectome, reconstructed from electron microscopy, that researchers and developers could use to simulate neural activity.

Naturally, the internet got hold of it.

Initially, people started connecting simulations of the fruit fly’s nervous system to increasingly ridiculous things. Minecraft, DOOM, Beat Saber, Super Mario 64. The poor insect’s neural wiring was suddenly being repurposed as a video game controller.

But apparently that wasn’t enough.

I’ve since seen people taking the joke considerably further: forcing the simulated fly to learn Rust, learn Java, and install Linux From Scratch.

And I mean Linux From Scratch. Not Arch Linux. Arch is practically a guided installation by comparison. Arch at least gives you access to binary repositories and a package manager relatively early on. You can get a working system installed with documentation, a terminal and a reasonable understanding of what you’re doing.

Linux From Scratch is a different proposition entirely.

The poor thing is apparently being made to follow the documentation, build a temporary toolchain, compile the essential system components, configure its environment, enter a chroot, build the base system from source and eventually put together an entire working Linux installation.

And that’s before getting into the kernel, bootloader and all the other pieces needed to turn that collection of compiled software into a functioning operating system.

Linux. From. Scratch.

Not installing a distribution. Not configuring a distribution. Building the foundations of an operating system yourself.

And that’s on top of being made to sit through thousands of YouTube tutorials to supposedly learn these technologies properly.

Imagine being a fruit fly whose entire nervous system has been painstakingly mapped by researchers, only to have some developer decide that your next assignment is learning Rust, Java and how to bootstrap an entire Linux operating system.

At least with Arch, you get a package manager and binary repositories. With Linux From Scratch, you’re being made to understand how the system is put together before you’ve even got the system.

At this point, it’s not neuroscience. It’s an unpaid software engineering apprenticeship.

And now I’m wondering whether my own brain is doing something similar, except instead of connecting a simulated insect to increasingly questionable software projects, it’s running increasingly elaborate engineering workloads on itself.

The difference is that nobody has to force me to watch the tutorials. Apparently, I’ll just dream up the architecture myself.

What the fuck?

I feel rested. I really do.

But what the fuck?

I think I need a holiday from my own brain. Preferably one involving werewolves, the Outer Hebrides, and absolutely no IDEs.