A Game With No Assets: Generating All Graphics and Sound Effects in Real-Time Using Sine Waves

A Game With No Asset Files Whatsoever

In game development, we're accustomed to a familiar workflow: artists create textures, sound designers record audio, and programmers bundle these assets into the game. Asset files typically account for the vast majority of a game's size—a modern AAA title's installation package can easily exceed 100GB, with most of that space consumed by high-resolution textures, pre-rendered cutscenes, and lossless audio. Yet indie developer Zanzlanz accomplished something seemingly impossible—releasing a game with absolutely no asset files.

When we say "no assets," this isn't marketing hyperbole. Every texture and sound effect in this game isn't a pre-made file stored on disk. Instead, everything is computed in real-time during runtime through mathematical functions. The core technique is something we all learned in math class: the sine wave.

This approach is extremely challenging technically, while also demonstrating the boundaries of what procedural generation can achieve in extreme scenarios.

How Sine Waves Generate Visuals and Audio

Sound Is Fundamentally a Wave

From an audio perspective, this approach is quite natural. Sound is physically just air vibration, and the purest tone is precisely a sine wave. The essence of digital audio sampling is calculating the amplitude value of a waveform at each sample point. For CD-quality audio, this means computing amplitude values for 44,100 sample points per second, where each point is the result of a simple mathematical operation: amplitude = A × sin(2π × frequency × t).

By controlling the sine wave's frequency (determining pitch), amplitude (determining volume), and superimposing multiple waves of different frequencies (determining timbre), developers can synthesize various sound effects and music at runtime without storing any WAV or MP3 files. This is essentially the most fundamental form of wavetable synthesis and additive synthesis.

Wavetable Synthesis is a technique that produces tones by storing a single-cycle waveform and playing it back at different rates, first applied in 1980s hardware synthesizers like the PPG Wave. Additive Synthesis is based on the Fourier theorem—any complex periodic waveform can be decomposed into a series of sine waves with different frequencies, amplitudes, and phases. The core idea of Fourier analysis was proposed by French mathematician Joseph Fourier in 1807, and this seemingly simple mathematical discovery profoundly transformed signal processing, image compression, quantum mechanics, and many other fields. In practice, even a small number of harmonic components can produce rich and varied timbres, from the warm thickness of a simulated pipe organ to the sharpness of an electronic buzz. This means that theoretically, by superimposing enough sine components, any sound can be reconstructed—precisely the mathematical principle Zanzlanz leveraged.

"Painting" Textures With Mathematical Functions

The visual aspect is even more impressive. Applying sine waves to texture generation requires more ingenious mathematical thinking. By applying combinations of sine functions to screen coordinates (x, y), periodic, gradient patterns can be generated. Multiple sine waves with different phases and frequencies, when superimposed, can produce stripes, ripples, gradient color blocks, and even cloud-like texture effects.

Specifically, a simple wood grain effect can be achieved through a formula like color = sin(x * freq1 + sin(y * freq2) * distortion), where nested sine functions create nonlinear distortion that simulates the irregular textures of natural materials. More complex effects might require dozens of layers of sine wave superposition and transformation, with each layer controlling details at a different scale. This multi-frequency superposition approach is conceptually similar to Perlin noise's fractal Brownian motion (fBm) method—invented by Ken Perlin in 1983, which produces natural-looking textures by superimposing multiple frequencies (called "octaves") of smooth random functions, and remains a core algorithm in world generation for games like Minecraft to this day.

This technique has a long tradition in computer graphics. The early Demoscene community was famous for cramming stunning audiovisual demonstrations into extremely small file sizes (such as 64KB), with procedural generation algorithms like these being one of their core techniques. The Demoscene originated in 1980s European computer hobbyist communities, initially as "intro" segments where software cracking groups showcased their technical prowess at the beginning of games, later evolving into an independent digital art movement. Participants create real-time rendered audiovisual demonstrations within strict file size limits (common categories include 64KB, 4KB, and even 1KB). In 2020, the Demoscene was recognized by UNESCO as intangible cultural heritage. Notable works like .kkrieger is a first-person shooter of only 96KB, with all 3D models, textures, and music generated by the program in real-time—Zanzlanz's project stands squarely on the shoulders of this technical tradition.

Why This Matters

Extreme Size Compression

The most direct benefit is game size. When all content is generated by code, the game's "assets" are effectively just a few lines of mathematical formulas. This means the entire game can be compressed to an extremely small size, which has practical significance in technical challenges pushing boundaries and certain special distribution scenarios.

To understand the staggering degree of compression, consider this comparison: a single 1024×1024 uncompressed RGBA texture occupies 4MB of storage, while the mathematical formula generating a texture of equivalent complexity might require only a few hundred bytes of code. This means the theoretical compression ratio can reach tens of thousands to one. In the early internet era when network bandwidth was limited, and in today's IoT devices where storage space is extremely constrained, this technique has practical value beyond artistic expression.

Educational Value

According to community feedback, the development process videos are high quality and explain complex mathematical concepts clearly and accessibly. This is precisely where such projects hold their greatest value—they transform abstract trigonometric functions, Fourier concepts, and signal processing knowledge into concrete results you can see and hear.

For developers learning graphics and audio programming, this is an excellent teaching case: it strips away the complexity of engines and asset pipelines, forcing one to confront the fundamental question of "where does content come from?" In an era where modern game engines (like Unity or Unreal Engine) heavily abstract away low-level details, many developers lack intuitive understanding of the mathematical nature of content. Projects like this force learners back to the most fundamental level: Where does a pixel's color value come from? How is an audio sample's numerical value determined? This "first principles" style of thinking is essential for developing deep technical competence.

Insights and Limitations of Procedural Generation

Unique Expression Through Creative Constraints

This project reminds us that technical constraints often spark creativity. When developers abandon traditional art assets and express everything solely through mathematical functions, a unique, unified audiovisual style emerges. This "constraint-driven aesthetic" has long been celebrated in indie games and creative coding.

History offers many similar examples: the palette limitations of early 8-bit consoles gave birth to pixel art's distinctive charm; chiptune music developed a unique style under extremely limited sound channels; Twitter's 140-character limit once spawned "Tweetcarts"—complete graphics programs written within a single tweet's length. Constraints aren't the enemy of creativity—they're often its best catalyst.

Trade-offs in Real-World Development

This extreme approach isn't practical for commercial games. Computing all textures and sound effects in real-time incurs performance overhead, and content generated from sine waves has an obvious ceiling in artistic expressiveness—it's very difficult to use them to draw a detailed character portrait. Therefore, the mainstream approach remains a "hybrid model": using procedural generation for terrain, texture details, ambient sounds, and other repetitive content, while using handcrafted assets for key elements requiring fine control.

However, it's worth noting that modern GPU fragment shaders are naturally suited for this kind of per-pixel mathematical computation, since GPUs have thousands of parallel processing cores that can simultaneously execute the same mathematical function on all pixels on screen. On platforms like Shadertoy, developers can render photorealistic scenes in real-time with just a few dozen lines of GLSL code. In the commercial realm, No Man's Sky used procedural algorithms to generate over 18 quintillion planets, and procedural workflows in DCC tools like Houdini have become standard practice in AAA game art production. However, complex procedural calculations can still cause frame rate drops, especially in scenarios requiring extensive iteration, so practical applications often employ precomputation caching strategies to balance quality and performance.

Conclusion

Zanzlanz's "no-asset game" is less a complete commercial product and more a brilliant technical experiment and mathematical art expression. Using the most basic sine waves, it validates the potential of procedural generation across both visual and audio dimensions, while providing the developer community with an excellent sample for learning the underlying principles of graphics and audio.

In an era where AI-generated content is sweeping the industry, this return to mathematical origins—conjuring something from nothing through pure algorithms—exudes a distinctive engineering romanticism. As we increasingly rely on large language models and diffusion models to generate content, perhaps it's occasionally worth pausing to reflect: just how far can a single sine curve take us?