Load a WebP image from a URL in Unity

using System.Collections;
using UnityEngine;
using UnityEngine.Networking;

public class WhyItIsBlank : MonoBehaviour
{
    IEnumerator Load(string url)
    {
        // UnityWebRequestTexture.GetTexture decodes as it downloads — and it
        // decodes PNG and JPG. Handed a .webp it gives you a placeholder
        // texture and NO error, which is the blank quad you are looking at.
        using (UnityWebRequest request = UnityWebRequestTexture.GetTexture(url))
        {
            yield return request.SendWebRequest();

            Texture2D texture = DownloadHandlerTexture.GetContent(request);
            GetComponent<Renderer>().material.mainTexture = texture;   // blank
        }
    }

    IEnumerator AlsoBlank(string url)
    {
        using (UnityWebRequest request = UnityWebRequest.Get(url))
        {
            yield return request.SendWebRequest();

            var texture = new Texture2D(2, 2);

            // ImageConversion.LoadImage "Loads PNG, JPG or EXR image byte array
            // into a texture" and returns false for anything else. Most code
            // ignores the bool, keeps the untouched 2x2 texture, and reports a
            // blank image rather than a decode failure.
            if (!texture.LoadImage(request.downloadHandler.data))
            {
                Debug.LogError("Not PNG, JPG or EXR — nothing was decoded.");
            }
        }
    }
}

Neither of these is wrong about the network. Both of them are wrong about the format.

using System;
using System.Collections;
using UnityEngine;
using UnityEngine.Networking;

public class WebpDownload : MonoBehaviour
{
    /// <summary>
    /// Downloads the raw bytes. This part always works — WebP is only a problem
    /// at decode time, never at download time.
    /// </summary>
    public IEnumerator Download(string url, Action<byte[]> onBytes, Action<string> onError)
    {
        using (UnityWebRequest request = UnityWebRequest.Get(url))
        {
            yield return request.SendWebRequest();

            if (request.result != UnityWebRequest.Result.Success)
            {
                onError($"{request.responseCode} {request.error}");
                yield break;
            }

            byte[] bytes = request.downloadHandler.data;

            if (!LooksLikeWebp(bytes))
            {
                // Worth checking before you blame the decoder: a CDN that
                // content-negotiates will hand a Unity client the AVIF or the
                // JPEG, not the .webp the URL names.
                onError("Server did not return a WebP file.");
                yield break;
            }

            onBytes(bytes);
        }
    }

    /// <summary>
    /// RIFF container check, per RFC 9649: "RIFF", a 4-byte length, then "WEBP".
    /// </summary>
    public static bool LooksLikeWebp(byte[] bytes)
    {
        return bytes != null
            && bytes.Length >= 12
            && bytes[0] == 'R' && bytes[1] == 'I' && bytes[2] == 'F' && bytes[3] == 'F'
            && bytes[8] == 'W' && bytes[9] == 'E' && bytes[10] == 'B' && bytes[11] == 'P';
    }
}

The header check is four lines and it has settled a lot of arguments about whose bug it is.

using System.IO;
using System.Security.Cryptography;
using System.Text;
using UnityEngine;

/// <summary>
/// Cache the DOWNLOADED BYTES, not the decoded Texture2D.
///
/// A texture is expensive to hold (width x height x 4 bytes of GPU memory,
/// per image, forever) and cheap to rebuild. The bytes are the opposite.
/// </summary>
public static class WebpByteCache
{
    static string PathFor(string url)
    {
        using (var sha = SHA256.Create())
        {
            byte[] hash = sha.ComputeHash(Encoding.UTF8.GetBytes(url));
            var name = new StringBuilder(hash.Length * 2);
            foreach (byte b in hash)
            {
                name.Append(b.ToString("x2"));
            }
            // temporaryCachePath is the platform's "you may delete this" location.
            return Path.Combine(Application.temporaryCachePath, name + ".webp");
        }
    }

    public static bool TryRead(string url, out byte[] bytes)
    {
        string path = PathFor(url);
        if (File.Exists(path))
        {
            bytes = File.ReadAllBytes(path);
            return true;
        }
        bytes = null;
        return false;
    }

    public static void Write(string url, byte[] bytes)
    {
        // WebGL has no System.IO filesystem — keep the memory half only there.
#if !UNITY_WEBGL || UNITY_EDITOR
        File.WriteAllBytes(PathFor(url), bytes);
#endif
    }
}

A 2048x2048 texture is 16 MB of GPU memory. The bytes behind it are usually under 200 KB.