Devlog #8

​
I asked the question — “is this actually accurate?” — and the answer was no. A real Enigma’s case isn’t one big lid you flip up. It splits into three: the main hinged lid, a fold-down flap in front of the plugboard, and a separate cover over the rotors with little letter windows. So I rebuilt all three.
​

What actually works now

​

• Plugboard front flap. On the real machine the plugboard sat behind a panel that folds down from a hinge at the bottom. I added that front panel and tied it to the lid state, so closing the lid folds the flap up over the front too — the way it would look packed away for transport.
• Rotor cover (Walzenabdeckung). Instead of leaving the rotors fully exposed, there’s now a cover that hides everything except three letter windows and the finger-wheel slits, with brass bezels around each window. It rides its own ▢ 로터 toggle — closed gives the authentic operating look, open shows the rotors.
• Lid interior. The inside of the lid used to be empty; the real one carried spare bulbs, red/green filters, and a metal plate. Added a bulb-holder strip, the two filters, and a nameplate — and kept them on independent materials so they stay solid in X-ray instead of going transparent along with the case.
  ​

Stuff that tripped me up

​

• Fully sinking the rotors into a well — so only the finger wheel and a single letter peek out, like the real machine — tangles with the X-ray wiring coordinates I’d already placed. Rather than move all the internal geometry, I got the same read from the cover: close it and you only ever see the letter windows. Same look, none of the rework.

Devlog #7

The engine has been correct for a while now — rotor stepping, ring settings, reflector, all of it. This session wasn’t about correctness, it was about feel: making the wooden lid open and shut for real, and making a keypress light up an actual path of current through the machine instead of just blinking a lamp at the end.

Then I committed all three changes in one go and the build blew up in my face. Worth it.

What actually works now

• The lid hinges open and closed. A ▣ 뚜껑 toggle drives a hinge pivot, and the render loop lerps it toward the target angle so it swings instead of snapping shut.
• Rebuilt the lid as a real box. My first lid was a single flat plank — it clipped straight through the rotors and only covered half the keyboard. Now it’s a hollow box (top + front + two side walls) with the hinge raised above the rotor tops, so it clears everything when it closes.
• Live current path. Until now, pressing a key did nothing to the cabling — the keyboard-to-plugboard route was never visualized at all. Now I take the trace the engine hands back and draw the whole route — keycap → plugboard → rotor contacts → lamp — as one glowing tube, with a spark running along it.
• Heavier materials pass. Nudged the wood/brass/steel roughness, metalness, and env-map strength a notch heavier to kill the last of the plastic look.

Stuff that tripped me up

• I committed all three changes at once and the build died on boot — three TypeScript errors, all from one mistake. My new lid store collided with an existing lid mesh variable, so the compiler threw Property 'subscribe' does not exist..., an implicit-any fell out of that, and on top of it I’d pasted over and deleted a partnerOf helper. Aliasing the import to lidStore and restoring the helper cleared all three at once.
• Lesson, paid the usual way: when you add a store with the same name as an existing mesh variable, alias it at the import line first — before TypeScript makes you.

Next up

The case opens and the wiring lights up, but it isn’t historically right yet. The real Enigma’s case came apart in three pieces — the main lid, a fold-down flap in front of the plugboard, and a separate cover over the rotors — and mine is still one lid sitting over fully exposed rotors. Next session: make it match the real thing.

X-ray mode

This is the part I said I was actually here for. Flip a switch and the wooden case turns to glass so you can see what’s been sealed inside the whole time. Getting it to look right was the fun part. Getting it to stay working cost me the better part of an afternoon.

What I built

• Case → glass. The casing shells (body, rotor housing, plugboard panel) drop to ~28% opacity with depth-writing turned off, so you can see straight through the wood.
• A lit interior. A warm point light kicks on inside the case the moment X-ray turns on — otherwise the guts just read as a dark smudge instead of actual hardware.
• The hidden hardware. Built everything that’s normally sealed away: a battery block with brass terminals, and thick orange cable looms routing down beneath the rotors.
• The wiring map. A 26-strand bundle draws the actual internal permutation for the current rotor / ring / position setup, so what you see under the glass matches what the engine is really doing.

Then it went dark — on a fresh load only
Everything looked perfect while I was building it. Then I cleared the cache, cold-booted the dev server to check it clean… and X-ray did nothing. Solid wood. The button highlighted, the wiring was clearly toggling on, the opacity was being set — and the case flat-out refused to turn transparent. I burned a good while convinced a git reset had eaten the fix.

The one-line culprit
It wasn’t git — the code was byte-for-byte the version I’d already signed off on. The real reason: in three.js (r137+), if you flip a material’s transparent flag at runtime, the change won’t take effect unless you also set material.needsUpdate = true. My toggle was setting transparent and opacity but never needsUpdate, so blending never actually switched on and opacity = 0.28 was silently ignored. It “worked” during development purely because hot-reload kept rebuilding the materials from scratch — a real cold load exposed it instantly. One line in the toggle loop and the glass came back.

Next up: make the current actually flow — each keypress lighting up the live signal path through the rotors and off the reflector, with a real cable running from the key you pressed into the loom, so the glow starts where your finger does.

Hardware fidelity pass — “wait, is this actually what the real Enigma looks like?”

After the electrical signal path was rendering, I pulled up real Kriegsmarine M4 photos to compare — and the 3D model didn’t hold up. So before adding anything new, this one is a “make it historically accurate first” pass.

What was wrong

• Floating letters. The rotor alphabet was hovering in mid-air beside each wheel instead of being on it. On the real machine the letters are engraved around the rotor’s circumference and you read one through a small window.
• The reflector and entry wheel looked fake. They were basically copy-pasted rotors with the letters wiped off. In reality the reflector (UKW) and entry wheel (ETW) are fixed and tucked inside the housing — there are no spinning lettered drums there at all.
• Lopsided UI. A huge dead zone under the input field was squashing the 3D view into a thin strip.
• Input/output drift. The I/O readout was center-aligned, so every keypress shoved the existing letters further left. Genuinely uncomfortable to type on.

What I did

• Wrapped the alphabet onto the rotor circumference with engraved grooves, contact rings, and brass window bezels, so you read it through the top window like the real thing.
• Rebuilt the reflector and ETW as smaller dark drums seated in the housing, and set them to stay hidden in the normal view — they’ll surface later in X-ray mode, where the internal wiring belongs.
• Set the 3D viewport to flex: 1 so it fills the space, and re-framed the camera.
• Switched the I/O readout to a fixed-width, left-anchored layout, so input and output line up and grow rightward instead of sliding around.

A lesson paid for in blood

Squashed a stack of messy single-digit commits into one clean commit — then ran git reset --hard with an uncommitted layout fix still in the working tree and watched it evaporate. Re-did it in two minutes, but the takeaway stands: run git status before --hard. Always.

Next up: the X-ray translucent mode that exposes the internal wiring and lights up the live signal path through the rotors. That’s the part I actually started this whole thing for.

Electrical signal implementation

I created an initial version to beautifully implement the existing CLI Enigma on the web.