FloppyDiskSizeGameProject

A complete 3D puzzle game that fits in a 1.44 MB floppy disk-sized executable.

Comment

Inspiration

Circuit Link began with a hard constraint: I wanted to enter a contest where the entire game had to fit within the 1.44 MB capacity of a floppy disk.

That limitation changed the way I approached every decision. Instead of starting with a commercial engine and reducing the result afterward, I built a compact C++ engine, editor, asset pipeline, and game around a single question: how much of a polished 3D puzzle experience can fit inside one tiny executable?

For the game itself, I was inspired by circuit-routing and path-building puzzles. Most of them take place on a flat board, so I explored what would happen if electricity could also travel upward, downward, forward, and backward. At the same time, I wanted to avoid a common problem in 3D puzzle games: fighting the camera instead of solving the puzzle.

The result is Circuit Link, a bright, pop-colored spatial puzzle where depth creates the challenge, while fixed views, smooth camera transitions, and layer slicing keep the board readable.

What it does

Circuit Link is a native 3D puzzle game in which players connect powered START terminals to every GOAL by placing and rotating circuit boards inside a voxel grid.

Players choose boards from a limited inventory, place them with the mouse, rotate them in 90-degree steps around the world X, Y, and Z axes, and press POWER to test the circuit. Electricity travels only when neighboring boards expose matching ports.

The 50-stage campaign is divided into ten sections that gradually introduce:

  • Straight, bend, tee, corner, cross, and six-way hub boards
  • Multiple starts, goals, and required TAP points
  • One-way straight, bending, and splitting diodes
  • Black semiconductor obstacles
  • Paired buried traces that transfer power between distant cells
  • Fixed boards and rotation-only preset boards
  • Relay coils and contacts
  • Separate 5V and 12V networks that must not be shorted together
  • Typed sockets that require a specific board and orientation
  • A final motherboard-scale stage combining the complete rule set

To make dense boards understandable, players can switch between six flat views and four diagonal overview cameras. In flat views, the active depth layer can be moved forward or backward, revealing cells inside the grid while hiding annotations that belong to covered layers. Camera and board rotations use smooth Ease-Out animation so players can follow the change in orientation.

The game also includes guided tutorials, undo and reset controls, animated power feedback, stage unlocking, three-star challenges, English and Japanese localization, independent BGM and SE volume controls, fullscreen/windowed settings, and a fixed-size persistent save format. Gameplay is completely mouse-driven, including placement, rotation, camera selection, menus, and modal dialogs.

How we built it

I built Circuit Link in C++17 without using an existing game engine. The repository contains a compact cross-platform engine, a Unity-like editor, the game-specific circuit systems, an asset conversion pipeline, and automated tests. Native Release builds are now available for Windows x64, macOS arm64, and Linux x64.

The editor provides a hierarchy, inspector, transform gizmos, component creation, scene serialization, asset management, logging, a scalable Game View, and gameplay-module hot reload. Editor scenes use JSON for convenient authoring, while the standalone game reads compact binary data.

Heavy import libraries stay on the editor side. Assimp handles FBX, stb_image handles PNG and JPEG, nlohmann/json handles authoring data, and miniaudio handles source audio. During a game build, assets are converted into small runtime formats:

  • Meshes contain only required vertices, normals, UVs, colors, and indices
  • Textures use raw RGBA or PackBits-style RLE, whichever is smaller
  • Audio is converted to 22.05 kHz mono IMA ADPCM
  • Scenes use a compact binary component format
  • Only referenced assets are packed
  • Meshes, textures, audio, scenes, shaders, and the application icon are embedded in the executable

The circuit simulation represents ports with a six-direction bit mask. Board rotations transform those directions, and a breadth-first traversal propagates voltage only through matching opposite ports. The same deterministic system handles diodes, relays, buried traces, multiple goals, typed sockets, and 5V/12V short detection.

GPT-5.6 through Codex was an active engineering collaborator throughout development. I supplied Japanese specifications, annotated screenshots, hand-drawn UI references, playtest observations, size constraints, and concrete bug reports. Codex inspected the existing repository, implemented scoped changes, compiled both Debug and Release builds, ran regression tests, captured game screenshots, and iterated on visual and gameplay problems.

This was not a one-prompt generation process. The workflow was a continuous loop: I made the product decisions and tested the game, then Codex helped investigate, implement, review, build, and verify each iteration. That loop covered engine architecture, the editor, compact formats, circuit logic, all 50 stages, localization, UI scaling, audio integration, persistence, rendering order, and executable-size optimization.

The current Windows x64 Release build is a single UPX-compressed executable measuring 1,097,728 bytes, below the required 1,474,560-byte floppy-disk limit. The verified macOS arm64 application bundle measures 1,394,989 bytes and uses lossless in-memory LZMA expansion for its embedded asset pack. The Linux x64 Release is a stripped, UPX-compressed ELF executable tested on Ubuntu and published as CircuitLink-v1.0-Linux-x64.

Challenges we ran into

The first major challenge was making a real 3D board readable. A fully transparent grid showed too much at once, but an opaque solution hid cells the player needed. The final system combines predictable camera presets, smooth transitions, a controllable depth layer, an opaque separator behind the active layer, view-dependent picking, and strict annotation visibility. Fixed-board and required-socket markers are drawn over their own cell but disappear when that cell is hidden or covered by the slice panel.

Rotation was another difficult problem. Applying local rotations in sequence caused the visible board, connection ports, preview, and star move counts to disagree. I changed the interaction to fixed world-axis quarter turns and added tests that verify orientations, ports, animation endpoints, and official solution move counts.

UI scaling also required several iterations. The editor Game View and standalone window originally produced different layouts, and resizing could misalign tutorials, buttons, and mouse hit tests. A reference-resolution Canvas scaler and viewport-aware input mapping now keep rendering and interaction aligned across window sizes and aspect ratios.

Cross-platform delivery exposed a different class of problems. Windows uses a consoleless single executable, macOS requires an application bundle and signing, and Linux depends on the guest audio and graphics stack behaving correctly. I verified the same embedded game on Windows x64, Apple Silicon, and Ubuntu x64, then used platform-appropriate packaging: UPX for Windows and Linux, and lossless LZMA asset expansion for macOS.

The size limit influenced the entire architecture. Rich editor features need flexible parsers, while the shipped game cannot afford those dependencies. Separating authoring-time code from runtime data, excluding unused assets, using fixed-capacity gameplay structures, compressing audio, and reporting asset-category sizes were essential to keeping the final build below 1.44 MB.

Finally, expanding from a small prototype to 50 distinct stages created a verification problem. The project now automatically validates authored solutions, circuit completeness, star conditions, unlock rules, localization, serialization, save corruption handling, UI behavior, and advanced mechanics in both Debug and Release configurations.

Accomplishments that we're proud of

  • Built a custom 3D engine and Unity-like editor specifically for the game
  • Delivered a complete 50-stage campaign with ten progressively combined mechanic groups
  • Released native builds for Windows x64, macOS arm64, and Linux x64
  • Kept the Windows Release build to one self-contained 1,097,728-byte executable
  • Kept the verified macOS arm64 application bundle within the floppy limit at 1,394,989 bytes
  • Embedded all required scenes, meshes, textures, audio, shaders, and the application icon
  • Implemented six-direction circuit propagation, one-way diodes, relays, buried traces, typed sockets, and dual-voltage short detection
  • Made dense 3D grids practical to edit through camera presets and active-layer slicing
  • Matched editor Play rendering and standalone rendering through the same runtime systems
  • Added English/Japanese localization with a compact embedded glyph atlas
  • Added an 80-byte fixed-length save format with CRC validation and platform-specific user storage
  • Maintained automated coverage for all 50 official solutions and core runtime formats
  • Used Codex as a sustained implementation and review partner across a large, evolving native C++ codebase

What we learned

Small executable constraints can improve architecture. Because every dependency and asset had a visible cost, I had to draw a clear boundary between an authoring tool and the runtime that players receive.

I also learned that readable interaction matters more than adding mechanics. Camera animation, consistent axis colors, active-layer isolation, clear connection feedback, and carefully timed tutorials made a larger difference than simply adding more board types.

For AI-assisted development, the most effective input was concrete evidence. Annotated screenshots, reproduction steps, exact expected behavior, and build-size targets gave Codex enough context to make focused changes. The best results came from treating AI work like an engineering review loop rather than accepting the first output.

Finally, automated tests were invaluable for a visual puzzle game. Changes to a model, rotation direction, depth rule, or UI state could silently affect an official solution many stages later. Deterministic simulation and full-campaign verification made aggressive iteration possible without losing confidence in the game rules.

What's next for FloppyDiskSizeGameProject

The technical foundation, all 50 stages, and native Windows, macOS, and Linux releases are complete. The next priority is broader human playtesting: measuring where players become confused, tuning the difficulty curve, improving stage descriptions without revealing solutions, and polishing the final balance of visual and audio feedback.

After that, I plan to:

  • Test the three native releases on a wider range of physical hardware and display configurations
  • Add Developer ID signing and notarization for a wider public macOS release
  • Add more accessibility options, including color-contrast alternatives
  • Improve the editor's dedicated stage-authoring and solution-validation workflow
  • Create optional challenge packs while keeping the original executable within the floppy-disk target
  • Continue reducing runtime and asset size without sacrificing clarity

Circuit Link started as an experiment in fitting a game onto a floppy disk. It has become a complete puzzle campaign, a compact engine, and a practical example of how strict constraints and an iterative human-plus-Codex workflow can produce a more focused result.

Built With

Share this project:

Updates