With Pete Baldes’s guidance, I created Text Textures—an experimental video game and installation built in Godot, designed to question the invisible codes shaping our digital worlds.

Initially conceived as an animation, Text Textures featured recursive layering: a figure composed entirely of ASCII text within a similarly textual classroom, observing a computer whose screen displayed another ASCII-rendered figure. This recursive structure established the project’s focus on dimensional interplay and textual embodiment.

Using ASCII imagery and 3D modeling software such as Blender, the project reimagines code not merely as functional instruction but as embodied surface. Words and letters become literal skins wrapping digital bodies and environments. Sensory boundaries further dissolve as artificial intelligence tools like Google Translate audibly vocalize raw code. When read aloud, the machine language takes on an unexpected rhythm—its strings of characters and numbers transformed into a stuttering, mechanical cadence. This gesture makes audible a language never meant for human ears, emphasizing how computational systems communicate through codes largely inaccessible unless mediated or decoded. It draws attention to the alien poetics of code: a machine speaking to itself, and now—unsettlingly—to us.

The project evolved into an immersive, exploratory digital environment—hesitantly termed a “video game” due to its intentional lack of conventional objectives. It encourages open-ended navigation and experimentation while making visible the limits built into any coded system. At times, control is stripped away entirely: the avatar gains agency, distorts its body, triggers unexpected dialogue, and even seizes camera control to look back at the player. Only after confronting the player with their own ASCII-rendered image is control returned, highlighting tensions between player authority and scripted autonomy.

This exploration builds on experiences with games like The Sims 3, where characters often misbehaved—walking into walls, refusing tasks, or altering routines unexpectedly. In Text Textures, such disruptions are intentional, emphasizing how avatars function as both puppet and puppeteer. The game’s customization interface, inspired by “Create-a-Sim” mechanics, complicates these dynamics further: players interact with mirrors to modify avatars, stretching and reshaping digital bodies. Yet, avatars may reject these new forms, declaring, “I’m not your toy to twist and stretch,” before walking off a ledge and self-destructing—a scripted refusal written directly into the code.

Even this apparent “agency” is pre-scripted. It is important to delve into source code, since code itself reveals the ideological, biases and political assumptions of the developer. This is why I added the dome feature: to expose the underlying scripts, to show the biases inscribed by the developer, and to complicate the authority of the game’s surface aesthetics. Players who enter the dome can view the code driving behavior, including agency overrides and forced-suicide sequences:

agency_trigger_timer.timeout.connect(_on_agency_timer_timeout)

camera_agency_trigger_timer.timeout.connect(_on_camera_agency_trigger_timeout)

camera_agency_duration_timer.timeout.connect(_on_camera_agency_duration_timeout)

safety_cooldown_timer.timeout.connect(_on_safety_cooldown_timeout)

agency_animation_timer.timeout.connect(_on_agency_animation_timeout)

_start_random_agency_timer()

_start_random_camera_agency_timer()

And even the avatar’s final act of resistance—the suicide sequence—is entirely scripted:

# === FORCED SUICIDE MOVEMENT ===

func _forced_suicide_movement(delta):

    if suicide_target:

        suicide_phase_timer += delta

        if not is_floating and suicide_phase_timer < 5.0:

            var to_target = (suicide_target.global_position – global_position).normalized()

            velocity.x = to_target.x * SPEED

            velocity.z = to_target.z * SPEED

            var distance = global_position.distance_to(suicide_target.global_position)

            if distance > 5.0:

                animation_player.play(“Running”)

            elif distance > 2.0:

                animation_player.play(“Crouch”)

            else:

                animation_player.play(“Walking”)

        elif not is_floating and suicide_phase_timer >= 5.0:

            is_floating = true

            collision_mask &= ~2

            gravity_enabled = false

            if not suicide_floating_audio_played and float_suicide_voice:

                audio_player.stream = float_suicide_voice

                audio_player.play()

                suicide_floating_audio_played = true

                if talk and talk.has_method(“start_talking”):

                    talk.start_talking()

                audio_player.finished.connect(Callable(self, “_on_suicide_voice_done”), CONNECT_ONE_SHOT)

Making these scripts visible raises critical questions: where does agency reside—in the developer who authored the code, the player who triggers it, or the avatar whose behavior appears autonomous but is ultimately constrained?

Approaching the code dome triggers another layer: an AI “voice of god” reads the scrolling code aloud, but it is unreliable, inserting statements not actually present in the source text and reading the code in a random order not in sync with the scrolling text dome. This visual and auditory paradox further complicates the sense of control, suggesting that even code—the supposed foundation of logic—is subject to misinterpretation and mediation.

By rendering code visible, audible, tactile, and materially integrated, Text Textures interrogates the presumed seamlessness of digital imagery. It reveals the scaffolding beneath polished aesthetics and foregrounds a deliberate, glitch-informed honesty about the complexities and power dynamics embedded within digital creation processes.

Download link and Player Instruction Guide: https://sirenapearl.itch.io/text-textures