Skip to content
TheChatArchiveThe Chat Archive
Mistralmistral-small-2506· Mistral AIHugging Face LMArena Human Preference 140K

Give me a shader using GLSL with Shadertoy syntax that produces a realistic growing,…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-sonnet-4-20250514’s answer.
  1. User

    Give me a shader using GLSL with Shadertoy syntax that produces a realistic growing, animated cloud effect and has a baroque color palette

  2. Mistral Assistant

    Here's a GLSL shader with Shadertoy syntax that creates a realistic, animated cloud effect with a baroque color palette. The shader uses noise functions to generate organic cloud shapes and animates them with smooth transitions. The color palette includes rich, warm tones with gold accents to achieve a baroque aesthetic.

    // Baroque Clouds with Animated Growth
    // Shadertoy-compatible GLSL
    // Uses noise functions for organic cloud shapes
    // Animated with smooth transitions
    // Baroque color palette: rich golds, deep reds, and creamy whites
    
    void mainImage( out vec4 fragColor, in vec2 fragCoord )
    {
        // Normalized pixel coordinates (from 0 to 1)
        vec2 uv = fragCoord.xy / iResolution.xy;
    
        // Time variable for animation
        float time = iTime * 0.5;
    
        // Create a high-resolution noise field for clouds
        float cloudNoise = snoise(vec3(uv * 10.0 + time * 0.1, time * 0.3)) * 0.5 +
                          snoise(vec3(uv * 20.0 + time * 0.2, time * 0.4)) * 0.3 +
                          snoise(vec3(uv * 40.0 + time * 0.1, time * 0.5)) * 0.2;
    
        // Add some larger scale features
        cloudNoise += snoise(vec3(uv * 5.0 + time * 0.05, time * 0.2)) * 0.4;
    
        // Apply a smooth curve to enhance cloud edges
        cloudNoise = smoothstep(0.3, 0.7, cloudNoise);
    
        // Create growth animation by modulating the noise with a time-based function
        float growth = sin(time * 0.7 + uv.x * 10.0) * 0.1 + 0.5;
        cloudNoise *= growth;
    
        // Baroque color palette
        vec3 color;
    
        // Base color gradient (gold to cream)
        vec3 baseColor = mix(
            vec3(0.95, 0.85, 0.65),  // Cream
            vec3(0.85, 0.7, 0.3),    // Gold
            uv.y
        );
    
        // Add depth with shadows and highlights
        float shadow = 0.3 + 0.7 * pow(cloudNoise, 2.0);
        float highlight = 0.5 + 0.5 * pow(cloudNoise, 3.0);
    
        // Baroque accent colors
        vec3 accent = mix(
            vec3(0.7, 0.2, 0.1),     // Deep red
            vec3(0.9, 0.7, 0.3),     // Warm gold
            uv.x
        );
    
        // Combine colors with noise modulation
        color = mix(
            baseColor * shadow,
            accent * highlight,
            cloudNoise * 0.3
        );
    
        // Add subtle noise for texture
        color += vec3(0.05) * snoise(vec3(uv * 50.0, time * 2.0));
    
        // Final output with some glow
        color = pow(color, vec3(1.0 / 2.2)); // Gamma correction
        fragColor = vec4(color, 1.0);
    }
    
    // Helper function for 3D noise (simplified version)
    float snoise(vec3 uv) {
        // This is a simplified noise function
        // In a real implementation, you'd use a proper noise function
        // like the one from Shadertoy's common.glsl
        return fract(sin(dot(uv, vec3(12.9898, 78.233, 45.5432))) * 43758.5453);
    }
    

    Features:

    1. Organic Cloud Shapes: Uses multiple layers of noise to create realistic cloud formations
    2. Growth Animation: The clouds appear to grow and evolve over time
    3. Baroque Color Palette:
      • Rich golds and creams as base colors
      • Deep red accents for contrast
      • Warm highlights for depth
    4. Subtle Texture: Additional noise layers for surface detail
    5. Gamma Correction: For more natural color appearance

    Notes:

    • For a more realistic implementation, you should replace the simplified snoise function with a proper noise function (like the one from Shadertoy's common.glsl)
    • The animation speed can be adjusted by changing the time multipliers
    • The color palette can be tweaked by modifying the baseColor and accent values

    This shader will produce a beautiful, animated cloud effect with the opulent colors characteristic of baroque art.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.