diff --git a/dotnet/src/MiniExcel.Rust/MiniExcel.Rust.csproj b/dotnet/src/MiniExcel.Rust/MiniExcel.Rust.csproj
index 3201746..3cc1cd4 100644
--- a/dotnet/src/MiniExcel.Rust/MiniExcel.Rust.csproj
+++ b/dotnet/src/MiniExcel.Rust/MiniExcel.Rust.csproj
@@ -29,7 +29,6 @@
 
   <ItemGroup>
     <PackageReference Include="MiniExcel" Version="[1.46.0]" />
-    <PackageReference Include="System.Text.Json" Version="10.0.10" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/dotnet/src/MiniExcel.Rust/MiniExcelBinaryPayload.cs b/dotnet/src/MiniExcel.Rust/MiniExcelBinaryPayload.cs
new file mode 100644
index 0000000..90da468
--- /dev/null
+++ b/dotnet/src/MiniExcel.Rust/MiniExcelBinaryPayload.cs
@@ -0,0 +1,339 @@
+using System.Collections;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace MiniExcelLibs;
+
+internal static class MiniExcelBinaryPayload
+{
+    private const byte Version = 1;
+    private const int MaxDepth = 64;
+
+    private enum PayloadKind : byte
+    {
+        XlsxWrite = 1,
+        CsvWrite = 2,
+        TemplateValue = 3,
+        MappedTemplate = 4
+    }
+
+    private enum ValueKind : byte
+    {
+        Null,
+        Boolean,
+        Int64,
+        UInt64,
+        Double,
+        String,
+        Array,
+        Object,
+        Decimal
+    }
+
+    internal static byte[] EncodeXlsxWrite(
+        IReadOnlyList<string> schema,
+        MiniExcelRustWriteOptions options)
+    {
+        using var stream = CreatePayload(PayloadKind.XlsxWrite, out var writer);
+        using (writer)
+        {
+            WriteStrings(writer, schema);
+            WriteString(writer, options.SheetName);
+            WriteBoolean(writer, options.OverwriteFile);
+            WriteBoolean(writer, options.PrintHeader);
+            WriteBoolean(writer, options.AutoFilter);
+            WriteBoolean(writer, options.RightToLeft);
+            WriteBoolean(writer, options.AutoWidth);
+            WriteBoolean(writer, options.WrapCellContents);
+            writer.Write((byte)options.HorizontalAlignment);
+            writer.Write((byte)options.VerticalAlignment);
+            writer.Write((byte)options.TableStyle);
+            WriteBoolean(writer, options.HeaderWrapText);
+            WriteString(writer, options.HeaderBackgroundColor);
+            writer.Write((byte)options.HeaderHorizontalAlignment);
+            writer.Write((byte)options.HeaderVerticalAlignment);
+            writer.Write(options.MinWidth);
+            writer.Write(options.MaxWidth);
+            writer.Write(options.FreezeRowCount);
+            writer.Write(options.FreezeColumnCount);
+            WriteString(writer, options.DateFormat);
+            WriteString(writer, options.TimeFormat);
+            WriteString(writer, options.DateTimeFormat);
+            WriteString(writer, options.DurationFormat);
+            WriteStringMap(writer, options.ColumnFormats);
+            WriteDoubleMap(writer, options.ColumnWidths);
+            WriteBooleanMap(writer, options.HiddenColumns);
+            WriteStrings(
+                writer,
+                options.DynamicColumns
+                    .Where(column => column.Value.IsFormula)
+                    .Select(column => string.IsNullOrWhiteSpace(column.Value.Name)
+                        ? column.Key
+                        : column.Value.Name!)
+                    .ToArray());
+        }
+        return stream.ToArray();
+    }
+
+    internal static byte[] EncodeCsvWrite(
+        IReadOnlyList<string> schema,
+        MiniExcelRustCsvWriteOptions options)
+    {
+        using var stream = CreatePayload(PayloadKind.CsvWrite, out var writer);
+        using (writer)
+        {
+            WriteStrings(writer, schema);
+            writer.Write(checked((byte)options.Delimiter));
+            writer.Write((byte)options.Encoding);
+            WriteBoolean(writer, options.WriteBom);
+            WriteBoolean(writer, options.PrintHeader);
+            WriteBoolean(writer, options.OverwriteFile);
+        }
+        return stream.ToArray();
+    }
+
+    internal static byte[] EncodeTemplateValue(object? value)
+    {
+        using var stream = CreatePayload(PayloadKind.TemplateValue, out var writer);
+        using (writer)
+            WriteValue(writer, value, 0, new HashSet<object>(ReferenceComparer.Instance));
+        return stream.ToArray();
+    }
+
+    internal static byte[] EncodeMappedTemplate(
+        string sheetName,
+        IEnumerable<MappedCell> cells)
+    {
+        var materialized = cells.ToList();
+        using var stream = CreatePayload(PayloadKind.MappedTemplate, out var writer);
+        using (writer)
+        {
+            WriteString(writer, sheetName);
+            writer.Write(checked((uint)materialized.Count));
+            var ancestors = new HashSet<object>(ReferenceComparer.Instance);
+            foreach (var cell in materialized)
+            {
+                WriteString(writer, cell.Address);
+                WriteBoolean(writer, cell.Formula);
+                WriteValue(writer, cell.Value, 0, ancestors);
+            }
+        }
+        return stream.ToArray();
+    }
+
+    private static MemoryStream CreatePayload(PayloadKind kind, out BinaryWriter writer)
+    {
+        var stream = new MemoryStream();
+        writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen: true);
+        writer.Write(new[] { (byte)'M', (byte)'X', (byte)'B', (byte)'P' });
+        writer.Write(Version);
+        writer.Write((byte)kind);
+        return stream;
+    }
+
+    private static void WriteValue(
+        BinaryWriter writer,
+        object? value,
+        int depth,
+        ISet<object> ancestors)
+    {
+        if (depth > MaxDepth)
+            throw new InvalidOperationException($"Template values cannot exceed {MaxDepth} nested levels.");
+
+        switch (value)
+        {
+            case null:
+            case DBNull:
+                writer.Write((byte)ValueKind.Null);
+                return;
+            case bool boolean:
+                writer.Write((byte)ValueKind.Boolean);
+                WriteBoolean(writer, boolean);
+                return;
+            case byte or sbyte or short or ushort or int or uint or long:
+                writer.Write((byte)ValueKind.Int64);
+                writer.Write(Convert.ToInt64(value, CultureInfo.InvariantCulture));
+                return;
+            case ulong unsigned:
+                writer.Write((byte)ValueKind.UInt64);
+                writer.Write(unsigned);
+                return;
+            case float or double:
+                var number = Convert.ToDouble(value, CultureInfo.InvariantCulture);
+                if (double.IsNaN(number) || double.IsInfinity(number))
+                    throw new ArgumentException("Template numbers must be finite.", nameof(value));
+                writer.Write((byte)ValueKind.Double);
+                writer.Write(number);
+                return;
+            case decimal decimalValue:
+                writer.Write((byte)ValueKind.Decimal);
+                WriteString(writer, decimalValue.ToString(CultureInfo.InvariantCulture));
+                return;
+            case string text:
+                writer.Write((byte)ValueKind.String);
+                WriteString(writer, text);
+                return;
+            case char character:
+                writer.Write((byte)ValueKind.String);
+                WriteString(writer, character.ToString());
+                return;
+            case DateTime dateTime:
+                writer.Write((byte)ValueKind.String);
+                WriteString(writer, dateTime.ToString("O", CultureInfo.InvariantCulture));
+                return;
+            case DateTimeOffset dateTimeOffset:
+                writer.Write((byte)ValueKind.String);
+                WriteString(writer, dateTimeOffset.ToString("O", CultureInfo.InvariantCulture));
+                return;
+            case TimeSpan timeSpan:
+                writer.Write((byte)ValueKind.String);
+                WriteString(writer, timeSpan.ToString("c", CultureInfo.InvariantCulture));
+                return;
+            case Guid or Uri:
+                writer.Write((byte)ValueKind.String);
+                WriteString(writer, Convert.ToString(value, CultureInfo.InvariantCulture)!);
+                return;
+            case byte[] bytes:
+                writer.Write((byte)ValueKind.String);
+                WriteString(writer, Convert.ToBase64String(bytes));
+                return;
+        }
+
+        var type = value.GetType();
+        if (type.IsEnum)
+        {
+            writer.Write((byte)ValueKind.Int64);
+            writer.Write(Convert.ToInt64(value, CultureInfo.InvariantCulture));
+            return;
+        }
+
+        if (!type.IsValueType && !ancestors.Add(value))
+            throw new InvalidOperationException("Template values cannot contain reference cycles.");
+        try
+        {
+            if (value is IDictionary dictionary)
+            {
+                writer.Write((byte)ValueKind.Object);
+                writer.Write(checked((uint)dictionary.Count));
+                foreach (DictionaryEntry entry in dictionary)
+                {
+                    if (entry.Key is not string key)
+                        throw new ArgumentException("Template dictionary keys must be strings.", nameof(value));
+                    WriteString(writer, key);
+                    WriteValue(writer, entry.Value, depth + 1, ancestors);
+                }
+                return;
+            }
+
+            if (value is IEnumerable sequence)
+            {
+                var items = sequence.Cast<object?>().ToList();
+                writer.Write((byte)ValueKind.Array);
+                writer.Write(checked((uint)items.Count));
+                foreach (var item in items)
+                    WriteValue(writer, item, depth + 1, ancestors);
+                return;
+            }
+
+            var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public)
+                .Where(property => property.GetMethod is not null && property.GetIndexParameters().Length == 0)
+                .Where(property => !HasJsonIgnore(property))
+                .ToList();
+            writer.Write((byte)ValueKind.Object);
+            writer.Write(checked((uint)properties.Count));
+            foreach (var property in properties)
+            {
+                WriteString(writer, JsonPropertyName(property));
+                WriteValue(writer, property.GetValue(value), depth + 1, ancestors);
+            }
+        }
+        finally
+        {
+            if (!type.IsValueType)
+                ancestors.Remove(value);
+        }
+    }
+
+    private static bool HasJsonIgnore(MemberInfo member) =>
+        member.CustomAttributes.Any(attribute =>
+            attribute.AttributeType.FullName == "System.Text.Json.Serialization.JsonIgnoreAttribute");
+
+    private static string JsonPropertyName(MemberInfo member)
+    {
+        var attribute = member.CustomAttributes.FirstOrDefault(candidate =>
+            candidate.AttributeType.FullName == "System.Text.Json.Serialization.JsonPropertyNameAttribute");
+        return attribute?.ConstructorArguments.FirstOrDefault().Value as string ?? member.Name;
+    }
+
+    private static void WriteStrings(BinaryWriter writer, IReadOnlyCollection<string> values)
+    {
+        writer.Write(checked((uint)values.Count));
+        foreach (var value in values)
+            WriteString(writer, value);
+    }
+
+    private static void WriteStringMap(BinaryWriter writer, IDictionary<string, string> values)
+    {
+        writer.Write(checked((uint)values.Count));
+        foreach (var value in values)
+        {
+            WriteString(writer, value.Key);
+            WriteString(writer, value.Value);
+        }
+    }
+
+    private static void WriteDoubleMap(BinaryWriter writer, IDictionary<string, double> values)
+    {
+        writer.Write(checked((uint)values.Count));
+        foreach (var value in values)
+        {
+            WriteString(writer, value.Key);
+            writer.Write(value.Value);
+        }
+    }
+
+    private static void WriteBooleanMap(BinaryWriter writer, IDictionary<string, bool> values)
+    {
+        writer.Write(checked((uint)values.Count));
+        foreach (var value in values)
+        {
+            WriteString(writer, value.Key);
+            WriteBoolean(writer, value.Value);
+        }
+    }
+
+    private static void WriteString(BinaryWriter writer, string value)
+    {
+        var bytes = Encoding.UTF8.GetBytes(value);
+        writer.Write(checked((uint)bytes.Length));
+        writer.Write(bytes);
+    }
+
+    private static void WriteBoolean(BinaryWriter writer, bool value) =>
+        writer.Write((byte)(value ? 1 : 0));
+
+    internal readonly struct MappedCell
+    {
+        internal MappedCell(string address, object? value, bool formula)
+        {
+            Address = address;
+            Value = value;
+            Formula = formula;
+        }
+
+        internal string Address { get; }
+        internal object? Value { get; }
+        internal bool Formula { get; }
+    }
+
+    private sealed class ReferenceComparer : IEqualityComparer<object>
+    {
+        internal static readonly ReferenceComparer Instance = new();
+
+        public new bool Equals(object? left, object? right) => ReferenceEquals(left, right);
+
+        public int GetHashCode(object value) => RuntimeHelpers.GetHashCode(value);
+    }
+}
\ No newline at end of file
diff --git a/dotnet/src/MiniExcel.Rust/MiniExcelRust.cs b/dotnet/src/MiniExcel.Rust/MiniExcelRust.cs
index fc65b4e..ce56d51 100644
--- a/dotnet/src/MiniExcel.Rust/MiniExcelRust.cs
+++ b/dotnet/src/MiniExcel.Rust/MiniExcelRust.cs
@@ -4,7 +4,6 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
-using System.Text.Json;
 using Microsoft.Win32.SafeHandles;
 
 namespace MiniExcelLibs;
@@ -1094,13 +1093,14 @@ public static async Task<int> SaveAsAsync<T>(
             if (schema is null)
                 throw new InvalidOperationException("Async export requires at least one row to infer its schema.");
 
-            var payload = JsonSerializer.SerializeToUtf8Bytes(new
-            {
+            var payload = MiniExcelBinaryPayload.EncodeXlsxWrite(
                 schema,
-                sheetName,
-                overwriteFile,
-                printHeader
-            }, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
+                new MiniExcelRustWriteOptions
+                {
+                    SheetName = sheetName,
+                    OverwriteFile = overwriteFile,
+                    PrintHeader = printHeader
+                });
             using var nativePath = new Utf8String(Path.GetFullPath(path));
             using var nativeSpoolPath = new Utf8String(spoolPath);
             using var nativeCancellation = NativeCancellationHandle.Create();
@@ -1262,43 +1262,9 @@ public static int SaveAsWithSchema(
         if (rows is null)
             throw new ArgumentNullException(nameof(rows));
         options ??= new MiniExcelRustWriteOptions();
-        var formulaColumns = options.DynamicColumns
-            .Where(column => column.Value.IsFormula)
-            .Select(column => string.IsNullOrWhiteSpace(column.Value.Name) ? column.Key : column.Value.Name!)
-            .ToArray();
-
         EnsureAbiVersion();
         var frame = EncodeRows(rows);
-        var payload = JsonSerializer.SerializeToUtf8Bytes(new
-        {
-            schema,
-            options.SheetName,
-            options.OverwriteFile,
-            options.PrintHeader,
-            options.AutoFilter,
-            options.RightToLeft,
-            options.AutoWidth,
-            options.WrapCellContents,
-            horizontalAlignment = options.HorizontalAlignment.ToString().ToLowerInvariant(),
-            verticalAlignment = options.VerticalAlignment.ToString().ToLowerInvariant(),
-            tableStyle = options.TableStyle.ToString().ToLowerInvariant(),
-            options.HeaderWrapText,
-            options.HeaderBackgroundColor,
-            headerHorizontalAlignment = options.HeaderHorizontalAlignment.ToString().ToLowerInvariant(),
-            headerVerticalAlignment = options.HeaderVerticalAlignment.ToString().ToLowerInvariant(),
-            options.MinWidth,
-            options.MaxWidth,
-            options.FreezeRowCount,
-            options.FreezeColumnCount,
-            options.DateFormat,
-            options.TimeFormat,
-            options.DateTimeFormat,
-            options.DurationFormat,
-            options.ColumnFormats,
-            options.ColumnWidths,
-            options.HiddenColumns,
-            formulaColumns
-        }, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
+        var payload = MiniExcelBinaryPayload.EncodeXlsxWrite(schema, options);
         using var nativePath = new Utf8String(Path.GetFullPath(path));
         var frameHandle = GCHandle.Alloc(frame, GCHandleType.Pinned);
         var payloadHandle = GCHandle.Alloc(payload, GCHandleType.Pinned);
@@ -1444,15 +1410,7 @@ public static async Task<int> SaveAsCsvAsync<T>(
             }
             if (schema is null)
                 throw new InvalidOperationException("Async CSV export requires at least one row to infer its schema.");
-            var payload = JsonSerializer.SerializeToUtf8Bytes(new
-            {
-                schema,
-                delimiter = (byte)configuration.Delimiter,
-                encoding = (byte)configuration.Encoding,
-                configuration.WriteBom,
-                configuration.PrintHeader,
-                configuration.OverwriteFile
-            }, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
+            var payload = MiniExcelBinaryPayload.EncodeCsvWrite(schema, configuration);
             using var nativePath = new Utf8String(Path.GetFullPath(path));
             using var nativeSpoolPath = new Utf8String(spoolPath);
             using var nativeCancellation = NativeCancellationHandle.Create();
@@ -1812,17 +1770,17 @@ public static void FillTemplate(
             throw new ArgumentNullException(nameof(value));
 
         EnsureAbiVersion();
-        var json = JsonSerializer.SerializeToUtf8Bytes(value, value.GetType());
+        var payload = MiniExcelBinaryPayload.EncodeTemplateValue(value);
         using var nativeDestinationPath = new Utf8String(Path.GetFullPath(destinationPath));
         using var nativeTemplatePath = new Utf8String(Path.GetFullPath(templatePath));
-        var jsonHandle = GCHandle.Alloc(json, GCHandleType.Pinned);
+        var payloadHandle = GCHandle.Alloc(payload, GCHandleType.Pinned);
         try
         {
             var result = NativeMethods.FillTemplate(
                 nativeDestinationPath.Pointer,
                 nativeTemplatePath.Pointer,
-                jsonHandle.AddrOfPinnedObject(),
-                (UIntPtr)(uint)json.Length,
+            payloadHandle.AddrOfPinnedObject(),
+            (UIntPtr)(uint)payload.Length,
                 overwriteFile ? (byte)1 : (byte)0,
                 ignoreMissingVariables ? (byte)1 : (byte)0);
             if (result < 0)
@@ -1830,7 +1788,7 @@ public static void FillTemplate(
         }
         finally
         {
-            jsonHandle.Free();
+            payloadHandle.Free();
         }
     }
 
@@ -2739,7 +2697,7 @@ private static void DeleteTemporaryFile(string? path)
     private static void EnsureAbiVersion()
     {
         var version = NativeMethods.GetAbiVersion();
-        if (version != 1)
+        if (version != 2)
             throw new NotSupportedException($"MiniExcel Rust ABI version {version} is not supported.");
     }
 
@@ -3077,7 +3035,7 @@ internal static extern int SaveAsConfigured(
             IntPtr path,
             IntPtr data,
             UIntPtr dataLength,
-            IntPtr optionsJson,
+            IntPtr optionsData,
             UIntPtr optionsLength,
             out uint rowCount);
 
@@ -3141,8 +3099,8 @@ internal static extern int CopyAndAddSheet(
         internal static extern int FillTemplate(
             IntPtr destinationPath,
             IntPtr templatePath,
-            IntPtr jsonData,
-            UIntPtr jsonLength,
+            IntPtr payloadData,
+            UIntPtr payloadLength,
             byte overwriteFile,
             byte ignoreMissingVariables);
 
@@ -3150,8 +3108,8 @@ internal static extern int FillTemplate(
         internal static extern int FillMappedTemplate(
             IntPtr destinationPath,
             IntPtr templatePath,
-            IntPtr jsonData,
-            UIntPtr jsonLength,
+            IntPtr payloadData,
+            UIntPtr payloadLength,
             byte overwriteFile);
 
         [DllImport(LibraryName, EntryPoint = "miniexcel_merge_same_cells", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
@@ -3177,7 +3135,7 @@ internal static extern int AddPicture(
         internal static extern int SaveAsSpooledAsync(
             IntPtr path,
             IntPtr spoolPath,
-            IntPtr optionsJson,
+            IntPtr optionsData,
             UIntPtr optionsLength,
             NativeCancellationHandle cancellation,
             out uint rowCount);
@@ -3186,7 +3144,7 @@ internal static extern int SaveAsSpooledAsync(
         internal static extern int SaveCsvSpooledAsync(
             IntPtr path,
             IntPtr spoolPath,
-            IntPtr optionsJson,
+            IntPtr optionsData,
             UIntPtr optionsLength,
             NativeCancellationHandle cancellation,
             out uint rowCount);
diff --git a/dotnet/src/MiniExcel.Rust/MiniExcelRustFluentMapping.cs b/dotnet/src/MiniExcel.Rust/MiniExcelRustFluentMapping.cs
index 02ecbec..d51bc68 100644
--- a/dotnet/src/MiniExcel.Rust/MiniExcelRustFluentMapping.cs
+++ b/dotnet/src/MiniExcel.Rust/MiniExcelRustFluentMapping.cs
@@ -2,7 +2,6 @@
 using System.Globalization;
 using System.Linq.Expressions;
 using System.Reflection;
-using System.Text.Json;
 
 namespace MiniExcelLibs;
 
@@ -401,16 +400,12 @@ public int Save(string path, string sheetName, bool overwriteFile)
 
     public byte[] CreateTemplatePayload(string sheetName)
     {
-        return JsonSerializer.SerializeToUtf8Bytes(new
-        {
+        return MiniExcelBinaryPayload.EncodeMappedTemplate(
             sheetName,
-            cells = _values.Select(cell => new
-            {
-                address = $"{ColumnName(cell.Key.Column)}{cell.Key.Row}",
-                value = cell.Value,
-                formula = _formulaCells.Contains(cell.Key)
-            })
-        });
+            _values.Select(cell => new MiniExcelBinaryPayload.MappedCell(
+                $"{ColumnName(cell.Key.Column)}{cell.Key.Row}",
+                cell.Value,
+                _formulaCells.Contains(cell.Key))));
     }
 
     internal static (int Row, int Column) ParseCell(string cellAddress)
diff --git a/dotnet/tests/MiniExcel.Rust.PackageTests/Program.cs b/dotnet/tests/MiniExcel.Rust.PackageTests/Program.cs
index 371d584..eb01100 100644
--- a/dotnet/tests/MiniExcel.Rust.PackageTests/Program.cs
+++ b/dotnet/tests/MiniExcel.Rust.PackageTests/Program.cs
@@ -56,12 +56,84 @@
     var roundTrip = global::MiniExcelLibs.MiniExcel.Query<PackageRow>(outputPath).Single();
     Require(roundTrip.Name == "Grace" && roundTrip.Score == 84, "MiniExcel v1 could not read the Rust-written workbook.");
 
+    var asyncOutputPath = Path.Combine(temporaryDirectory, "async-output.xlsx");
+    var asyncCount = await MiniExcelRust.SaveAsAsync(
+        asyncOutputPath,
+        AsyncRows(new PackageRow { Name = "Katherine", Score = 126 }));
+    Require(asyncCount == 1, "Rust-backed async XLSX write returned an unexpected row count.");
+    Require(
+        global::MiniExcelLibs.MiniExcel.Query<PackageRow>(asyncOutputPath).Single().Name == "Katherine",
+        "MiniExcel v1 could not read the async Rust-written workbook.");
+
     var csvPath = Path.Combine(temporaryDirectory, "input.csv");
     File.WriteAllText(csvPath, "Name;Score\r\nLinus;21\r\n");
     var csvConfiguration = new CsvConfiguration { Seperator = ';' };
     var csvRow = MiniExcelRust.QueryCsv(csvPath, useHeaderRow: true, configuration: csvConfiguration).Single();
     Require((string)csvRow["Name"]! == "Linus", "MiniExcel v1 CSV configuration was not applied.");
 
+    var asyncCsvPath = Path.Combine(temporaryDirectory, "async-output.csv");
+    var asyncCsvCount = await MiniExcelRust.SaveAsCsvAsync(
+        asyncCsvPath,
+        AsyncRows(new PackageRow { Name = "Margaret", Score = 168 }));
+    Require(asyncCsvCount == 1, "Rust-backed async CSV write returned an unexpected row count.");
+    Require(
+        MiniExcelRust.QueryCsv(asyncCsvPath, useHeaderRow: true).Single()["Display Name"]?.ToString() == "Margaret",
+        "Rust could not read the async Rust-written CSV file.");
+
+    var templatePath = Path.Combine(temporaryDirectory, "template.xlsx");
+    MiniExcelRust.SaveAs(
+        templatePath,
+        new[]
+        {
+            new Dictionary<string, object?>
+            {
+                ["A"] = "{{count}}",
+                ["B"] = "{{enabled}}",
+                ["C"] = "Value: {{text}}"
+            },
+            new Dictionary<string, object?>
+            {
+                ["A"] = "{{items.name}}",
+                ["B"] = "{{items.score}}",
+                ["C"] = null
+            }
+        },
+        printHeader: false);
+    var templateOutputPath = Path.Combine(temporaryDirectory, "template-output.xlsx");
+    MiniExcelRust.FillTemplate(
+        templateOutputPath,
+        templatePath,
+        new
+        {
+            count = 42,
+            enabled = true,
+            text = "binary",
+            items = new[]
+            {
+                new { name = "Ada", score = 10 },
+                new { name = "Linus", score = 20 }
+            }
+        });
+    var templateRows = MiniExcelRust.Query(templateOutputPath).ToList();
+    Require(Convert.ToDouble(templateRows[0]["A"]) == 42d, "Binary template number was not applied.");
+    Require((bool)templateRows[0]["B"]!, "Binary template boolean was not applied.");
+    Require(templateRows[0]["C"]?.ToString() == "Value: binary", "Binary template text was not applied.");
+    Require(templateRows[1]["A"]?.ToString() == "Ada", "Binary template list item was not expanded.");
+    Require(Convert.ToDouble(templateRows[2]["B"]) == 20d, "Binary template list value was not expanded.");
+
+    var mappedOutputPath = Path.Combine(temporaryDirectory, "mapped-output.xlsx");
+    var mapping = new MiniExcelRustMapping<PackageRow>().ToWorksheet("Sheet1");
+    mapping.Property(row => row.Name).ToCell("A1");
+    mapping.Property(row => row.Score).ToCell("B1");
+    MiniExcelRustMappingExtensions.FillMappedTemplate(
+        mappedOutputPath,
+        templatePath,
+        new[] { new PackageRow { Name = "Dorothy", Score = 210 } },
+        mapping);
+    var mappedRow = MiniExcelRust.Query(mappedOutputPath).First();
+    Require(mappedRow["A"]?.ToString() == "Dorothy", "Binary mapped-template text was not applied.");
+    Require(Convert.ToDouble(mappedRow["B"]) == 210d, "Binary mapped-template number was not applied.");
+
     Console.WriteLine("MiniExcel.Rust package smoke test passed.");
 }
 finally
@@ -75,6 +147,15 @@ static void Require(bool condition, string message)
         throw new InvalidOperationException(message);
 }
 
+static async IAsyncEnumerable<T> AsyncRows<T>(params T[] rows)
+{
+    foreach (var row in rows)
+    {
+        yield return row;
+        await Task.Yield();
+    }
+}
+
 internal sealed class PackageRow
 {
     [ExcelColumn(Name = "Display Name")]
diff --git a/miniexcel-ffi/src/lib.rs b/miniexcel-ffi/src/lib.rs
index a55e7e0..46c34fe 100644
--- a/miniexcel-ffi/src/lib.rs
+++ b/miniexcel-ffi/src/lib.rs
@@ -21,7 +21,7 @@ use quick_xml::events::{BytesStart, Event};
 use zip::write::SimpleFileOptions;
 use zip::{CompressionMethod, ZipArchive, ZipWriter};
 
-const ABI_VERSION: u32 = 1;
+const ABI_VERSION: u32 = 2;
 const RESULT_END: i32 = 0;
 const RESULT_BATCH: i32 = 1;
 const ERROR_INVALID_ARGUMENT: i32 = -1;
@@ -1040,40 +1040,34 @@ pub unsafe extern "C" fn miniexcel_save_as_sheets(
     })
 }
 
-/// Creates an XLSX workbook from dynamic rows and a JSON write-options payload.
+/// Creates an XLSX workbook from dynamic rows and a binary write-options payload.
 ///
 /// # Safety
 ///
-/// `path`, `data`, `options_json`, and `out_row_count` must be valid for supplied lengths.
+/// `path`, `data`, `options_data`, and `out_row_count` must be valid for supplied lengths.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn miniexcel_save_as_configured(
     path: *const c_char,
     data: *const u8,
     data_length: usize,
-    options_json: *const u8,
+    options_data: *const u8,
     options_length: usize,
     out_row_count: *mut u32,
 ) -> i32 {
     ffi_result(|| {
-        if path.is_null() || data.is_null() || options_json.is_null() || out_row_count.is_null() {
-            set_last_error("path, data, options_json, and out_row_count are required");
+        if path.is_null() || data.is_null() || options_data.is_null() || out_row_count.is_null() {
+            set_last_error("path, data, options_data, and out_row_count are required");
             return Err(ERROR_INVALID_ARGUMENT);
         }
         unsafe { ptr::write(out_row_count, 0) };
         let path = unsafe { read_utf8(path) }?;
         let mut rows = decode_rows(unsafe { std::slice::from_raw_parts(data, data_length) })?;
-        let payload: serde_json::Value = serde_json::from_slice(unsafe {
-            std::slice::from_raw_parts(options_json, options_length)
-        })
-        .map_err(|error| {
-            set_last_error(format!("invalid write-options JSON: {error}"));
-            ERROR_INVALID_ARGUMENT
-        })?;
-        let options = configured_write_options(&payload)?;
-        let schema = configured_schema(&payload)?;
-        let formula_columns = configured_formula_columns(&payload)?;
+        let BinaryXlsxWritePayload { schema, options, formula_columns, overwrite_file } =
+            decode_xlsx_write_payload(unsafe {
+                std::slice::from_raw_parts(options_data, options_length)
+            })?;
         if formula_columns.is_empty() {
-            write_configured_workbook(path, &rows, schema.as_deref(), &options)?;
+            write_configured_workbook(path, &rows, Some(&schema), &options)?;
         } else {
             for row in &mut rows {
                 for column in &formula_columns {
@@ -1100,9 +1094,9 @@ pub unsafe extern "C" fn miniexcel_save_as_configured(
             std::fs::remove_file(&staging).map_err(write_error)?;
             let staging_options = options.clone().with_overwrite_file(false);
             let staging_path: &Path = staging.as_ref();
-            write_configured_workbook(staging_path, &rows, schema.as_deref(), &staging_options)?;
+            write_configured_workbook(staging_path, &rows, Some(&schema), &staging_options)?;
             let template_options = TemplateOptions::new()
-                .with_overwrite_file(json_bool(&payload, "overwriteFile", false)?)
+                .with_overwrite_file(overwrite_file)
                 .with_ignore_missing_variables(true);
             MiniExcel::save_as_template(path, &staging, &serde_json::json!({}), &template_options)
                 .map_err(|error| {
@@ -1123,7 +1117,7 @@ pub unsafe extern "C" fn miniexcel_save_as_configured(
 pub unsafe extern "C" fn miniexcel_save_as_spooled_async(
     path: *const c_char,
     spool_path: *const c_char,
-    options_json: *const u8,
+    options_data: *const u8,
     options_length: usize,
     cancellation: *mut CancellationHandle,
     out_row_count: *mut u32,
@@ -1131,30 +1125,21 @@ pub unsafe extern "C" fn miniexcel_save_as_spooled_async(
     ffi_result(|| {
         if path.is_null()
             || spool_path.is_null()
-            || options_json.is_null()
+            || options_data.is_null()
             || cancellation.is_null()
             || out_row_count.is_null()
         {
             set_last_error(
-                "path, spool_path, options_json, cancellation, and out_row_count are required",
+                "path, spool_path, options_data, cancellation, and out_row_count are required",
             );
             return Err(ERROR_INVALID_ARGUMENT);
         }
         unsafe { ptr::write(out_row_count, 0) };
         let path = unsafe { read_utf8(path) }?;
         let spool_path = unsafe { read_utf8(spool_path) }?;
-        let payload: serde_json::Value = serde_json::from_slice(unsafe {
-            std::slice::from_raw_parts(options_json, options_length)
-        })
-        .map_err(|error| {
-            set_last_error(format!("invalid write-options JSON: {error}"));
-            ERROR_INVALID_ARGUMENT
-        })?;
-        let schema = configured_schema(&payload)?.ok_or_else(|| {
-            set_last_error("async spool export requires an explicit schema");
-            ERROR_INVALID_ARGUMENT
+        let BinaryXlsxWritePayload { schema, options, .. } = decode_xlsx_write_payload(unsafe {
+            std::slice::from_raw_parts(options_data, options_length)
         })?;
-        let options = configured_write_options(&payload)?;
         let rows = SpoolRows::open(spool_path).map_err(write_error)?;
         let rows = futures_util::stream::iter(rows);
         let token = unsafe { &*cancellation }.token.clone();
@@ -1179,7 +1164,7 @@ pub unsafe extern "C" fn miniexcel_save_as_spooled_async(
 pub unsafe extern "C" fn miniexcel_save_csv_spooled_async(
     path: *const c_char,
     spool_path: *const c_char,
-    options_json: *const u8,
+    options_data: *const u8,
     options_length: usize,
     cancellation: *mut CancellationHandle,
     out_row_count: *mut u32,
@@ -1187,48 +1172,28 @@ pub unsafe extern "C" fn miniexcel_save_csv_spooled_async(
     ffi_result(|| {
         if path.is_null()
             || spool_path.is_null()
-            || options_json.is_null()
+            || options_data.is_null()
             || cancellation.is_null()
             || out_row_count.is_null()
         {
             set_last_error(
-                "path, spool_path, options_json, cancellation, and out_row_count are required",
+                "path, spool_path, options_data, cancellation, and out_row_count are required",
             );
             return Err(ERROR_INVALID_ARGUMENT);
         }
         unsafe { ptr::write(out_row_count, 0) };
         let path = unsafe { read_utf8(path) }?;
         let spool_path = unsafe { read_utf8(spool_path) }?;
-        let payload: serde_json::Value = serde_json::from_slice(unsafe {
-            std::slice::from_raw_parts(options_json, options_length)
-        })
-        .map_err(|error| {
-            set_last_error(format!("invalid CSV write-options JSON: {error}"));
-            ERROR_INVALID_ARGUMENT
-        })?;
-        let schema = configured_schema(&payload)?.ok_or_else(|| {
-            set_last_error("async CSV spool export requires an explicit schema");
-            ERROR_INVALID_ARGUMENT
-        })?;
-        let configuration = CsvConfiguration::new()
-            .with_delimiter(
-                json_u64(&payload, "delimiter", b',' as u64)?
-                    .try_into()
-                    .map_err(|_| invalid_write_options("delimiter exceeds one byte"))?,
-            )
-            .with_encoding(parse_csv_encoding(
-                json_u64(&payload, "encoding", 0)?
-                    .try_into()
-                    .map_err(|_| invalid_write_options("encoding exceeds one byte"))?,
-            )?)
-            .with_write_bom(json_bool(&payload, "writeBom", true)?);
+        let BinaryCsvWritePayload { schema, configuration, print_header, overwrite_file } =
+            decode_csv_write_payload(unsafe {
+                std::slice::from_raw_parts(options_data, options_length)
+            })?;
         let options = CsvWriteOptions::new()
             .with_configuration(configuration)
-            .with_print_header(json_bool(&payload, "printHeader", true)?)
+            .with_print_header(print_header)
             .with_overwrite_file(true);
-        let overwrite = json_bool(&payload, "overwriteFile", false)?;
         let destination = Path::new(path);
-        if destination.exists() && !overwrite {
+        if destination.exists() && !overwrite_file {
             set_last_error(format!("destination '{}' already exists", destination.display()));
             return Err(ERROR_WRITE);
         }
@@ -1484,7 +1449,7 @@ pub unsafe extern "C" fn miniexcel_copy_and_add_sheet(
     })
 }
 
-/// Fills an XLSX template from a UTF-8 JSON value and atomically writes the destination.
+/// Fills an XLSX template from a binary value payload and atomically writes the destination.
 ///
 /// # Safety
 ///
@@ -1493,23 +1458,21 @@ pub unsafe extern "C" fn miniexcel_copy_and_add_sheet(
 pub unsafe extern "C" fn miniexcel_fill_template(
     destination_path: *const c_char,
     template_path: *const c_char,
-    json_data: *const u8,
-    json_length: usize,
+    payload_data: *const u8,
+    payload_length: usize,
     overwrite_file: u8,
     ignore_missing_variables: u8,
 ) -> i32 {
     ffi_result(|| {
-        if destination_path.is_null() || template_path.is_null() || json_data.is_null() {
-            set_last_error("destination_path, template_path, and json_data are required");
+        if destination_path.is_null() || template_path.is_null() || payload_data.is_null() {
+            set_last_error("destination_path, template_path, and payload_data are required");
             return Err(ERROR_INVALID_ARGUMENT);
         }
 
         let destination_path = unsafe { read_utf8(destination_path) }?;
         let template_path = unsafe { read_utf8(template_path) }?;
-        let json = unsafe { std::slice::from_raw_parts(json_data, json_length) };
-        let value: serde_json::Value = serde_json::from_slice(json).map_err(|error| {
-            set_last_error(format!("invalid template JSON: {error}"));
-            ERROR_INVALID_ARGUMENT
+        let value = decode_template_value_payload(unsafe {
+            std::slice::from_raw_parts(payload_data, payload_length)
         })?;
         let options = TemplateOptions::new()
             .with_overwrite_file(overwrite_file != 0)
@@ -1533,23 +1496,20 @@ pub unsafe extern "C" fn miniexcel_fill_template(
 pub unsafe extern "C" fn miniexcel_fill_mapped_template(
     destination_path: *const c_char,
     template_path: *const c_char,
-    json_data: *const u8,
-    json_length: usize,
+    payload_data: *const u8,
+    payload_length: usize,
     overwrite_file: u8,
 ) -> i32 {
     ffi_result(|| {
-        if destination_path.is_null() || template_path.is_null() || json_data.is_null() {
-            set_last_error("destination_path, template_path, and json_data are required");
+        if destination_path.is_null() || template_path.is_null() || payload_data.is_null() {
+            set_last_error("destination_path, template_path, and payload_data are required");
             return Err(ERROR_INVALID_ARGUMENT);
         }
         let destination_path = unsafe { read_utf8(destination_path) }?;
         let template_path = unsafe { read_utf8(template_path) }?;
-        let payload: serde_json::Value =
-            serde_json::from_slice(unsafe { std::slice::from_raw_parts(json_data, json_length) })
-                .map_err(|error| {
-                set_last_error(format!("invalid mapped template JSON: {error}"));
-                ERROR_INVALID_ARGUMENT
-            })?;
+        let payload = decode_mapped_template_payload(unsafe {
+            std::slice::from_raw_parts(payload_data, payload_length)
+        })?;
         fill_mapped_template(destination_path, template_path, &payload, overwrite_file != 0)?;
         Ok(RESULT_BATCH)
     })
@@ -2077,40 +2037,200 @@ fn decode_rows(bytes: &[u8]) -> Result<Vec<DynamicRow>, i32> {
     Ok(rows)
 }
 
-fn configured_schema(payload: &serde_json::Value) -> Result<Option<Vec<String>>, i32> {
-    let Some(schema) = payload.get("schema") else {
-        return Ok(None);
-    };
-    let values =
-        schema.as_array().ok_or_else(|| invalid_write_options("schema must be an array"))?;
-    values
-        .iter()
-        .map(|value| {
-            value
-                .as_str()
-                .map(str::to_owned)
-                .ok_or_else(|| invalid_write_options("schema values must be strings"))
-        })
-        .collect::<Result<Vec<_>, _>>()
-        .map(Some)
+struct BinaryXlsxWritePayload {
+    schema: Vec<String>,
+    options: WriteOptions,
+    formula_columns: Vec<String>,
+    overwrite_file: bool,
 }
 
-fn configured_formula_columns(payload: &serde_json::Value) -> Result<Vec<String>, i32> {
-    let Some(columns) = payload.get("formulaColumns") else {
-        return Ok(Vec::new());
+struct BinaryCsvWritePayload {
+    schema: Vec<String>,
+    configuration: CsvConfiguration,
+    print_header: bool,
+    overwrite_file: bool,
+}
+
+struct BinaryMappedTemplatePayload {
+    sheet_name: String,
+    cells: Vec<BinaryMappedCell>,
+}
+
+struct BinaryMappedCell {
+    address: String,
+    value: serde_json::Value,
+    formula: bool,
+}
+
+fn decode_xlsx_write_payload(bytes: &[u8]) -> Result<BinaryXlsxWritePayload, i32> {
+    let mut reader = binary_payload_reader(bytes, 1)?;
+    let schema = reader.read_strings()?;
+    if schema.is_empty() {
+        return Err(invalid_write_options("schema must contain at least one column"));
+    }
+    let sheet_name = reader.read_string()?;
+    let overwrite_file = reader.read_bool()?;
+    let print_header = reader.read_bool()?;
+    let auto_filter = reader.read_bool()?;
+    let right_to_left = reader.read_bool()?;
+    let auto_width = reader.read_bool()?;
+    let wrap_cell_contents = reader.read_bool()?;
+    let horizontal_alignment = parse_binary_horizontal_alignment(reader.read_byte()?)?;
+    let vertical_alignment = parse_binary_vertical_alignment(reader.read_byte()?)?;
+    let table_style = match reader.read_byte()? {
+        0 => TableStyle::None,
+        1 => TableStyle::Default,
+        _ => return Err(invalid_write_options("table style tag is invalid")),
     };
-    let values = columns
-        .as_array()
-        .ok_or_else(|| invalid_write_options("formulaColumns must be an array"))?;
-    values
-        .iter()
-        .map(|value| {
-            value
-                .as_str()
-                .map(str::to_owned)
-                .ok_or_else(|| invalid_write_options("formulaColumns values must be strings"))
-        })
-        .collect()
+    let header_wrap_text = reader.read_bool()?;
+    let header_background_color = parse_rgb_color(&reader.read_string()?)?;
+    let header_horizontal_alignment = parse_binary_horizontal_alignment(reader.read_byte()?)?;
+    let header_vertical_alignment = parse_binary_vertical_alignment(reader.read_byte()?)?;
+    let min_width = reader.read_f64()?;
+    let max_width = reader.read_f64()?;
+    let freeze_row_count = reader.read_u32()?;
+    let freeze_column_count = reader.read_u16()?;
+    let date_format = reader.read_string()?;
+    let time_format = reader.read_string()?;
+    let datetime_format = reader.read_string()?;
+    let duration_format = reader.read_string()?;
+
+    let mut options = WriteOptions::new()
+        .with_sheet_name(sheet_name)
+        .with_overwrite_file(overwrite_file)
+        .with_print_header(print_header)
+        .with_auto_filter(auto_filter)
+        .with_right_to_left(right_to_left)
+        .with_auto_width(auto_width)
+        .with_wrap_cell_contents(wrap_cell_contents)
+        .with_horizontal_alignment(horizontal_alignment)
+        .with_vertical_alignment(vertical_alignment)
+        .with_table_style(table_style)
+        .with_header_style(
+            HeaderStyle::new()
+                .with_wrap_text(header_wrap_text)
+                .with_background_color(header_background_color)
+                .with_horizontal_alignment(header_horizontal_alignment)
+                .with_vertical_alignment(header_vertical_alignment),
+        )
+        .with_min_width(min_width)
+        .with_max_width(max_width)
+        .with_freeze_row_count(freeze_row_count)
+        .with_freeze_column_count(freeze_column_count)
+        .with_date_format(date_format)
+        .with_time_format(time_format)
+        .with_datetime_format(datetime_format)
+        .with_duration_format(duration_format);
+
+    for _ in 0..reader.read_length()? {
+        options = options.with_column_format(reader.read_string()?, reader.read_string()?);
+    }
+    for _ in 0..reader.read_length()? {
+        options = options.with_column_width(reader.read_string()?, reader.read_f64()?);
+    }
+    for _ in 0..reader.read_length()? {
+        options = options.with_column_hidden(reader.read_string()?, reader.read_bool()?);
+    }
+    let formula_columns = reader.read_strings()?;
+    reader.ensure_complete()?;
+    Ok(BinaryXlsxWritePayload { schema, options, formula_columns, overwrite_file })
+}
+
+fn decode_csv_write_payload(bytes: &[u8]) -> Result<BinaryCsvWritePayload, i32> {
+    let mut reader = binary_payload_reader(bytes, 2)?;
+    let schema = reader.read_strings()?;
+    if schema.is_empty() {
+        return Err(invalid_write_options("schema must contain at least one column"));
+    }
+    let configuration = CsvConfiguration::new()
+        .with_delimiter(reader.read_byte()?)
+        .with_encoding(parse_csv_encoding(reader.read_byte()?)?)
+        .with_write_bom(reader.read_bool()?);
+    let print_header = reader.read_bool()?;
+    let overwrite_file = reader.read_bool()?;
+    reader.ensure_complete()?;
+    Ok(BinaryCsvWritePayload { schema, configuration, print_header, overwrite_file })
+}
+
+fn decode_template_value_payload(bytes: &[u8]) -> Result<serde_json::Value, i32> {
+    let mut reader = binary_payload_reader(bytes, 3)?;
+    let value = read_binary_value(&mut reader, 0)?;
+    reader.ensure_complete()?;
+    Ok(value)
+}
+
+fn decode_mapped_template_payload(bytes: &[u8]) -> Result<BinaryMappedTemplatePayload, i32> {
+    let mut reader = binary_payload_reader(bytes, 4)?;
+    let sheet_name = reader.read_string()?;
+    let count = reader.read_length()?;
+    let mut cells = Vec::with_capacity(count);
+    for _ in 0..count {
+        cells.push(BinaryMappedCell {
+            address: reader.read_string()?,
+            formula: reader.read_bool()?,
+            value: read_binary_value(&mut reader, 0)?,
+        });
+    }
+    reader.ensure_complete()?;
+    Ok(BinaryMappedTemplatePayload { sheet_name, cells })
+}
+
+fn read_binary_value(reader: &mut FrameInput<'_>, depth: usize) -> Result<serde_json::Value, i32> {
+    if depth > 64 {
+        set_last_error("binary template value exceeds the maximum nesting depth");
+        return Err(ERROR_INVALID_ARGUMENT);
+    }
+    match reader.read_byte()? {
+        0 => Ok(serde_json::Value::Null),
+        1 => Ok(serde_json::Value::Bool(reader.read_bool()?)),
+        2 => Ok(serde_json::Value::Number(reader.read_i64()?.into())),
+        3 => Ok(serde_json::Value::Number(reader.read_u64()?.into())),
+        4 => serde_json::Number::from_f64(reader.read_f64()?)
+            .map(serde_json::Value::Number)
+            .ok_or_else(|| invalid_write_options("template number must be finite")),
+        5 => Ok(serde_json::Value::String(reader.read_string()?)),
+        6 => {
+            let count = reader.read_length()?;
+            let mut values = Vec::with_capacity(count);
+            for _ in 0..count {
+                values.push(read_binary_value(reader, depth + 1)?);
+            }
+            Ok(serde_json::Value::Array(values))
+        }
+        7 => {
+            let count = reader.read_length()?;
+            let mut values = serde_json::Map::with_capacity(count);
+            for _ in 0..count {
+                values.insert(reader.read_string()?, read_binary_value(reader, depth + 1)?);
+            }
+            Ok(serde_json::Value::Object(values))
+        }
+        8 => {
+            let value = reader.read_string()?;
+            serde_json::Number::from_str(&value)
+                .map(serde_json::Value::Number)
+                .map_err(|_| invalid_write_options("template decimal is invalid"))
+        }
+        _ => Err(invalid_write_options("template value tag is invalid")),
+    }
+}
+
+fn parse_binary_horizontal_alignment(value: u8) -> Result<HorizontalAlignment, i32> {
+    match value {
+        0 => Ok(HorizontalAlignment::Left),
+        1 => Ok(HorizontalAlignment::Center),
+        2 => Ok(HorizontalAlignment::Right),
+        _ => Err(invalid_write_options("horizontal alignment tag is invalid")),
+    }
+}
+
+fn parse_binary_vertical_alignment(value: u8) -> Result<VerticalAlignment, i32> {
+    match value {
+        0 => Ok(VerticalAlignment::Bottom),
+        1 => Ok(VerticalAlignment::Center),
+        2 => Ok(VerticalAlignment::Top),
+        _ => Err(invalid_write_options("vertical alignment tag is invalid")),
+    }
 }
 
 fn write_configured_workbook(
@@ -2144,123 +2264,6 @@ fn publish_staged_file(source: &Path, destination: &Path) -> Result<(), i32> {
     std::fs::rename(source, destination).map_err(write_error)
 }
 
-fn configured_write_options(payload: &serde_json::Value) -> Result<WriteOptions, i32> {
-    let mut options = WriteOptions::new()
-        .with_sheet_name(json_string(payload, "sheetName", "Sheet1")?)
-        .with_overwrite_file(json_bool(payload, "overwriteFile", false)?)
-        .with_print_header(json_bool(payload, "printHeader", true)?)
-        .with_auto_filter(json_bool(payload, "autoFilter", true)?)
-        .with_right_to_left(json_bool(payload, "rightToLeft", false)?)
-        .with_auto_width(json_bool(payload, "autoWidth", false)?)
-        .with_wrap_cell_contents(json_bool(payload, "wrapCellContents", false)?)
-        .with_min_width(json_f64(payload, "minWidth", 8.42857143)?)
-        .with_max_width(json_f64(payload, "maxWidth", 200.0)?)
-        .with_freeze_row_count(
-            json_u64(payload, "freezeRowCount", 1)?
-                .try_into()
-                .map_err(|_| invalid_write_options("freezeRowCount exceeds UInt32"))?,
-        )
-        .with_freeze_column_count(
-            json_u64(payload, "freezeColumnCount", 0)?
-                .try_into()
-                .map_err(|_| invalid_write_options("freezeColumnCount exceeds UInt16"))?,
-        )
-        .with_horizontal_alignment(parse_horizontal_alignment(json_string(
-            payload,
-            "horizontalAlignment",
-            "left",
-        )?)?)
-        .with_vertical_alignment(parse_vertical_alignment(json_string(
-            payload,
-            "verticalAlignment",
-            "bottom",
-        )?)?)
-        .with_table_style(match json_string(payload, "tableStyle", "default")?.as_str() {
-            "none" => TableStyle::None,
-            "default" => TableStyle::Default,
-            _ => return Err(invalid_write_options("tableStyle must be none or default")),
-        });
-    let header_style = HeaderStyle::new()
-        .with_wrap_text(json_bool(payload, "headerWrapText", false)?)
-        .with_background_color(parse_rgb_color(&json_string(
-            payload,
-            "headerBackgroundColor",
-            "4472C4",
-        )?)?)
-        .with_horizontal_alignment(parse_horizontal_alignment(json_string(
-            payload,
-            "headerHorizontalAlignment",
-            "left",
-        )?)?)
-        .with_vertical_alignment(parse_vertical_alignment(json_string(
-            payload,
-            "headerVerticalAlignment",
-            "bottom",
-        )?)?);
-    options = options.with_header_style(header_style);
-    for (property, setter) in
-        [("dateFormat", 0_u8), ("timeFormat", 1), ("dateTimeFormat", 2), ("durationFormat", 3)]
-    {
-        if let Some(value) = payload.get(property).and_then(serde_json::Value::as_str) {
-            options = match setter {
-                0 => options.with_date_format(value),
-                1 => options.with_time_format(value),
-                2 => options.with_datetime_format(value),
-                _ => options.with_duration_format(value),
-            };
-        }
-    }
-    if let Some(values) = payload.get("columnFormats").and_then(serde_json::Value::as_object) {
-        for (name, value) in values {
-            options = options.with_column_format(
-                name,
-                value
-                    .as_str()
-                    .ok_or_else(|| invalid_write_options("columnFormats values must be strings"))?,
-            );
-        }
-    }
-    if let Some(values) = payload.get("columnWidths").and_then(serde_json::Value::as_object) {
-        for (name, value) in values {
-            options = options.with_column_width(
-                name,
-                value
-                    .as_f64()
-                    .ok_or_else(|| invalid_write_options("columnWidths values must be numbers"))?,
-            );
-        }
-    }
-    if let Some(values) = payload.get("hiddenColumns").and_then(serde_json::Value::as_object) {
-        for (name, value) in values {
-            options = options.with_column_hidden(
-                name,
-                value.as_bool().ok_or_else(|| {
-                    invalid_write_options("hiddenColumns values must be booleans")
-                })?,
-            );
-        }
-    }
-    Ok(options)
-}
-
-fn parse_horizontal_alignment(value: String) -> Result<HorizontalAlignment, i32> {
-    match value.as_str() {
-        "left" => Ok(HorizontalAlignment::Left),
-        "center" => Ok(HorizontalAlignment::Center),
-        "right" => Ok(HorizontalAlignment::Right),
-        _ => Err(invalid_write_options("horizontal alignment must be left, center, or right")),
-    }
-}
-
-fn parse_vertical_alignment(value: String) -> Result<VerticalAlignment, i32> {
-    match value.as_str() {
-        "bottom" => Ok(VerticalAlignment::Bottom),
-        "center" => Ok(VerticalAlignment::Center),
-        "top" => Ok(VerticalAlignment::Top),
-        _ => Err(invalid_write_options("vertical alignment must be bottom, center, or top")),
-    }
-}
-
 fn parse_rgb_color(value: &str) -> Result<RgbColor, i32> {
     let value = value.strip_prefix('#').unwrap_or(value);
     if value.len() != 6 {
@@ -2275,43 +2278,6 @@ fn parse_rgb_color(value: &str) -> Result<RgbColor, i32> {
     ))
 }
 
-fn json_string(payload: &serde_json::Value, name: &str, default: &str) -> Result<String, i32> {
-    match payload.get(name) {
-        None => Ok(default.to_owned()),
-        Some(value) => value
-            .as_str()
-            .map(str::to_owned)
-            .ok_or_else(|| invalid_write_options(&format!("{name} must be a string"))),
-    }
-}
-
-fn json_bool(payload: &serde_json::Value, name: &str, default: bool) -> Result<bool, i32> {
-    match payload.get(name) {
-        None => Ok(default),
-        Some(value) => value
-            .as_bool()
-            .ok_or_else(|| invalid_write_options(&format!("{name} must be a boolean"))),
-    }
-}
-
-fn json_f64(payload: &serde_json::Value, name: &str, default: f64) -> Result<f64, i32> {
-    match payload.get(name) {
-        None => Ok(default),
-        Some(value) => {
-            value.as_f64().ok_or_else(|| invalid_write_options(&format!("{name} must be a number")))
-        }
-    }
-}
-
-fn json_u64(payload: &serde_json::Value, name: &str, default: u64) -> Result<u64, i32> {
-    match payload.get(name) {
-        None => Ok(default),
-        Some(value) => value.as_u64().ok_or_else(|| {
-            invalid_write_options(&format!("{name} must be a non-negative integer"))
-        }),
-    }
-}
-
 fn invalid_write_options(message: &str) -> i32 {
     set_last_error(format!("invalid write options: {message}"));
     ERROR_INVALID_ARGUMENT
@@ -2840,17 +2806,10 @@ fn write_rewritten_package(
 fn fill_mapped_template(
     destination_path: &str,
     template_path: &str,
-    payload: &serde_json::Value,
+    payload: &BinaryMappedTemplatePayload,
     overwrite: bool,
 ) -> Result<(), i32> {
-    let sheet_name = payload
-        .get("sheetName")
-        .and_then(serde_json::Value::as_str)
-        .ok_or_else(|| invalid_write_options("sheetName is required"))?;
-    let cells = payload
-        .get("cells")
-        .and_then(serde_json::Value::as_array)
-        .ok_or_else(|| invalid_write_options("cells must be an array"))?;
+    let sheet_name = &payload.sheet_name;
     let file = File::open(template_path).map_err(write_error)?;
     let mut archive = ZipArchive::new(file).map_err(write_error)?;
     let workbook = read_zip_entry(&mut archive, "xl/workbook.xml")?;
@@ -2871,23 +2830,17 @@ fn fill_mapped_template(
         })?);
     let mut worksheet =
         String::from_utf8(read_zip_entry(&mut archive, &worksheet_path)?).map_err(write_error)?;
-    let mut ordered_cells = cells.iter().collect::<Vec<_>>();
+    let mut ordered_cells = payload.cells.iter().collect::<Vec<_>>();
     ordered_cells.sort_by_key(|cell| {
-        let address = cell.get("address").and_then(serde_json::Value::as_str).unwrap_or_default();
         (
-            cell_row_index(address).unwrap_or(usize::MAX),
-            cell_column_index(address).unwrap_or(usize::MAX),
+            cell_row_index(&cell.address).unwrap_or(usize::MAX),
+            cell_column_index(&cell.address).unwrap_or(usize::MAX),
         )
     });
     for cell in ordered_cells {
-        let address = cell
-            .get("address")
-            .and_then(serde_json::Value::as_str)
-            .ok_or_else(|| invalid_write_options("each mapped cell requires an address"))?;
+        let address = &cell.address;
         let row = cell_row_index(address)?;
-        let formula = cell.get("formula").and_then(serde_json::Value::as_bool).unwrap_or(false);
-        let value = cell.get("value").unwrap_or(&serde_json::Value::Null);
-        worksheet = upsert_worksheet_cell(&worksheet, address, row, value, formula)?;
+        worksheet = upsert_worksheet_cell(&worksheet, address, row, &cell.value, cell.formula)?;
     }
     let mut replacements = BTreeMap::new();
     replacements.insert(worksheet_path, worksheet.into_bytes());
@@ -3306,6 +3259,14 @@ impl<'a> FrameInput<'a> {
         Ok(u32::from_le_bytes(value))
     }
 
+    fn read_u16(&mut self) -> Result<u16, i32> {
+        self.ensure_available(2)?;
+        let mut value = [0_u8; 2];
+        value.copy_from_slice(&self.bytes[self.offset..self.offset + 2]);
+        self.offset += 2;
+        Ok(u16::from_le_bytes(value))
+    }
+
     fn read_u64(&mut self) -> Result<u64, i32> {
         self.ensure_available(8)?;
         let mut value = [0_u8; 8];
@@ -3318,6 +3279,21 @@ impl<'a> FrameInput<'a> {
         self.read_u64().map(|value| i64::from_le_bytes(value.to_le_bytes()))
     }
 
+    fn read_f64(&mut self) -> Result<f64, i32> {
+        self.read_u64().map(f64::from_bits)
+    }
+
+    fn read_bool(&mut self) -> Result<bool, i32> {
+        match self.read_byte()? {
+            0 => Ok(false),
+            1 => Ok(true),
+            _ => {
+                set_last_error("binary payload boolean tag is invalid");
+                Err(ERROR_INVALID_ARGUMENT)
+            }
+        }
+    }
+
     fn read_length(&mut self) -> Result<usize, i32> {
         self.read_u32().map(|value| value as usize)
     }
@@ -3335,6 +3311,11 @@ impl<'a> FrameInput<'a> {
         Ok(value)
     }
 
+    fn read_strings(&mut self) -> Result<Vec<String>, i32> {
+        let count = self.read_length()?;
+        (0..count).map(|_| self.read_string()).collect()
+    }
+
     fn ensure_complete(&self) -> Result<(), i32> {
         if self.offset == self.bytes.len() {
             Ok(())
@@ -3354,6 +3335,25 @@ impl<'a> FrameInput<'a> {
     }
 }
 
+fn binary_payload_reader(bytes: &[u8], expected_kind: u8) -> Result<FrameInput<'_>, i32> {
+    let mut reader = FrameInput::new(bytes);
+    let magic =
+        [reader.read_byte()?, reader.read_byte()?, reader.read_byte()?, reader.read_byte()?];
+    if magic != *b"MXBP" {
+        set_last_error("binary payload magic is invalid");
+        return Err(ERROR_INVALID_ARGUMENT);
+    }
+    if reader.read_byte()? != 1 {
+        set_last_error("binary payload version is unsupported");
+        return Err(ERROR_INVALID_ARGUMENT);
+    }
+    if reader.read_byte()? != expected_kind {
+        set_last_error("binary payload kind is invalid");
+        return Err(ERROR_INVALID_ARGUMENT);
+    }
+    Ok(reader)
+}
+
 fn write_length(frame: &mut Vec<u8>, length: usize) -> Result<(), i32> {
     let length = u32::try_from(length).map_err(|_| {
         set_last_error("FFI frame value exceeds the 4 GiB format limit");
@@ -3373,7 +3373,33 @@ mod tests {
 
     #[test]
     fn reports_the_supported_abi_version() {
-        assert_eq!(miniexcel_abi_version(), 1);
+        assert_eq!(miniexcel_abi_version(), 2);
+    }
+
+    #[test]
+    fn rejects_invalid_binary_payload_headers() {
+        assert_eq!(decode_template_value_payload(b"JSON"), Err(ERROR_INVALID_ARGUMENT));
+        assert_eq!(decode_template_value_payload(b"MXBP\x02\x03"), Err(ERROR_INVALID_ARGUMENT));
+        assert_eq!(decode_template_value_payload(b"MXBP\x01\x02"), Err(ERROR_INVALID_ARGUMENT));
+    }
+
+    #[test]
+    fn decodes_nested_binary_template_values() {
+        let mut payload = b"MXBP\x01\x03".to_vec();
+        payload.push(7);
+        write_u32(&mut payload, 1);
+        write_string(&mut payload, "items").unwrap();
+        payload.push(6);
+        write_u32(&mut payload, 2);
+        payload.push(2);
+        payload.extend_from_slice(&10_i64.to_le_bytes());
+        payload.push(5);
+        write_string(&mut payload, "Ada").unwrap();
+
+        assert_eq!(
+            decode_template_value_payload(&payload).unwrap(),
+            serde_json::json!({ "items": [10, "Ada"] })
+        );
     }
 
     #[test]
diff --git a/scripts/dotnet/Verify-Package.ps1 b/scripts/dotnet/Verify-Package.ps1
index 5f929fd..0a22465 100644
--- a/scripts/dotnet/Verify-Package.ps1
+++ b/scripts/dotnet/Verify-Package.ps1
@@ -72,6 +72,10 @@ try {
     if ($dependencies.Count -ne 2 -or $invalidDependencies.Count -ne 0) {
         throw 'Every target framework must depend on MiniExcel [1.46.0].'
     }
+    $jsonDependencies = @($nuspec.SelectNodes('//n:dependency[@id="System.Text.Json"]', $namespace))
+    if ($jsonDependencies.Count -ne 0) {
+        throw 'MiniExcel.Rust must not expose a System.Text.Json package dependency.'
+    }
 }
 finally {
     $archive.Dispose()