Skip to content
TheChatArchiveThe Chat Archive
o3-mini· OpenAIHugging Face LMArena Human Preference 140K

Generate me a visually appealing website with moving chromatic and reflecting liquid…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with gpt-4.1-2025-04-14’s answer.
  1. User

    Generate me a visually appealing website with moving chromatic and reflecting liquid that interacts with clicks from the user

  2. Assistant

    Below is an example of a complete HTML file that creates a “chromatic liquid” effect using an HTML5 canvas. In this example, animated “blobs” move around the screen with smooth, shifting color gradients. When you click anywhere on the page, a new liquid blob is introduced at the click location. You can copy the code into an HTML file and open it in your browser to see the effect in action.

    Feel free to tweak the parameters (such as speeds, radii, colors, opacity values, etc.) for a more personalized experience.


    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1" />
      <title>Chromatic Liquid Interaction</title>
      <style>
        html, body {
          margin: 0;
          padding: 0;
          overflow: hidden;
          background: #000;
        }
        canvas {
          position: absolute;
          top: 0;
          left: 0;
          display: block;
        }
      </style>
    </head>
    <body>
      <canvas id="canvas"></canvas>
    
      <script>
        const canvas = document.getElementById('canvas');
        const ctx = canvas.getContext('2d');
        let width, height;
    
        // Adjust canvas size to fit the window
        function resize() {
          width = canvas.width = window.innerWidth;
          height = canvas.height = window.innerHeight;
        }
        window.addEventListener('resize', resize);
        resize();
    
        // Class representing a liquid blob
        class Blob {
          constructor(x, y, radius = Math.random() * 50 + 30) {
            this.x = x;
            this.y = y;
            this.radius = radius;
            // Set a random initial direction and speed
            const angle = Math.random() * Math.PI * 2;
            this.dx = Math.cos(angle) * (Math.random() * 1 + 0.5);
            this.dy = Math.sin(angle) * (Math.random() * 1 + 0.5);
            // Initialize with a random hue for chromatic effect
            this.hue = Math.floor(Math.random() * 360);
          }
          
          update() {
            // Move the blob
            this.x += this.dx;
            this.y += this.dy;
    
            // Bounce off the borders (with a little extra room)
            if (this.x < -this.radius || this.x > width + this.radius) {
              this.dx *= -1;
            }
            if (this.y < -this.radius || this.y > height + this.radius) {
              this.dy *= -1;
            }
            // Slowly change the hue to create a shifting color effect
            this.hue = (this.hue + 0.3) % 360;
          }
          
          draw(ctx) {
            // Create a radial gradient for a reflective, liquid look
            const gradient = ctx.createRadialGradient(
              this.x,
              this.y,
              this.radius * 0.1,
              this.x,
              this.y,
              this.radius
            );
            gradient.addColorStop(0, `hsla(${this.hue}, 100%, 70%, 1)`);
            gradient.addColorStop(0.5, `hsla(${this.hue}, 100%, 50%, 0.8)`);
            gradient.addColorStop(1, `hsla(${this.hue}, 100%, 30%, 0)`);
            
            ctx.fillStyle = gradient;
            ctx.beginPath();
            ctx.arc(this.x, this.y, this.radius, 0, Math.PI * 2);
            ctx.fill();
          }
        }
    
        // Array to store all blobs
        const blobs = [];
    
        // Create a few blobs automatically on startup
        for (let i = 0; i < 5; i++) {
          blobs.push(new Blob(Math.random() * width, Math.random() * height));
        }
    
        // Add a new blob on click
        canvas.addEventListener('click', (event) => {
          const rect = canvas.getBoundingClientRect();
          const x = event.clientX - rect.left;
          const y = event.clientY - rect.top;
          blobs.push(new Blob(x, y));
        });
    
        // Animation loop
        function animate() {
          requestAnimationFrame(animate);
    
          // Clear the canvas with a semi-transparent fill to create smooth trails
          ctx.fillStyle = 'rgba(0, 0, 0, 0.1)';
          ctx.fillRect(0, 0, width, height);
    
          // Use a lighter composite operation to enhance the glowing effect
          ctx.globalCompositeOperation = 'lighter';
    
          // Update and draw each blob
          for (const blob of blobs) {
            blob.update();
            blob.draw(ctx);
          }
    
          // Reset composite operation for the next frame
          ctx.globalCompositeOperation = 'source-over';
        }
    
        animate();
      </script>
    </body>
    </html>
    

    How It Works

    1. Canvas Setup:
      The <canvas> element is set to cover the full viewport. The script ensures that the canvas resizes with the window.

    2. Blob Class:
      Each blob has an (x, y) position, a radius, a velocity (dx, dy), and a hue value that gradually shifts to create a dynamic chromatic effect. The draw() method uses a radial gradient to simulate a reflective, liquid appearance.

    3. Animation Loop:
      The animate() function uses requestAnimationFrame to continuously update and redraw the blobs. A semi-transparent black rectangle is drawn each frame to leave a fading trail, enhancing the liquid look.

    4. Interactivity:
      Clicking on the canvas adds a new blob at that location, allowing you to interact with the liquid simulation.

    This code is a starting point for a visually engaging website. You can further enhance it by adding more physics, interactivity, or even integrating WebGL/shaders for more advanced liquid simulations. Enjoy experimenting!

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