How One ITP Participant Built a Game with Open Source Tools
When an ITP participant connected with New York University’s Interactive Telecommunications Program began sketching a game, the ambition was deliberately modest: make one satisfying puzzle loop, test it with other people, and avoid building an engine before there was a game to play. That restraint shaped every later decision, from the grey-box prototype to the public build.
The project was assembled from open source programs rather than an expensive studio stack. A small engine handled play, graphics tools produced assets, and version control kept the work recoverable. The result was more than a release; it demonstrated how a solo maker can experiment, document choices and welcome contributors without waiting for a studio-sized budget.
Starting with a Playable Mechanic
The first prototype did not need a world, cast or elaborate lore. It needed one mechanic: reroute power between small stations until every light came on. Rough cubes and placeholder signals were enough to expose problems. Each test asked whether the rule was clear, whether failure felt fair and whether another round was worth starting.
That narrow scope protected the schedule. The participant could change a timing value, then watch someone else discover the same frustration or surprise. Feedback moved the design towards a clean, readable experience while keeping the game’s technical demands modest enough for a solo project and a small volunteer team.
Choosing an Open Source Toolchain
Godot supplied the game engine and exported builds for desktop and web. Blender created low-polygon scenery, GIMP handled texture edits, and Audacity processed sound effects. Inkscape covered interface graphics, while Git recorded changes and stored early versions. Each program offered a direct route from an editable file to the finished build.
Using freely available software also made the process legible. Visitors could install comparable tools, inspect the repository and understand why an asset had been simplified. The participant documented licences carefully, including attribution requirements, so the transparent workflow supported both experimentation and responsible reuse.
Making Minimalism Feel Playable
The visual approach was spare: a dark interface, pale geometric objects and a restrained palette of colour. Melbourne’s changeable light and the utility signs glimpsed around the city informed that atmosphere without turning the game into a documentary. Simplicity made the puzzle readable, but the participant resisted making every surface lifeless.
That balance connects with the ITP 30 Show journal’s reflection on minimalism in digital art. Reduced forms gave each object a purpose, while tiny shifts in colour, sound and motion supplied the emotional texture. Minimalism became a system for guiding attention rather than an excuse to leave the work unfinished.
Keeping Art and Code in Conversation
A compact game can still become difficult when visual intent and technical structure drift apart. The journal discussion of balancing art and engineering captures the central problem: a convincing animation is of little value if the underlying state is unreliable, while stable code can feel sterile without careful feedback.
The participant treated polish as an engineering task. Motion was tied to readable game states, sound marked important changes, and each new effect had to survive slow devices and repeated play. This discipline kept the expressive choices connected to the puzzle’s actual needs rather than to novelty for its own sake.
Testing the Game Close to Home
Melbourne offered a practical test bed, especially around the Freeplay Independent Games Festival, where local players are accustomed to trying unfamiliar independent games. Short sessions with volunteers revealed that the opening explanation needed to be shorter. In Australian playtest banter, one tester called an early control “a bit dodgy”, while another said the solved puzzle felt “fair dinkum”.
The broader Australian release also had to respect a distinct market. Storefront prices appear in AUD, creators need to account for GST, and a project of this size cannot assume international sales will compensate for local costs. Online collaboration with participants in Sydney and Brisbane helped test the build across devices and connections, while public forums and game-jam nights provided useful audiences without turning feedback into a popularity contest.
Releasing the Project and Its Process
The final build was offered with a short public demo, a clear credit list and links to the project’s source files. Source access did not mean every file was destined for commercial use; it showed how the game was made and let technically curious visitors examine the structure. The participant also preserved earlier builds so design decisions could be compared over time.
That openness mattered because a polished result can hide the uncertainty behind it. The project archive made room for prototypes, rejected effects and notes about difficult bugs. For an emerging maker, the record offered something as valuable as the game itself: evidence that a coherent digital experience can grow from small experiments and ordinary working sessions.
Explore the ITP 30 Show to see project descriptions, author credits and related resources. Event information and RSVP details can help you join the wider programme, while the scholarship and census pages connect the showcase to ongoing work at ITP. Interactive concepts, illustrated catalogues, weather-based experiences and digital archives show the same experimental spirit beyond the game.
Read the game’s process alongside the journal essays, then carry that curiosity into your own experiments: choose one clear objective, use tools you can inspect, test with people outside your usual circle and record what changes. Open source offers a practical way to work in public without pretending the work was finished in isolation.