Language bindings, KDE thumbnails, yapf compare, in-memory encoding

- yapf_encode() / yapf_free_buffer(): encode to memory; yapf_save uses it
- yapf.c also compiles as C++
- `yapf compare`: size and decode speed of the original format vs YAPF,
  with a lossless check
- bindings with tested examples: C++ (header-only), C# (P/Invoke),
  Rust (crate, builds the C code), Go (cgo), Java (FFM API, Java 22+),
  Zig (@cImport), LuaJIT (FFI), TypeScript types for the JS port;
  Python now encodes in memory
- docs/LANGUAGES.md and examples/ with measured results
- KDE Dolphin thumbnail plugin (KF6, CMake)
- README: honest status for Photoshop / VS Code / Figma (not run in the
  apps yet) and macOS (cross-compiled only), platform table

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

bindings/csharp/Example/Example.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="../Yapf.cs" />
+  </ItemGroup>
+</Project>

bindings/csharp/Example/Program.cs

@@ -0,0 +1,25 @@
+// dotnet run -- ../../../other/YAPF.YAPF   (with yapf.dll / libyapf.so on the library path)
+using System.Diagnostics;
+using Yapf;
+
+string path = args.Length > 0 ? args[0] : "../../../other/YAPF.YAPF";
+byte[] file = File.ReadAllBytes(path);
+
+var img = YapfImage.Decode(file);                 // first call also loads the library / JIT
+double ms = double.MaxValue;                      // best of 10, as in a running program
+for (int i = 0; i < 10; i++)
+{
+    var sw = Stopwatch.StartNew();
+    img = YapfImage.Decode(file);
+    ms = Math.Min(ms, sw.Elapsed.TotalMilliseconds);
+}
+Console.WriteLine($"{path}: {img.Width}x{img.Height}, {img.Channels} channels, decoded in {ms:F2} ms");
+Console.WriteLine($"file is {file.Length} bytes, {100.0 * file.Length / img.Pixels.Length:F1}% of the raw pixels");
+
+byte[] again = img.Encode();
+Console.WriteLine($"re-encoded: {again.Length} bytes, identical: {again.AsSpan().SequenceEqual(file)}");
+
+var rgba = new byte[64 * 64 * 4];
+for (int i = 0; i < rgba.Length; i += 4) { rgba[i] = (byte)(i / 4 % 64 * 4); rgba[i + 1] = 100; rgba[i + 2] = 200; rgba[i + 3] = 255; }
+new YapfImage(64, 64, 4, rgba).Save("csharp.yapf");
+Console.WriteLine("wrote csharp.yapf");

bindings/csharp/README.md

@@ -0,0 +1,19 @@
+# YAPF for C# / .NET
+
+`Yapf.cs` is a single-file P/Invoke wrapper for .NET 6 or later (tested with
+.NET 8).  It should also work in Unity with the native library in
+`Assets/Plugins`, but that is not tested yet.  Add it to your project and put
+the native library next to your program: `yapf.dll` (Windows),
+`libyapf.so` (Linux) or `libyapf.dylib` (macOS) — from the
+[Releases](https://github.com/Nexoniarz/YAPF/releases) or `make`.
+
+```csharp
+using Yapf;
+
+var img = YapfImage.Load("texture.yapf");          // or YapfImage.Decode(bytes)
+byte[] pixels = img.Pixels;                         // Width * Height * Channels
+new YapfImage(256, 256, 4, rgba).Save("out.yapf");  // or .Encode() → byte[]
+```
+
+Example: `cd Example && dotnet run -- ../../../other/YAPF.YAPF`
+(Linux: `LD_LIBRARY_PATH=../../../build dotnet run …` after `make`).

bindings/csharp/Yapf.cs

@@ -0,0 +1,121 @@
+// Yapf.cs — C# bindings for YAPF (P/Invoke).  Copyright 2026 Nexoniarz — Apache 2.0.
+//
+// Needs the native library next to your program or on the library path:
+// yapf.dll (Windows), libyapf.so (Linux), libyapf.dylib (macOS).
+//
+//   var img = YapfImage.Load("texture.yapf");
+//   byte[] pixels = img.Pixels;                 // Width * Height * Channels, rows top to bottom
+//   byte[] file = new YapfImage(256, 256, 4, myRgba).Encode();
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace Yapf
+{
+    public sealed class YapfException : Exception
+    {
+        public YapfException(string message) : base(message) { }
+    }
+
+    public sealed class YapfImage
+    {
+        public const byte FlagPremultipliedAlpha = 1, FlagSrgb = 2;
+
+        public int Width { get; }
+        public int Height { get; }
+        public int Channels { get; }            // 1 gray, 2 gray+alpha, 3 RGB, 4 RGBA
+        public byte Flags { get; }
+        public byte GpuFormat { get; }
+        public byte[] Pixels => Mips[0];
+        public byte[][] Mips { get; }           // Mips[0] is the full-size image
+
+        public YapfImage(int width, int height, int channels, byte[] pixels,
+                         byte flags = FlagSrgb, byte[][]? mips = null)
+        {
+            if (pixels.Length != width * height * channels)
+                throw new ArgumentException("pixels must hold width * height * channels bytes");
+            Width = width; Height = height; Channels = channels; Flags = flags;
+            GpuFormat = channels switch { 4 => (byte)4, 3 => (byte)5, 2 => (byte)2, _ => (byte)3 };
+            Mips = mips ?? new[] { pixels };
+            Mips[0] = pixels;
+        }
+
+        private YapfImage(Native n)
+        {
+            Width = (int)n.width; Height = (int)n.height; Channels = n.channels;
+            Flags = n.flags; GpuFormat = n.gpu_format;
+            Mips = new byte[n.mip_levels][];
+            for (int m = 0; m < n.mip_levels; m++)
+            {
+                int w = Math.Max(1, Width >> m), h = Math.Max(1, Height >> m);
+                Mips[m] = new byte[w * h * Channels];
+                Marshal.Copy(Marshal.ReadIntPtr(n.mips, m * IntPtr.Size), Mips[m], 0, Mips[m].Length);
+            }
+        }
+
+        /// <summary>Decode YAPF bytes.  threads: 1 = calling thread, 0 = all cores.</summary>
+        public static YapfImage Decode(byte[] data, int threads = 1)
+        {
+            IntPtr p = NativeMethods.yapf_load_memory_mt(data, (UIntPtr)data.Length, threads);
+            if (p == IntPtr.Zero) throw new YapfException("not a valid YAPF file");
+            try { return new YapfImage(Marshal.PtrToStructure<Native>(p)); }
+            finally { NativeMethods.yapf_free(p); }
+        }
+
+        public static YapfImage Load(string path, int threads = 1) => Decode(File.ReadAllBytes(path), threads);
+
+        /// <summary>Encode to the bytes of a .yapf file.</summary>
+        public byte[] Encode()
+        {
+            var handles = new GCHandle[Mips.Length];
+            IntPtr table = Marshal.AllocHGlobal(IntPtr.Size * Mips.Length);
+            try
+            {
+                for (int m = 0; m < Mips.Length; m++)
+                {
+                    handles[m] = GCHandle.Alloc(Mips[m], GCHandleType.Pinned);
+                    Marshal.WriteIntPtr(table, m * IntPtr.Size, handles[m].AddrOfPinnedObject());
+                }
+                var n = new Native
+                {
+                    width = (uint)Width, height = (uint)Height, channels = (byte)Channels,
+                    gpu_format = GpuFormat, flags = Flags, mip_levels = (byte)Mips.Length,
+                    pixels = handles[0].AddrOfPinnedObject(), mips = table,
+                };
+                int rc = NativeMethods.yapf_encode(ref n, out IntPtr data, out UIntPtr size);
+                if (rc != 0) throw new YapfException($"yapf_encode failed ({rc})");
+                try
+                {
+                    var bytes = new byte[(int)size];
+                    Marshal.Copy(data, bytes, 0, bytes.Length);
+                    return bytes;
+                }
+                finally { NativeMethods.yapf_free_buffer(data); }
+            }
+            finally
+            {
+                foreach (var h in handles) if (h.IsAllocated) h.Free();
+                Marshal.FreeHGlobal(table);
+            }
+        }
+
+        public void Save(string path) => File.WriteAllBytes(path, Encode());
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct Native
+        {
+            public uint width, height;
+            public byte channels, gpu_format, flags, mip_levels;
+            public IntPtr pixels, mips;
+        }
+
+        private static class NativeMethods
+        {
+            private const string Lib = "yapf";
+            [DllImport(Lib)] public static extern IntPtr yapf_load_memory_mt(byte[] data, UIntPtr size, int threads);
+            [DllImport(Lib)] public static extern void yapf_free(IntPtr img);
+            [DllImport(Lib)] public static extern int yapf_encode(ref Native img, out IntPtr data, out UIntPtr size);
+            [DllImport(Lib)] public static extern void yapf_free_buffer(IntPtr data);
+        }
+    }
+}