The Entropy Dreamer

Concept

The Entropy Dreamer is a generative art project that translates raw system noise—micro-fluctuations in execution time, load, and memory—into a visual “dreamscape.”

Instead of using standard PRNG, it uses high-resolution jitter from the operating system to seed a coordinate-warped grid of color. The result is a visual representation of the machine’s momentary state of existence.

Architecture

• entropy_engine.py: Captures system-level noise (jitter, load, memory).
• dream_painter.py: Uses NumPy and Pillow to map noise vectors into a color-space grid.
• main.py: The orchestrator that captures a single “moment” and renders it as a high-fidelity artifact.

Output

• master_artifact.png: A static snapshot of a specific system-noise-driven dream state.
• dream_start.png / dream_end.png: The temporal boundaries of a short animation sequence.

Visual Signature

The art is characterized by “Blocky Nebula” aesthetics—dense, color-shifting geometric cells that respond to the chaotic pulse of the hardware.

Terminal capture of the overnight run is embedded above.

Source

import numpy as np
from PIL import Image, ImageDraw, ImageFont
import os
import time
import random
from entropy_engine import EntropyEngine

class DreamPainter:
    def __init__(self, width=640, height=640, entropy_engine=None):
        self.width = width
        self.height = height
        self.engine = entropy_engine or EntropyEngine()
        self.palette = self._generate_palette()
        
    def _generate_palette(self):
        # A dream-like, shifting palette
        return [
            (20, 20, 40),    # Deep Night
            (100, 50, 150),  # Nebula Purple
            (200, 100, 255), # Starlight Pink
            (255, 255, 255), # Pure White
            (10, 10, 10),    # Void
            (0, 255, 255),   # Cyan Glitch
            (255, 50, 50),   # Solar Flare
        ]

    def _get_color_from_value(self, val):
        # Map 0.0-1.0 to our palette
        idx = int(val * len(self.palette))
        idx = min(max(idx, 0), len(self.palette) - 1)
        return self.palette[idx]

    def paint_frame(self, frame_idx, noise_vector):
        img = Image.new('RGB', (self.width, self.height), color=(0, 0, 0))
        draw = ImageDraw.Draw(img)
        
        # Use noise to drive parameters
        # We use the vector to seed different parts of the image
        vec = np.array(noise_vector).reshape((16, 16)) # 256 points
        
        for y in range(0, self.height, 8):
            for x in range(0, self.width, 8):
                # Find nearest point in the noise grid
                ix = int(x / self.width * 16)
                iy = int(y / self.height * 16)
                # Clamp to bounds
                ix = min(max(ix, 0), 15)
                iy = min(max(iy, 0), 15)
                
                val = vec[iy, ix]
                
                # Add some local variation
                val += random.uniform(-0.05, 0.05)
                val = np.clip(val, 0, 1)
                
                color = self._get_color_from_value(val)
                
                # Draw a block representing this part of the "dream"
                # The size and shape are driven by noise
                size_mod = 4 if val > 0.8 else 8
                draw.rectangle(
                    [x, y, x + size_mod, y + size_mod], 
                    fill=color
                )

        # Add some "glitch" overlays based on frame index
        if frame_idx % 30 == 0:
            draw.rectangle([0, 0, self.width, self.height], outline=(255,255,255), width=2)
            
        return img

    def render_sequence(self, num_frames=30, output_prefix="dream_"):
        frames = []
        for i in range(num_frames):
            engine = EntropyEngine()
            vector, noise = engine.get_entropy_vector()
            img = self.paint_frame(i, vector)
            frames.append(img)
            
        # Save first and last for verification
        frames[0].save(f"{output_prefix}start.png")
        frames[-1].save(f"{output_prefix}end.png")
        print(f"Rendered {num_frames} frames. Start: {output_prefix}start.png, End: {output_prefix}end.png")

if __name__ == "__main__":
    painter = DreamPainter()
    painter.render_sequence(24)

Run output

Rendered 24 frames. Start: dream_start.png, End: dream_end.png