Fractals have fascinated programmers for decades.
From the Mandelbrot Set to Julia Sets, these mathematical structures can generate breathtaking patterns from surprisingly simple equations.
The challenge isn't generating a fractal.
The challenge is generating one at extreme resolutions.
A 10,000 × 10,000 image contains:
100,000,000 pixels
That's 100 million pixels.
Many image-generation approaches attempt to store the entire image in memory before saving it to disk. At these resolutions, memory consumption can quickly become a problem.
This is where pyaitk.CLSE's StreamingWriter becomes useful.
Instead of building the entire image in RAM, rows are generated and written directly to disk.
In this article, we'll create a 10K Julia Set fractal while keeping memory usage under control.
The Code
from pyaitk.CLSE import StreamingWriter
WIDTH = 10000
HEIGHT = 10000
MAX_ITER = 300
C_REAL = -0.7
C_IMAG = 0.27015
with StreamingWriter(
"julia_10k.png",
width=WIDTH,
height=HEIGHT,
bpp=24
) as sw:
for py in range(HEIGHT):
row = []
zy = ((py / HEIGHT) * 3.0) - 1.5
for px in range(WIDTH):
zx = ((px / WIDTH) * 3.0) - 1.5
iteration = 0
while (
zx * zx + zy * zy < 4.0 and
iteration < MAX_ITER
):
temp = zx * zx - zy * zy + C_REAL
zy = 2.0 * zx * zy + C_IMAG
zx = temp
iteration += 1
color = int(
255 * iteration / MAX_ITER
)
row.append(
(
color,
color // 2,
255 - color
)
)
sw.write_row(row)
The result is a massive Julia Set image containing intricate fractal structures across 100 million pixels.
Why Julia Sets?
Julia Sets are generated by repeatedly applying a complex mathematical function.
The equation used is:
z = z² + c
where:
c = -0.7 + 0.27015i
Each pixel becomes a point in the complex plane.
The algorithm repeatedly evaluates the equation until either:
- The point escapes
- The maximum iteration count is reached
The number of iterations determines the pixel colour.
This simple rule produces remarkably complex structures.
Mapping Pixels to Mathematics
A computer screen works in pixels.
A fractal works in mathematical coordinates.
The first step is converting pixel positions into coordinates in the complex plane.
zx = ((px / WIDTH) * 3.0) - 1.5
zy = ((py / HEIGHT) * 3.0) - 1.5
This maps the image into a viewing region:
(-1.5, -1.5)
↓
( 1.5, 1.5)
Every pixel becomes a unique mathematical starting point.
The Escape Test
The heart of the algorithm is:
while (
zx * zx + zy * zy < 4.0 and
iteration < MAX_ITER
):
As long as the point remains inside the escape radius, iteration continues.
If the value grows beyond:
|z| > 2
the point is considered escaped.
Points that remain stable create the characteristic Julia Set structure.
Colouring the Fractal
After the iteration process finishes, a colour is assigned.
color = int(
255 * iteration / MAX_ITER
)
The pixel colour becomes:
(
color,
color // 2,
255 - color
)
This creates a smooth gradient ranging from deep blues to bright highlights.
More advanced colour maps can produce even more dramatic results.
Why StreamingWriter Matters
A traditional image-generation workflow usually follows this pattern:
Allocate image
Store every pixel in memory
Save image
For small images, this isn't a problem.
But a 10,000 × 10,000 RGB image contains 100 million pixels. As resolutions increase, memory requirements grow rapidly, especially when additional processing buffers are involved.
StreamingWriter takes a different approach:
Generate row
Write row to disk
Discard row
Generate next row
Only a single row (and a small amount of bookkeeping data) needs to exist in memory at any given moment.
Memory usage remains relatively stable because the entire image never needs to be stored in RAM simultaneously.
This means even developers using older laptops, entry-level PCs, virtual machines, or systems with around 4 GB of RAM can generate extremely large procedural images without needing workstation-class hardware.
Instead of requiring enough memory to hold a complete 100-million-pixel image, StreamingWriter continuously streams data directly to disk.
The result is a workflow that scales far beyond what many traditional in-memory approaches can comfortably handle.
Understanding the Scale
Let's put the resolution into perspective.
10000 × 10000
equals:
100,000,000 pixels
For comparison:
| Resolution | Pixels |
|---|---|
| 1920×1080 | 2.07 Million |
| 3840×2160 (4K) | 8.29 Million |
| 7680×4320 (8K) | 33.18 Million |
| 10000×10000 | 100 Million |
This single fractal image contains more pixels than a typical 8K render.
Beyond Julia Sets
The same streaming approach can be applied to many procedural graphics systems:
- Mandelbrot Sets
- Perlin Noise
- Voronoi Diagrams
- Terrain Maps
- Heatmaps
- Scientific Visualizations
- AI Dataset Generation
- Procedural Artwork
The rendering logic changes.
The streaming architecture remains exactly the same.
Why This Matters
Modern displays continue to increase in resolution.
At the same time, procedural content generation is becoming increasingly important in:
- Games
- Simulations
- AI
- Scientific Computing
- Generative Art
Generating these assets efficiently requires more than just fast algorithms.
It requires memory-efficient workflows.
StreamingWriter provides exactly that.
Final Thoughts
Creating a Julia Set is already an interesting mathematical exercise.
Creating one at 10,000 × 10,000 resolution introduces an entirely different challenge: managing memory efficiently.
By combining fractal mathematics with pyaitk.CLSE.StreamingWriter, it's possible to generate images containing 100 million pixels while avoiding the need to keep the entire image in memory.
One of the most interesting aspects is that this kind of rendering isn't limited to high-end workstations. Thanks to row-by-row streaming, even systems with around 4 GB of RAM can participate in generating massive procedural images that would otherwise be impractical using fully in-memory workflows.
What starts as a simple equation:
z = z² + c
ultimately becomes a massive, highly detailed fractal image generated one row at a time.
And that's the power of streaming image generation.
Other
Installation
pip install pythonaibrain[clse]
