Skip to content
The Chat Archive
Claudeclaude-opus-4-20250514· Anthropic LMArena Human Preference 140K

fill all the letters with random colored pixels each pixel to be 0.5 px

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-pro’s answer.
  1. User

    fill all the letters with random colored pixels each pixel to be 0.5 px

  2. Assistant

    I'll modify the CAPTCHA generator to fill each letter with random colored pixels. Since we can't actually draw 0.5px pixels (the minimum is 1px), I'll use a technique that creates a similar visual effect by drawing 1px pixels with varying opacity to simulate sub-pixel rendering.

    Here's the updated code:

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Pixelated Distorted CAPTCHA Generator</title>
        <style>
            body {
                font-family: Arial, sans-serif;
                text-align: center;
                margin-top: 50px;
                background-color: #f4f4f4;
                color: #333;
            }
            h1 {
                color: #0056b3;
            }
            button {
                padding: 12px 25px;
                font-size: 18px;
                cursor: pointer;
                background-color: #007bff;
                color: white;
                border: none;
                border-radius: 5px;
                transition: background-color 0.3s ease;
            }
            button:hover {
                background-color: #0056b3;
            }
            canvas {
                display: none; /* Hidden, used only for generation */
            }
            p {
                margin-bottom: 25px;
            }
            #preview {
                margin-top: 20px;
                border: 1px solid #ccc;
                display: none;
            }
        </style>
    </head>
    <body>
        <h1>Pixelated Distorted CAPTCHA Generator</h1>
        <p>
            Click the button to generate and download a CAPTCHA image with: <br>
            - Black and white background <br>
            - Letters filled with random colored pixels (gray to black) <br>
            - Letters distorted, shrunk/stretched, and angled <br>
            - 1px blur applied
        </p>
        <button id="generateBtn">Generate and Download Pixelated CAPTCHA</button>
        <canvas id="captchaCanvas"></canvas>
        <canvas id="tempCanvas"></canvas>
    
        <script>
            document.getElementById('generateBtn').addEventListener('click', function() {
                const canvas = document.getElementById('captchaCanvas');
                const ctx = canvas.getContext('2d');
                const tempCanvas = document.getElementById('tempCanvas');
                const tempCtx = tempCanvas.getContext('2d');
                
                // Set canvas size
                canvas.width = 280;
                canvas.height = 70;
                tempCanvas.width = canvas.width;
                tempCanvas.height = canvas.height;
                
                // Generate a random string of 6 alphanumeric characters
                const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
                let captchaText = '';
                for(let i = 0; i < 6; i++) {
                    captchaText += characters.charAt(Math.floor(Math.random() * characters.length));
                }
                
                // Clear both canvases and set white background
                ctx.fillStyle = 'white';
                ctx.fillRect(0, 0, canvas.width, canvas.height);
                tempCtx.fillStyle = 'white';
                tempCtx.fillRect(0, 0, tempCanvas.width, tempCanvas.height);
                
                // Set common font properties
                ctx.font = '40px Arial';
                ctx.textAlign = 'center';
                ctx.textBaseline = 'middle';
                tempCtx.font = '40px Arial';
                tempCtx.textAlign = 'center';
                tempCtx.textBaseline = 'middle';
    
                const letters = captchaText.split('');
                const xIncrement = canvas.width / (letters.length + 1);
                let currentX = xIncrement;
    
                letters.forEach(letter => {
                    // Clear temp canvas
                    tempCtx.clearRect(0, 0, tempCanvas.width, tempCanvas.height);
                    
                    tempCtx.save();
                    
                    // Apply transformations to temp canvas
                    tempCtx.translate(currentX, canvas.height / 2);
                    
                    // Random rotation (-30 to 30 degrees)
                    const randomAngle = (Math.random() * (Math.PI / 3)) - (Math.PI / 6);
                    tempCtx.rotate(randomAngle);
                    
                    // Random scaling
                    const scaleX = 0.7 + Math.random() * 0.6;
                    const scaleY = 0.7 + Math.random() * 0.6;
                    tempCtx.scale(scaleX, scaleY);
                    
                    // Draw letter in black on temp canvas
                    tempCtx.fillStyle = 'black';
                    tempCtx.fillText(letter, 0, 0);
                    
                    tempCtx.restore();
                    
                    // Get the image data from temp canvas
                    const imageData = tempCtx.getImageData(0, 0, tempCanvas.width, tempCanvas.height);
                    const data = imageData.data;
                    
                    // Create a new image data for the pixelated version
                    const pixelatedData = ctx.createImageData(canvas.width, canvas.height);
                    
                    // Process each pixel
                    for (let y = 0; y < tempCanvas.height; y++) {
                        for (let x = 0; x < tempCanvas.width; x++) {
                            const idx = (y * tempCanvas.width + x) * 4;
                            
                            // Check if this pixel is part of the letter (not white)
                            if (data[idx] < 255 || data[idx + 1] < 255 || data[idx + 2] < 255) {
                                // This pixel is part of the letter
                                // Generate random gray value for this pixel
                                const grayValue = Math.floor(Math.random() * 129); // 0 to 128
                                
                                // To simulate 0.5px pixels, we'll use a checkerboard pattern
                                // with varying opacity
                                if ((x + y) % 2 === 0) {
                                    pixelatedData.data[idx] = grayValue;
                                    pixelatedData.data[idx + 1] = grayValue;
                                    pixelatedData.data[idx + 2] = grayValue;
                                    pixelatedData.data[idx + 3] = 255; // Full opacity
                                } else {
                                    // For alternating pixels, use lighter opacity to simulate smaller pixels
                                    pixelatedData.data[idx] = grayValue;
                                    pixelatedData.data[idx + 1] = grayValue;
                                    pixelatedData.data[idx + 2] = grayValue;
                                    pixelatedData.data[idx + 3] = 128; // Half opacity
                                }
                            } else {
                                // Background pixel - keep white
                                pixelatedData.data[idx] = 255;
                                pixelatedData.data[idx + 1] = 255;
                                pixelatedData.data[idx + 2] = 255;
                                pixelatedData.data[idx + 3] = 255;
                            }
                        }
                    }
                    
                    // Put the pixelated image data onto the main canvas
                    ctx.putImageData(pixelatedData, 0, 0);
                    
                    currentX += xIncrement;
                });
                
                // Apply final 1px blur to the entire image
                ctx.filter = 'blur(1px)';
                ctx.drawImage(canvas, 0, 0);
                ctx.filter = 'none';
                
                // Convert canvas to a downloadable image
                const dataURL = canvas.toDataURL('image/png');
                const link = document.createElement('a');
                link.href = dataURL;
                link.download = `captcha_${captchaText}.png`;
                link.click();
            });
        </script>
    </body>
    </html>
    

    This implementation creates a pixelated effect where each letter is filled with random gray-to-black pixels. Here's how it works:

    1. Two-Canvas Approach:

      • A temporary canvas is used to draw each letter with transformations
      • The main canvas receives the pixelated version
    2. Pixel-by-Pixel Processing:

      • Each letter is first drawn normally on the temp canvas
      • The code then reads every pixel to determine if it's part of the letter
      • For pixels that are part of the letter, it assigns a random gray value (0-128)
    3. Simulating 0.5px Pixels:

      • Since we can't actually draw 0.5px pixels, the code uses a checkerboard pattern
      • Alternating pixels have different opacity levels (full vs half)
      • This creates a visual effect similar to sub-pixel rendering
    4. Random Colors:

      • Each pixel that's part of a letter gets its own random gray value
      • This creates a noisy, static-like fill for each character
    5. Final Blur:

      • After all letters are pixelated, a 1px blur is applied to the entire image

    The result is a CAPTCHA where each letter appears to be made up of tiny random-colored pixels, making it more challenging to read while maintaining the distortion effects from before.

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