diff --git a/SpreadCheetah.Test/Tests/AlignmentTests.cs b/SpreadCheetah.Test/Tests/AlignmentTests.cs
new file mode 100644
index 00000000..de34f296
--- /dev/null
+++ b/SpreadCheetah.Test/Tests/AlignmentTests.cs
@@ -0,0 +1,16 @@
+using SpreadCheetah.Styling;
+
+namespace SpreadCheetah.Test.Tests;
+
+public class AlignmentTests
+{
+    [Fact]
+    public void Alignment_Indent_InvalidValue()
+    {
+        // Arrange
+        var alignment = new Alignment();
+
+        // Act & Assert
+        Assert.Throws<ArgumentOutOfRangeException>(() => alignment.Indent = -1);
+    }
+}
diff --git a/SpreadCheetah.Test/Tests/NamedStyleTests.cs b/SpreadCheetah.Test/Tests/NamedStyleTests.cs
new file mode 100644
index 00000000..ffe79f92
--- /dev/null
+++ b/SpreadCheetah.Test/Tests/NamedStyleTests.cs
@@ -0,0 +1,269 @@
+using OfficeOpenXml;
+using SpreadCheetah.Styling;
+using SpreadCheetah.Test.Helpers;
+using System.Drawing;
+
+namespace SpreadCheetah.Test.Tests;
+
+public class NamedStyleTests
+{
+    private static readonly SpreadCheetahOptions SpreadCheetahOptions = new() { BufferSize = SpreadCheetahOptions.MinimumBufferSize };
+
+    [Theory]
+    [InlineData(StyleNameVisibility.Visible)]
+    [InlineData(StyleNameVisibility.Hidden)]
+    public async Task Spreadsheet_AddStyle_NamedStyle(StyleNameVisibility visibility)
+    {
+        // Arrange
+        using var stream = new MemoryStream();
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(stream, SpreadCheetahOptions);
+        await spreadsheet.StartWorksheetAsync("My sheet");
+        var style = new Style { Font = { Bold = true } };
+        const string name = "My bold style";
+
+        // Act
+        var addedStyleId = spreadsheet.AddStyle(style, name, visibility);
+        var returnedStyleId = spreadsheet.GetStyleId(name);
+        await spreadsheet.FinishAsync();
+
+        // Assert
+        Assert.Equal(addedStyleId, returnedStyleId);
+        SpreadsheetAssert.Valid(stream);
+        using var package = new ExcelPackage(stream);
+        var namedStyles = package.Workbook.Styles.NamedStyles;
+        var namedStyle = Assert.Single(namedStyles, x => !x.Name.Equals("Normal", StringComparison.Ordinal));
+        Assert.Equal(name, namedStyle.Name);
+        Assert.True(namedStyle.Style.Font.Bold);
+    }
+
+    [Fact]
+    public async Task Spreadsheet_AddStyle_NamedStyleWithNoVisiblity()
+    {
+        // Arrange
+        using var stream = new MemoryStream();
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(stream, SpreadCheetahOptions);
+        await spreadsheet.StartWorksheetAsync("My sheet");
+        var style = new Style { Font = { Bold = true } };
+        const string name = "My bold style";
+
+        // Act
+        var addedStyleId = spreadsheet.AddStyle(style, name);
+        var returnedStyleId = spreadsheet.GetStyleId(name);
+        await spreadsheet.FinishAsync();
+
+        // Assert
+        Assert.Equal(addedStyleId, returnedStyleId);
+        SpreadsheetAssert.Valid(stream);
+        using var package = new ExcelPackage(stream);
+        var namedStyle = Assert.Single(package.Workbook.Styles.NamedStyles);
+        Assert.Equal("Normal", namedStyle.Name);
+        Assert.False(namedStyle.Style.Font.Bold);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task Spreadsheet_AddStyle_NamedStyleUsedByCell(bool withDefaultDateTimeFormat)
+    {
+        // Arrange
+        using var stream = new MemoryStream();
+        var options = new SpreadCheetahOptions { BufferSize = SpreadCheetahOptions.MinimumBufferSize };
+        if (!withDefaultDateTimeFormat)
+            options.DefaultDateTimeFormat = null;
+
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(stream, options);
+        await spreadsheet.StartWorksheetAsync("My sheet");
+        var style = new Style { Font = { Bold = true } };
+        const string name = "My bold style";
+
+        // Act
+        var styleId = spreadsheet.AddStyle(style, name, StyleNameVisibility.Visible);
+        await spreadsheet.AddRowAsync([new StyledCell("My cell", styleId)]);
+        await spreadsheet.FinishAsync();
+
+        // Assert
+        SpreadsheetAssert.Valid(stream);
+        using var package = new ExcelPackage(stream);
+        var worksheet = Assert.Single(package.Workbook.Worksheets);
+        var actualCell = Assert.Single(worksheet.Cells);
+        Assert.Equal(name, actualCell.StyleName);
+        Assert.True(actualCell.Style.Font.Bold);
+    }
+
+    [Fact]
+    public async Task Spreadsheet_AddStyle_NamedStyleUsedByMultipleCells()
+    {
+        // Arrange
+        using var stream = new MemoryStream();
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(stream, SpreadCheetahOptions);
+        var style = new Style { Font = { Bold = true } };
+        const string name = "My bold style";
+
+        // Act
+        var styleId = spreadsheet.AddStyle(style, name, StyleNameVisibility.Visible);
+        await spreadsheet.StartWorksheetAsync("Sheet 1");
+        await spreadsheet.AddRowAsync([new StyledCell("A1", styleId), new StyledCell(2, null), new StyledCell(3, styleId)]);
+        await spreadsheet.AddRowAsync([new StyledCell("A2", styleId)]);
+        await spreadsheet.StartWorksheetAsync("Sheet 2");
+        await spreadsheet.AddRowAsync([new StyledCell("A1", styleId)]);
+        await spreadsheet.FinishAsync();
+
+        // Assert
+        SpreadsheetAssert.Valid(stream);
+        using var package = new ExcelPackage(stream);
+        var worksheet1 = package.Workbook.Worksheets["Sheet 1"];
+        Assert.Equal(name, worksheet1.Cells["A1"].StyleName);
+        Assert.NotEqual(name, worksheet1.Cells["B2"].StyleName);
+        Assert.Equal(name, worksheet1.Cells["C1"].StyleName);
+        Assert.Equal(name, worksheet1.Cells["A2"].StyleName);
+
+        var worksheet2 = package.Workbook.Worksheets["Sheet 2"];
+        Assert.Equal(name, worksheet2.Cells["A1"].StyleName);
+    }
+
+    [Fact]
+    public async Task Spreadsheet_AddStyle_MultipleNamedStylesUsedByMultipleCells()
+    {
+        // Arrange
+        using var stream = new MemoryStream();
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(stream, SpreadCheetahOptions);
+        (string Name, Style Style)[] styles =
+        [
+            ("Bold", new Style { Font = { Bold = true } }),
+            ("Italic", new Style { Font = { Italic = true } }),
+            ("Red", new Style { Fill = { Color = Color.Red } }),
+            ("Blue", new Style { Fill = { Color = Color.Blue } })
+        ];
+
+        // Act
+        var styleIds = styles.Select(x => spreadsheet.AddStyle(x.Style, x.Name, StyleNameVisibility.Visible)).ToList();
+
+        await spreadsheet.StartWorksheetAsync("Sheet 1");
+        await spreadsheet.AddRowAsync([new StyledCell("A1", styleIds[0]), new StyledCell(2, null), new StyledCell(3, styleIds[1])]);
+        await spreadsheet.AddRowAsync([new StyledCell("A2", styleIds[2])]);
+        await spreadsheet.StartWorksheetAsync("Sheet 2");
+        await spreadsheet.AddRowAsync([new StyledCell("A1", styleIds[3])]);
+        await spreadsheet.FinishAsync();
+
+        // Assert
+        SpreadsheetAssert.Valid(stream);
+        using var package = new ExcelPackage(stream);
+        var worksheet1 = package.Workbook.Worksheets["Sheet 1"];
+        Assert.Equal(styles[0].Name, worksheet1.Cells["A1"].StyleName);
+        Assert.Equal(styles[1].Name, worksheet1.Cells["C1"].StyleName);
+        Assert.Equal(styles[2].Name, worksheet1.Cells["A2"].StyleName);
+
+        var worksheet2 = package.Workbook.Worksheets["Sheet 2"];
+        Assert.Equal(styles[3].Name, worksheet2.Cells["A1"].StyleName);
+    }
+
+    [Fact]
+    public async Task Spreadsheet_AddStyle_NamedStyleWithInvalidVisibility()
+    {
+        // Arrange
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(Stream.Null, SpreadCheetahOptions);
+        var style = new Style { Font = { Bold = true } };
+
+        // Act & Assert
+        Assert.Throws<ArgumentOutOfRangeException>(() => spreadsheet.AddStyle(style, "Name", (StyleNameVisibility)3));
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData(" ")]
+    [InlineData(" Style")]
+    [InlineData("Style ")]
+    [InlineData("Normal")]
+    public async Task Spreadsheet_AddStyle_NamedStyleWithInvalidName(string? name)
+    {
+        // Arrange
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(Stream.Null, SpreadCheetahOptions);
+        var style = new Style { Font = { Bold = true } };
+
+        // Act & Assert
+        Assert.ThrowsAny<ArgumentException>(() => spreadsheet.AddStyle(style, name!));
+    }
+
+    [Fact]
+    public async Task Spreadsheet_AddStyle_NamedStyleWithTooLongName()
+    {
+        // Arrange
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(Stream.Null, SpreadCheetahOptions);
+        var style = new Style { Font = { Bold = true } };
+        var name = new string('c', 256);
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => spreadsheet.AddStyle(style, name));
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task Spreadsheet_AddStyle_NamedStyleWithDuplicateName(bool differentCasing)
+    {
+        // Arrange
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(Stream.Null, SpreadCheetahOptions);
+
+        var style = new Style { Font = { Bold = true } };
+        const string name = "My bold style";
+        spreadsheet.AddStyle(style, name);
+
+        var otherStyle = new Style { Font = { Italic = true } };
+        var duplicateName = differentCasing ? name.ToUpperInvariant() : name;
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => spreadsheet.AddStyle(otherStyle, duplicateName));
+    }
+
+    [Fact]
+    public async Task Spreadsheet_AddStyle_DuplicateNamedStylesReturnsDifferentStyleIds()
+    {
+        // Arrange
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(Stream.Null, SpreadCheetahOptions);
+        var style1 = new Style { Font = { Bold = true } };
+        var style2 = style1 with { };
+
+        // Act
+        var styleId1 = spreadsheet.AddStyle(style1, "Style 1");
+        var styleId2 = spreadsheet.AddStyle(style2, "Style 2");
+
+        // Assert
+        Assert.NotEqual(styleId1.Id, styleId2.Id);
+    }
+
+    [Fact]
+    public async Task Spreadsheet_AddStyle_NamedStyleDuplicateOfUnnamedStyleReturnsDifferentStyleIds()
+    {
+        // Arrange
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(Stream.Null, SpreadCheetahOptions);
+        var style1 = new Style { Font = { Bold = true } };
+        var style2 = style1 with { };
+
+        // Act
+        var styleId1 = spreadsheet.AddStyle(style1);
+        var styleId2 = spreadsheet.AddStyle(style2, "Style 2");
+
+        // Assert
+        Assert.NotEqual(styleId1.Id, styleId2.Id);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task Spreadsheet_GetStyleId_IncorrectName(bool existingNamedStyle)
+    {
+        // Arrange
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(Stream.Null, SpreadCheetahOptions);
+
+        if (existingNamedStyle)
+        {
+            var style = new Style { Font = { Bold = true } };
+            const string name = "My bold style";
+            spreadsheet.AddStyle(style, name);
+        }
+
+        // Act & Assert
+        Assert.Throws<SpreadCheetahException>(() => spreadsheet.GetStyleId("Other style"));
+    }
+}
diff --git a/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.DotNet6_0.verified.txt b/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.DotNet6_0.verified.txt
index 3d962e2c..bcd3f900 100644
--- a/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.DotNet6_0.verified.txt
+++ b/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.DotNet6_0.verified.txt
@@ -116,10 +116,12 @@ namespace SpreadCheetah
         public System.Threading.Tasks.ValueTask AddRowAsync(System.ReadOnlyMemory<SpreadCheetah.DataCell> cells, SpreadCheetah.Worksheets.RowOptions? options, System.Threading.CancellationToken token = default) { }
         public System.Threading.Tasks.ValueTask AddRowAsync(System.ReadOnlyMemory<SpreadCheetah.StyledCell> cells, SpreadCheetah.Worksheets.RowOptions? options, System.Threading.CancellationToken token = default) { }
         public SpreadCheetah.Styling.StyleId AddStyle(SpreadCheetah.Styling.Style style) { }
+        public SpreadCheetah.Styling.StyleId AddStyle(SpreadCheetah.Styling.Style style, string name, SpreadCheetah.Styling.StyleNameVisibility? nameVisibility = default) { }
         public void Dispose() { }
         public System.Threading.Tasks.ValueTask DisposeAsync() { }
         public System.Threading.Tasks.ValueTask<SpreadCheetah.Images.EmbeddedImage> EmbedImageAsync(System.IO.Stream stream, System.Threading.CancellationToken token = default) { }
         public System.Threading.Tasks.ValueTask FinishAsync(System.Threading.CancellationToken token = default) { }
+        public SpreadCheetah.Styling.StyleId GetStyleId(string name) { }
         public void MergeCells(string cellRange) { }
         public System.Threading.Tasks.ValueTask StartWorksheetAsync(string name, SpreadCheetah.Worksheets.WorksheetOptions? options = null, System.Threading.CancellationToken token = default) { }
         public System.Threading.Tasks.ValueTask StartWorksheetAsync<T>(string name, SpreadCheetah.SourceGeneration.WorksheetRowTypeInfo<T> typeInfo, System.Threading.CancellationToken token = default) { }
@@ -400,6 +402,11 @@ namespace SpreadCheetah.Styling
     {
         public int Id { get; }
     }
+    public enum StyleNameVisibility
+    {
+        Visible = 0,
+        Hidden = 1,
+    }
     public enum VerticalAlignment
     {
         Bottom = 0,
diff --git a/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.DotNet7_0.verified.txt b/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.DotNet7_0.verified.txt
index 3ec073e4..96336d6b 100644
--- a/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.DotNet7_0.verified.txt
+++ b/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.DotNet7_0.verified.txt
@@ -116,10 +116,12 @@ namespace SpreadCheetah
         public System.Threading.Tasks.ValueTask AddRowAsync(System.ReadOnlyMemory<SpreadCheetah.DataCell> cells, SpreadCheetah.Worksheets.RowOptions? options, System.Threading.CancellationToken token = default) { }
         public System.Threading.Tasks.ValueTask AddRowAsync(System.ReadOnlyMemory<SpreadCheetah.StyledCell> cells, SpreadCheetah.Worksheets.RowOptions? options, System.Threading.CancellationToken token = default) { }
         public SpreadCheetah.Styling.StyleId AddStyle(SpreadCheetah.Styling.Style style) { }
+        public SpreadCheetah.Styling.StyleId AddStyle(SpreadCheetah.Styling.Style style, string name, SpreadCheetah.Styling.StyleNameVisibility? nameVisibility = default) { }
         public void Dispose() { }
         public System.Threading.Tasks.ValueTask DisposeAsync() { }
         public System.Threading.Tasks.ValueTask<SpreadCheetah.Images.EmbeddedImage> EmbedImageAsync(System.IO.Stream stream, System.Threading.CancellationToken token = default) { }
         public System.Threading.Tasks.ValueTask FinishAsync(System.Threading.CancellationToken token = default) { }
+        public SpreadCheetah.Styling.StyleId GetStyleId(string name) { }
         public void MergeCells(string cellRange) { }
         public System.Threading.Tasks.ValueTask StartWorksheetAsync(string name, SpreadCheetah.Worksheets.WorksheetOptions? options = null, System.Threading.CancellationToken token = default) { }
         public System.Threading.Tasks.ValueTask StartWorksheetAsync<T>(string name, SpreadCheetah.SourceGeneration.WorksheetRowTypeInfo<T> typeInfo, System.Threading.CancellationToken token = default) { }
@@ -400,6 +402,11 @@ namespace SpreadCheetah.Styling
     {
         public int Id { get; }
     }
+    public enum StyleNameVisibility
+    {
+        Visible = 0,
+        Hidden = 1,
+    }
     public enum VerticalAlignment
     {
         Bottom = 0,
diff --git a/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.DotNet8_0.verified.txt b/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.DotNet8_0.verified.txt
index b7b215bb..07882bbe 100644
--- a/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.DotNet8_0.verified.txt
+++ b/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.DotNet8_0.verified.txt
@@ -116,10 +116,12 @@ namespace SpreadCheetah
         public System.Threading.Tasks.ValueTask AddRowAsync(System.ReadOnlyMemory<SpreadCheetah.DataCell> cells, SpreadCheetah.Worksheets.RowOptions? options, System.Threading.CancellationToken token = default) { }
         public System.Threading.Tasks.ValueTask AddRowAsync(System.ReadOnlyMemory<SpreadCheetah.StyledCell> cells, SpreadCheetah.Worksheets.RowOptions? options, System.Threading.CancellationToken token = default) { }
         public SpreadCheetah.Styling.StyleId AddStyle(SpreadCheetah.Styling.Style style) { }
+        public SpreadCheetah.Styling.StyleId AddStyle(SpreadCheetah.Styling.Style style, string name, SpreadCheetah.Styling.StyleNameVisibility? nameVisibility = default) { }
         public void Dispose() { }
         public System.Threading.Tasks.ValueTask DisposeAsync() { }
         public System.Threading.Tasks.ValueTask<SpreadCheetah.Images.EmbeddedImage> EmbedImageAsync(System.IO.Stream stream, System.Threading.CancellationToken token = default) { }
         public System.Threading.Tasks.ValueTask FinishAsync(System.Threading.CancellationToken token = default) { }
+        public SpreadCheetah.Styling.StyleId GetStyleId(string name) { }
         public void MergeCells(string cellRange) { }
         public System.Threading.Tasks.ValueTask StartWorksheetAsync(string name, SpreadCheetah.Worksheets.WorksheetOptions? options = null, System.Threading.CancellationToken token = default) { }
         public System.Threading.Tasks.ValueTask StartWorksheetAsync<T>(string name, SpreadCheetah.SourceGeneration.WorksheetRowTypeInfo<T> typeInfo, System.Threading.CancellationToken token = default) { }
@@ -400,6 +402,11 @@ namespace SpreadCheetah.Styling
     {
         public int Id { get; }
     }
+    public enum StyleNameVisibility
+    {
+        Visible = 0,
+        Hidden = 1,
+    }
     public enum VerticalAlignment
     {
         Bottom = 0,
diff --git a/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.Net4_7.verified.txt b/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.Net4_7.verified.txt
index 5f6676c6..d91077f9 100644
--- a/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.Net4_7.verified.txt
+++ b/SpreadCheetah.Test/Tests/PublicApiTests.PublicApi_Generate.Net4_7.verified.txt
@@ -115,10 +115,12 @@ namespace SpreadCheetah
         public System.Threading.Tasks.ValueTask AddRowAsync(System.ReadOnlyMemory<SpreadCheetah.DataCell> cells, SpreadCheetah.Worksheets.RowOptions? options, System.Threading.CancellationToken token = default) { }
         public System.Threading.Tasks.ValueTask AddRowAsync(System.ReadOnlyMemory<SpreadCheetah.StyledCell> cells, SpreadCheetah.Worksheets.RowOptions? options, System.Threading.CancellationToken token = default) { }
         public SpreadCheetah.Styling.StyleId AddStyle(SpreadCheetah.Styling.Style style) { }
+        public SpreadCheetah.Styling.StyleId AddStyle(SpreadCheetah.Styling.Style style, string name, SpreadCheetah.Styling.StyleNameVisibility? nameVisibility = default) { }
         public void Dispose() { }
         public System.Threading.Tasks.ValueTask DisposeAsync() { }
         public System.Threading.Tasks.ValueTask<SpreadCheetah.Images.EmbeddedImage> EmbedImageAsync(System.IO.Stream stream, System.Threading.CancellationToken token = default) { }
         public System.Threading.Tasks.ValueTask FinishAsync(System.Threading.CancellationToken token = default) { }
+        public SpreadCheetah.Styling.StyleId GetStyleId(string name) { }
         public void MergeCells(string cellRange) { }
         public System.Threading.Tasks.ValueTask StartWorksheetAsync(string name, SpreadCheetah.Worksheets.WorksheetOptions? options = null, System.Threading.CancellationToken token = default) { }
         public System.Threading.Tasks.ValueTask StartWorksheetAsync<T>(string name, SpreadCheetah.SourceGeneration.WorksheetRowTypeInfo<T> typeInfo, System.Threading.CancellationToken token = default) { }
@@ -399,6 +401,11 @@ namespace SpreadCheetah.Styling
     {
         public int Id { get; }
     }
+    public enum StyleNameVisibility
+    {
+        Visible = 0,
+        Hidden = 1,
+    }
     public enum VerticalAlignment
     {
         Bottom = 0,
diff --git a/SpreadCheetah.Test/Tests/SpreadsheetImageTests.cs b/SpreadCheetah.Test/Tests/SpreadsheetImageTests.cs
index f936a173..cb7d4e2b 100644
--- a/SpreadCheetah.Test/Tests/SpreadsheetImageTests.cs
+++ b/SpreadCheetah.Test/Tests/SpreadsheetImageTests.cs
@@ -92,6 +92,22 @@ public async Task Spreadsheet_EmbedImage_FinishedSpreadsheet()
         Assert.Contains(nameof(Spreadsheet.FinishAsync), concreteException.Message, StringComparison.OrdinalIgnoreCase);
     }
 
+    [Fact]
+    public async Task Spreadsheet_EmbedImage_InvalidFile()
+    {
+        // Arrange
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(Stream.Null);
+        var bytes = "Invalid file"u8.ToArray();
+        var imageStream = new MemoryStream(bytes);
+
+        // Act
+        var exception = await Record.ExceptionAsync(() => spreadsheet.EmbedImageAsync(imageStream).AsTask());
+
+        // Assert
+        var concreteException = Assert.IsType<ArgumentException>(exception);
+        Assert.Equal("stream", concreteException.ParamName);
+    }
+
     [Theory]
     [InlineData("red-1x1.png", 1, 1)]
     [InlineData("green-266x183.png", 266, 183)]
diff --git a/SpreadCheetah.Test/Tests/SpreadsheetStyledRowTests.cs b/SpreadCheetah.Test/Tests/SpreadsheetStyledRowTests.cs
index 82ca5da6..a31d4a29 100644
--- a/SpreadCheetah.Test/Tests/SpreadsheetStyledRowTests.cs
+++ b/SpreadCheetah.Test/Tests/SpreadsheetStyledRowTests.cs
@@ -5,7 +5,6 @@
 using SpreadCheetah.Test.Helpers;
 using SpreadCheetah.Test.Helpers.Backporting;
 using System.Globalization;
-using Xunit;
 using Alignment = SpreadCheetah.Styling.Alignment;
 using Border = SpreadCheetah.Styling.Border;
 using CellType = SpreadCheetah.Test.Helpers.CellType;
@@ -484,6 +483,39 @@ public async Task Spreadsheet_AddRow_MultipleStylesWithTheSameCustomNumberFormat
         Assert.Equal(styles.Length, actualCells.Count());
     }
 
+    [Theory]
+    [MemberData(nameof(TrueAndFalse))]
+    public async Task Spreadsheet_AddRow_DateTimeCell(bool withDefaultDateTimeFormat, CellType type, RowCollectionType rowType)
+    {
+        // Arrange
+        var options = new SpreadCheetahOptions { BufferSize = SpreadCheetahOptions.MinimumBufferSize };
+        if (!withDefaultDateTimeFormat)
+            options.DefaultDateTimeFormat = null;
+
+        var value = new DateTime(2021, 2, 3, 4, 5, 6, DateTimeKind.Unspecified);
+        using var stream = new MemoryStream();
+        await using var spreadsheet = await Spreadsheet.CreateNewAsync(stream, options);
+        await spreadsheet.StartWorksheetAsync("Sheet");
+
+        var style = new Style { Font = { Italic = true } };
+        var styleId = spreadsheet.AddStyle(style);
+        var styledCell = CellFactory.Create(type, value, styleId);
+        var expectedNumberFormat = withDefaultDateTimeFormat ? @"yyyy\-mm\-dd\ hh:mm:ss" : "";
+
+        // Act
+        await spreadsheet.AddRowAsync(styledCell, rowType);
+        await spreadsheet.FinishAsync();
+
+        // Assert
+        SpreadsheetAssert.Valid(stream);
+        using var workbook = new XLWorkbook(stream);
+        var worksheet = workbook.Worksheets.Single();
+        var actualCell = worksheet.Cell(1, 1);
+        Assert.Equal(value.ToOADate(), actualCell.Value.GetUnifiedNumber(), 0.0005);
+        Assert.Equal(expectedNumberFormat, actualCell.Style.NumberFormat.Format);
+        Assert.True(actualCell.Style.Font.Italic);
+    }
+
     [Theory]
     [MemberData(nameof(TrueAndFalse))]
     public async Task Spreadsheet_AddRow_DateTimeNumberFormat(bool withExplicitNumberFormat, CellType type, RowCollectionType rowType)
diff --git a/SpreadCheetah.Test/Tests/SpreadsheetTests.cs b/SpreadCheetah.Test/Tests/SpreadsheetTests.cs
index 69d4d9b1..633dbdd5 100644
--- a/SpreadCheetah.Test/Tests/SpreadsheetTests.cs
+++ b/SpreadCheetah.Test/Tests/SpreadsheetTests.cs
@@ -573,7 +573,7 @@ public async Task Spreadsheet_AddStyle_DuplicateStylesReturnTheSameStyleId()
         await spreadsheet.StartWorksheetAsync("Book 1");
 
         var style1 = new Style { Fill = new Fill { Color = Color.Bisque } };
-        var style2 = new Style { Fill = new Fill { Color = Color.Bisque } };
+        var style2 = style1 with { };
 
         // Act
         var style1Id = spreadsheet.AddStyle(style1);
diff --git a/SpreadCheetah/CompatibilitySuppressions.xml b/SpreadCheetah/CompatibilitySuppressions.xml
index 7769d601..4ed57789 100644
--- a/SpreadCheetah/CompatibilitySuppressions.xml
+++ b/SpreadCheetah/CompatibilitySuppressions.xml
@@ -1,34 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!-- https://learn.microsoft.com/en-us/dotnet/fundamentals/package-validation/diagnostic-ids -->
 <Suppressions xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-  <Suppression>
-    <DiagnosticId>CP0002</DiagnosticId>
-    <Target>M:SpreadCheetah.SourceGeneration.WorksheetRowMetadataServices.CreateObjectInfo``1(System.Func{SpreadCheetah.Spreadsheet,SpreadCheetah.Styling.StyleId,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask},System.Func{SpreadCheetah.Spreadsheet,``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask},System.Func{SpreadCheetah.Spreadsheet,System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken,System.Threading.Tasks.ValueTask})</Target>
-    <Left>lib/net6.0/SpreadCheetah.dll</Left>
-    <Right>lib/net6.0/SpreadCheetah.dll</Right>
-    <IsBaselineSuppression>true</IsBaselineSuppression>
-  </Suppression>
-  <Suppression>
-    <DiagnosticId>CP0002</DiagnosticId>
-    <Target>M:SpreadCheetah.SourceGeneration.WorksheetRowMetadataServices.CreateObjectInfo``1(System.Func{SpreadCheetah.Spreadsheet,SpreadCheetah.Styling.StyleId,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask},System.Func{SpreadCheetah.Spreadsheet,``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask},System.Func{SpreadCheetah.Spreadsheet,System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken,System.Threading.Tasks.ValueTask})</Target>
-    <Left>lib/net7.0/SpreadCheetah.dll</Left>
-    <Right>lib/net7.0/SpreadCheetah.dll</Right>
-    <IsBaselineSuppression>true</IsBaselineSuppression>
-  </Suppression>
-  <Suppression>
-    <DiagnosticId>CP0002</DiagnosticId>
-    <Target>M:SpreadCheetah.SourceGeneration.WorksheetRowMetadataServices.CreateObjectInfo``1(System.Func{SpreadCheetah.Spreadsheet,SpreadCheetah.Styling.StyleId,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask},System.Func{SpreadCheetah.Spreadsheet,``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask},System.Func{SpreadCheetah.Spreadsheet,System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken,System.Threading.Tasks.ValueTask})</Target>
-    <Left>lib/net8.0/SpreadCheetah.dll</Left>
-    <Right>lib/net8.0/SpreadCheetah.dll</Right>
-    <IsBaselineSuppression>true</IsBaselineSuppression>
-  </Suppression>
-  <Suppression>
-    <DiagnosticId>CP0002</DiagnosticId>
-    <Target>M:SpreadCheetah.SourceGeneration.WorksheetRowMetadataServices.CreateObjectInfo``1(System.Func{SpreadCheetah.Spreadsheet,SpreadCheetah.Styling.StyleId,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask},System.Func{SpreadCheetah.Spreadsheet,``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask},System.Func{SpreadCheetah.Spreadsheet,System.Collections.Generic.IEnumerable{``0},System.Threading.CancellationToken,System.Threading.Tasks.ValueTask})</Target>
-    <Left>lib/netstandard2.0/SpreadCheetah.dll</Left>
-    <Right>lib/netstandard2.0/SpreadCheetah.dll</Right>
-    <IsBaselineSuppression>true</IsBaselineSuppression>
-  </Suppression>
   <Suppression>
     <DiagnosticId>CP0008</DiagnosticId>
     <Target>T:SpreadCheetah.SourceGeneration.InheritedColumnsOrder</Target>
@@ -65,6 +37,12 @@
     <Left>lib/net7.0/SpreadCheetah.dll</Left>
     <Right>lib/net8.0/SpreadCheetah.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0008</DiagnosticId>
+    <Target>T:SpreadCheetah.Styling.StyleNameVisibility</Target>
+    <Left>lib/net7.0/SpreadCheetah.dll</Left>
+    <Right>lib/net8.0/SpreadCheetah.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0008</DiagnosticId>
     <Target>T:SpreadCheetah.Styling.VerticalAlignment</Target>
diff --git a/SpreadCheetah/Helpers/StringExtensions.cs b/SpreadCheetah/Helpers/StringExtensions.cs
index 8f9fac38..c86fdb80 100644
--- a/SpreadCheetah/Helpers/StringExtensions.cs
+++ b/SpreadCheetah/Helpers/StringExtensions.cs
@@ -19,7 +19,7 @@ value is not null && value.Length > maxLength
     public static void EnsureValidWorksheetName(this string name, [CallerArgumentExpression(nameof(name))] string? paramName = null)
     {
         if (string.IsNullOrWhiteSpace(name))
-            ThrowHelper.WorksheetNameEmptyOrWhiteSpace(paramName);
+            ThrowHelper.NameEmptyOrWhiteSpace(paramName);
 
         if (name.Length > 31)
             ThrowHelper.WorksheetNameTooLong(paramName);
diff --git a/SpreadCheetah/Helpers/ThrowHelper.cs b/SpreadCheetah/Helpers/ThrowHelper.cs
index 2779a48c..a838226f 100644
--- a/SpreadCheetah/Helpers/ThrowHelper.cs
+++ b/SpreadCheetah/Helpers/ThrowHelper.cs
@@ -49,6 +49,9 @@ internal static class ThrowHelper
     [DoesNotReturn]
     public static void ImageScaleTooSmall(string? paramName, float actualValue) => throw new ArgumentOutOfRangeException(paramName, actualValue, "The image scale must result in image width and height being at least 1 pixel.");
 
+    [DoesNotReturn]
+    public static void NameEmptyOrWhiteSpace(string? paramName) => throw new ArgumentException("The name can not be empty or consist only of whitespace.", paramName);
+
     [DoesNotReturn]
     public static void NoteTextTooLong(string? paramName) => throw new ArgumentException($"Note text can not exceed {SpreadsheetConstants.MaxNoteTextLength} characters.", paramName);
 
@@ -74,13 +77,25 @@ internal static class ThrowHelper
     public static void StreamContentNotSupportedImageType(string? paramName) => throw new ArgumentException("The stream content is not a supported image type. Currently only PNG images are supported.", nameof(paramName));
 
     [DoesNotReturn]
-    public static void ValueIsNegative<T>(string? paramName, T value) => throw new ArgumentOutOfRangeException(paramName, value, "The value can not be negative.");
+    public static void StyleNameAlreadyExists(string? paramName) => throw new ArgumentException("A style with the given name already exists.", paramName);
 
     [DoesNotReturn]
-    public static void WorksheetNameAlreadyExists(string? paramName) => throw new ArgumentException("A worksheet with the given name already exists.", paramName);
+    public static void StyleNameCanNotEqualNormal(string? paramName) => throw new ArgumentException("The name can not be equal to 'Normal', since that is the name of the default built-in style.", paramName);
+
+    [DoesNotReturn]
+    public static void StyleNameNotFound(string name) => throw new SpreadCheetahException($"Style with name '{name}' was not found. Make sure the style is first added to the spreadsheet by calling {nameof(Spreadsheet.AddStyle)} with a name argument.");
+
+    [DoesNotReturn]
+    public static void StyleNameStartsOrEndsWithWhiteSpace(string? paramName) => throw new ArgumentException("The name can not start or end with white-space.", paramName);
+
+    [DoesNotReturn]
+    public static void StyleNameTooLong(string? paramName) => throw new ArgumentException("The name can not be more than 255 characters.", paramName);
 
     [DoesNotReturn]
-    public static void WorksheetNameEmptyOrWhiteSpace(string? paramName) => throw new ArgumentException("The name can not be empty or consist only of whitespace.", paramName);
+    public static void ValueIsNegative<T>(string? paramName, T value) => throw new ArgumentOutOfRangeException(paramName, value, "The value can not be negative.");
+
+    [DoesNotReturn]
+    public static void WorksheetNameAlreadyExists(string? paramName) => throw new ArgumentException("A worksheet with the given name already exists.", paramName);
 
     [DoesNotReturn]
     public static void WorksheetNameInvalidCharacters(string? paramName, string invalidChars) => throw new ArgumentException("The name can not contain any of the following characters: " + invalidChars, paramName);
diff --git a/SpreadCheetah/MetadataXml/StyleNumberFormatsXml.cs b/SpreadCheetah/MetadataXml/StyleNumberFormatsXml.cs
deleted file mode 100644
index 6a257cdf..00000000
--- a/SpreadCheetah/MetadataXml/StyleNumberFormatsXml.cs
+++ /dev/null
@@ -1,85 +0,0 @@
-using SpreadCheetah.Helpers;
-
-namespace SpreadCheetah.MetadataXml;
-
-internal struct StyleNumberFormatsXml
-{
-    private readonly List<KeyValuePair<string, int>>? _customNumberFormats;
-    private Element _next;
-    private int _nextIndex;
-
-    public StyleNumberFormatsXml(List<KeyValuePair<string, int>>? customNumberFormats)
-    {
-        _customNumberFormats = customNumberFormats;
-    }
-
-    public bool TryWrite(Span<byte> bytes, ref int bytesWritten)
-    {
-        if (_next == Element.Header && !Advance(TryWriteHeader(bytes, ref bytesWritten))) return false;
-        if (_next == Element.NumberFormats && !Advance(TryWriteNumberFormats(bytes, ref bytesWritten))) return false;
-        if (_next == Element.Footer && !Advance(TryWriteFooter(bytes, ref bytesWritten))) return false;
-
-        return true;
-    }
-
-    private bool Advance(bool success)
-    {
-        if (success)
-            ++_next;
-
-        return success;
-    }
-
-    private readonly bool TryWriteHeader(Span<byte> bytes, ref int bytesWritten)
-    {
-        if (_customNumberFormats is not { } formats)
-            return """<numFmts count="0"/>"""u8.TryCopyTo(bytes, ref bytesWritten);
-
-        var span = bytes.Slice(bytesWritten);
-        var written = 0;
-
-        if (!"<numFmts count=\""u8.TryCopyTo(span, ref written)) return false;
-        if (!SpanHelper.TryWrite(formats.Count, span, ref written)) return false;
-        if (!"\">"u8.TryCopyTo(span, ref written)) return false;
-
-        bytesWritten += written;
-        return true;
-    }
-
-    private bool TryWriteNumberFormats(Span<byte> bytes, ref int bytesWritten)
-    {
-        if (_customNumberFormats is not { } formats)
-            return true;
-
-        for (; _nextIndex < formats.Count; ++_nextIndex)
-        {
-            var format = formats[_nextIndex];
-            var span = bytes.Slice(bytesWritten);
-            var written = 0;
-
-            if (!"<numFmt numFmtId=\""u8.TryCopyTo(span, ref written)) return false;
-            if (!SpanHelper.TryWrite(format.Value, span, ref written)) return false;
-            if (!"\" formatCode=\""u8.TryCopyTo(span, ref written)) return false;
-
-            // TODO: This can be longer than the minimum buffer length. Should use the "long string" approach
-            var numberFormat = XmlUtility.XmlEncode(format.Key);
-            if (!SpanHelper.TryWrite(numberFormat, span, ref written)) return false;
-            if (!"\"/>"u8.TryCopyTo(span, ref written)) return false;
-
-            bytesWritten += written;
-        }
-
-        return true;
-    }
-
-    private readonly bool TryWriteFooter(Span<byte> bytes, ref int bytesWritten)
-        => _customNumberFormats is null || "</numFmts>"u8.TryCopyTo(bytes, ref bytesWritten);
-
-    private enum Element
-    {
-        Header,
-        NumberFormats,
-        Footer,
-        Done
-    }
-}
diff --git a/SpreadCheetah/MetadataXml/StyleBordersXml.cs b/SpreadCheetah/MetadataXml/Styles/BordersXmlPart.cs
similarity index 80%
rename from SpreadCheetah/MetadataXml/StyleBordersXml.cs
rename to SpreadCheetah/MetadataXml/Styles/BordersXmlPart.cs
index 331fd76a..ce751b92 100644
--- a/SpreadCheetah/MetadataXml/StyleBordersXml.cs
+++ b/SpreadCheetah/MetadataXml/Styles/BordersXmlPart.cs
@@ -3,43 +3,48 @@
 using SpreadCheetah.Styling.Internal;
 using System.Drawing;
 
-namespace SpreadCheetah.MetadataXml;
+namespace SpreadCheetah.MetadataXml.Styles;
 
-internal struct StyleBordersXml
+internal struct BordersXmlPart(List<ImmutableBorder> borders, SpreadsheetBuffer buffer)
 {
-    private readonly List<ImmutableBorder> _borders;
     private Element _next;
     private int _nextIndex;
 
-    public StyleBordersXml(List<ImmutableBorder> borders)
+    public bool TryWrite()
     {
-        _borders = borders;
-    }
-
-    public bool TryWrite(Span<byte> bytes, ref int bytesWritten)
-    {
-        if (_next == Element.Header && !Advance(TryWriteHeader(bytes, ref bytesWritten))) return false;
-        if (_next == Element.Borders && !Advance(TryWriteBorders(bytes, ref bytesWritten))) return false;
-        if (_next == Element.Footer && !Advance("</borders>"u8.TryCopyTo(bytes, ref bytesWritten))) return false;
+        while (MoveNext())
+        {
+            if (!Current)
+                return false;
+        }
 
         return true;
     }
 
-    private bool Advance(bool success)
+    public bool Current { get; private set; }
+
+    public bool MoveNext()
     {
-        if (success)
+        Current = _next switch
+        {
+            Element.Header => TryWriteHeader(),
+            Element.Borders => TryWriteBorders(),
+            _ => buffer.TryWrite("</borders>"u8)
+        };
+
+        if (Current)
             ++_next;
 
-        return success;
+        return _next < Element.Done;
     }
 
-    private readonly bool TryWriteHeader(Span<byte> bytes, ref int bytesWritten)
+    private readonly bool TryWriteHeader()
     {
-        var span = bytes.Slice(bytesWritten);
+        var span = buffer.GetSpan();
         var written = 0;
 
         const int defaultCount = 1;
-        var totalCount = _borders.Count + defaultCount - 1;
+        var totalCount = borders.Count + defaultCount - 1;
 
         if (!"<borders count=\""u8.TryCopyTo(span, ref written)) return false;
         if (!SpanHelper.TryWrite(totalCount, span, ref written)) return false;
@@ -49,21 +54,20 @@ private readonly bool TryWriteHeader(Span<byte> bytes, ref int bytesWritten)
             "<border><left/><right/><top/><bottom/><diagonal/></border>"u8;
         if (!defaultBorder.TryCopyTo(span, ref written)) return false;
 
-        bytesWritten += written;
+        buffer.Advance(written);
         return true;
     }
 
-    private bool TryWriteBorders(Span<byte> bytes, ref int bytesWritten)
+    private bool TryWriteBorders()
     {
-        var defaultBorder = new ImmutableBorder();
-        var borders = _borders;
+        var bordersLocal = borders;
 
-        for (; _nextIndex < borders.Count; ++_nextIndex)
+        for (; _nextIndex < bordersLocal.Count; ++_nextIndex)
         {
-            var border = borders[_nextIndex];
-            if (border.Equals(defaultBorder)) continue;
+            var border = bordersLocal[_nextIndex];
+            if (border.Equals(default)) continue;
 
-            var span = bytes.Slice(bytesWritten);
+            var span = buffer.GetSpan();
             var written = 0;
 
             var diag = border.Diagonal;
@@ -80,7 +84,7 @@ private bool TryWriteBorders(Span<byte> bytes, ref int bytesWritten)
 
             if (!"</border>"u8.TryCopyTo(span, ref written)) return false;
 
-            bytesWritten += written;
+            buffer.Advance(written);
         }
 
         return true;
diff --git a/SpreadCheetah/MetadataXml/Styles/CellStylesXmlPart.cs b/SpreadCheetah/MetadataXml/Styles/CellStylesXmlPart.cs
new file mode 100644
index 00000000..d2818890
--- /dev/null
+++ b/SpreadCheetah/MetadataXml/Styles/CellStylesXmlPart.cs
@@ -0,0 +1,101 @@
+using SpreadCheetah.Helpers;
+using SpreadCheetah.Styling;
+using SpreadCheetah.Styling.Internal;
+
+namespace SpreadCheetah.MetadataXml.Styles;
+
+internal struct CellStylesXmlPart(
+    List<(string, ImmutableStyle, StyleNameVisibility)>? namedStyles,
+    SpreadsheetBuffer buffer)
+{
+    private string? _currentXmlEncodedName;
+    private int _currentXmlEncodedNameIndex;
+    private Element _next;
+    private int _nextIndex;
+
+#pragma warning disable EPS12 // A struct member can be made readonly
+    public bool TryWrite()
+#pragma warning restore EPS12 // A struct member can be made readonly
+    {
+        while (MoveNext())
+        {
+            if (!Current)
+                return false;
+        }
+
+        return true;
+    }
+
+    public bool Current { get; private set; }
+
+    public bool MoveNext()
+    {
+        Current = _next switch
+        {
+            Element.Header => TryWriteHeader(),
+            Element.CellStyles => TryWriteCellStyles(),
+            _ => buffer.TryWrite("</cellStyles>"u8)
+        };
+
+        if (Current)
+            ++_next;
+
+        return _next < Element.Done;
+    }
+
+    private readonly bool TryWriteHeader()
+    {
+        var count = (namedStyles?.Count ?? 0) + 1;
+        return buffer.TryWrite(
+            $"{"<cellStyles count=\""u8}" +
+            $"{count}" +
+            $"{"\"><cellStyle name=\"Normal\" xfId=\"0\" builtinId=\"0\"/>"u8}");
+    }
+
+    private bool TryWriteCellStyles()
+    {
+        if (namedStyles is not { } namedStylesLocal)
+            return true;
+
+        for (; _nextIndex < namedStylesLocal.Count; ++_nextIndex)
+        {
+            var (name, _, visibility) = namedStylesLocal[_nextIndex];
+            var span = buffer.GetSpan();
+            var written = 0;
+
+            if (_currentXmlEncodedName is null)
+            {
+                if (!"<cellStyle xfId=\""u8.TryCopyTo(span, ref written)) return false;
+                if (!SpanHelper.TryWrite(_nextIndex + 1, span, ref written)) return false;
+                if (visibility == StyleNameVisibility.Hidden && !"\" hidden=\"1"u8.TryCopyTo(span, ref written)) return false;
+                if (!"\" name=\""u8.TryCopyTo(span, ref written)) return false;
+
+                _currentXmlEncodedName = XmlUtility.XmlEncode(name);
+                _currentXmlEncodedNameIndex = 0;
+            }
+
+            if (!SpanHelper.TryWriteLongString(_currentXmlEncodedName, ref _currentXmlEncodedNameIndex, span, ref written))
+            {
+                buffer.Advance(written);
+                return false;
+            }
+
+            buffer.Advance(written);
+
+            if (!buffer.TryWrite("\"/>"u8)) return false;
+
+            _currentXmlEncodedName = null;
+            _currentXmlEncodedNameIndex = 0;
+        }
+
+        return true;
+    }
+
+    private enum Element
+    {
+        Header,
+        CellStyles,
+        Footer,
+        Done
+    }
+}
diff --git a/SpreadCheetah/MetadataXml/StyleFillsXml.cs b/SpreadCheetah/MetadataXml/Styles/FillsXmlPart.cs
similarity index 50%
rename from SpreadCheetah/MetadataXml/StyleFillsXml.cs
rename to SpreadCheetah/MetadataXml/Styles/FillsXmlPart.cs
index 731b69d9..82a754ae 100644
--- a/SpreadCheetah/MetadataXml/StyleFillsXml.cs
+++ b/SpreadCheetah/MetadataXml/Styles/FillsXmlPart.cs
@@ -1,43 +1,48 @@
 using SpreadCheetah.Helpers;
 using SpreadCheetah.Styling.Internal;
 
-namespace SpreadCheetah.MetadataXml;
+namespace SpreadCheetah.MetadataXml.Styles;
 
-internal struct StyleFillsXml
+internal struct FillsXmlPart(List<ImmutableFill> fills, SpreadsheetBuffer buffer)
 {
-    private readonly List<ImmutableFill> _fills;
     private Element _next;
     private int _nextIndex;
 
-    public StyleFillsXml(List<ImmutableFill> fills)
+    public bool TryWrite()
     {
-        _fills = fills;
-    }
-
-    public bool TryWrite(Span<byte> bytes, ref int bytesWritten)
-    {
-        if (_next == Element.Header && !Advance(TryWriteHeader(bytes, ref bytesWritten))) return false;
-        if (_next == Element.Fills && !Advance(TryWriteFills(bytes, ref bytesWritten))) return false;
-        if (_next == Element.Footer && !Advance("</fills>"u8.TryCopyTo(bytes, ref bytesWritten))) return false;
+        while (MoveNext())
+        {
+            if (!Current)
+                return false;
+        }
 
         return true;
     }
 
-    private bool Advance(bool success)
+    public bool Current { get; private set; }
+
+    public bool MoveNext()
     {
-        if (success)
+        Current = _next switch
+        {
+            Element.Header => TryWriteHeader(),
+            Element.Fills => TryWriteFills(),
+            _ => buffer.TryWrite("</fills>"u8)
+        };
+
+        if (Current)
             ++_next;
 
-        return success;
+        return _next < Element.Done;
     }
 
-    private readonly bool TryWriteHeader(Span<byte> bytes, ref int bytesWritten)
+    private readonly bool TryWriteHeader()
     {
-        var span = bytes.Slice(bytesWritten);
+        var span = buffer.GetSpan();
         var written = 0;
 
         const int defaultCount = 2;
-        var totalCount = _fills.Count + defaultCount - 1;
+        var totalCount = fills.Count + defaultCount - 1;
 
         if (!"<fills count=\""u8.TryCopyTo(span, ref written)) return false;
         if (!SpanHelper.TryWrite(totalCount, span, ref written)) return false;
@@ -48,29 +53,28 @@ private readonly bool TryWriteHeader(Span<byte> bytes, ref int bytesWritten)
             """<fill><patternFill patternType="gray125"/></fill>"""u8;
         if (!defaultFills.TryCopyTo(span, ref written)) return false;
 
-        bytesWritten += written;
+        buffer.Advance(written);
         return true;
     }
 
-    private bool TryWriteFills(Span<byte> bytes, ref int bytesWritten)
+    private bool TryWriteFills()
     {
-        var defaultFill = new ImmutableFill();
-        var fills = _fills;
+        var fillsLocal = fills;
 
-        for (; _nextIndex < fills.Count; ++_nextIndex)
+        for (; _nextIndex < fillsLocal.Count; ++_nextIndex)
         {
-            var fill = fills[_nextIndex];
-            if (fill.Equals(defaultFill)) continue;
+            var fill = fillsLocal[_nextIndex];
+            if (fill.Equals(default)) continue;
             if (fill.Color is not { } color) continue;
 
-            var span = bytes.Slice(bytesWritten);
+            var span = buffer.GetSpan();
             var written = 0;
 
             if (!"<fill><patternFill patternType=\"solid\"><fgColor rgb=\""u8.TryCopyTo(span, ref written)) return false;
             if (!SpanHelper.TryWrite(color, span, ref written)) return false;
             if (!"\"/></patternFill></fill>"u8.TryCopyTo(span, ref written)) return false;
 
-            bytesWritten += written;
+            buffer.Advance(written);
         }
 
         return true;
diff --git a/SpreadCheetah/MetadataXml/StyleFontsXml.cs b/SpreadCheetah/MetadataXml/Styles/FontsXmlPart.cs
similarity index 66%
rename from SpreadCheetah/MetadataXml/StyleFontsXml.cs
rename to SpreadCheetah/MetadataXml/Styles/FontsXmlPart.cs
index 91a61fcc..27b23e34 100644
--- a/SpreadCheetah/MetadataXml/StyleFontsXml.cs
+++ b/SpreadCheetah/MetadataXml/Styles/FontsXmlPart.cs
@@ -2,43 +2,48 @@
 using SpreadCheetah.Styling;
 using SpreadCheetah.Styling.Internal;
 
-namespace SpreadCheetah.MetadataXml;
+namespace SpreadCheetah.MetadataXml.Styles;
 
-internal struct StyleFontsXml
+internal struct FontsXmlPart(List<ImmutableFont> fonts, SpreadsheetBuffer buffer)
 {
-    private readonly List<ImmutableFont> _fonts;
     private Element _next;
     private int _nextIndex;
 
-    public StyleFontsXml(List<ImmutableFont> fonts)
+    public bool TryWrite()
     {
-        _fonts = fonts;
-    }
-
-    public bool TryWrite(Span<byte> bytes, ref int bytesWritten)
-    {
-        if (_next == Element.Header && !Advance(TryWriteHeader(bytes, ref bytesWritten))) return false;
-        if (_next == Element.Fonts && !Advance(TryWriteFonts(bytes, ref bytesWritten))) return false;
-        if (_next == Element.Footer && !Advance("</fonts>"u8.TryCopyTo(bytes, ref bytesWritten))) return false;
+        while (MoveNext())
+        {
+            if (!Current)
+                return false;
+        }
 
         return true;
     }
 
-    private bool Advance(bool success)
+    public bool Current { get; private set; }
+
+    public bool MoveNext()
     {
-        if (success)
+        Current = _next switch
+        {
+            Element.Header => TryWriteHeader(),
+            Element.Fonts => TryWriteFonts(),
+            _ => buffer.TryWrite("</fonts>"u8)
+        };
+
+        if (Current)
             ++_next;
 
-        return success;
+        return _next < Element.Done;
     }
 
-    private readonly bool TryWriteHeader(Span<byte> bytes, ref int bytesWritten)
+    private readonly bool TryWriteHeader()
     {
-        var span = bytes.Slice(bytesWritten);
+        var span = buffer.GetSpan();
         var written = 0;
 
         const int defaultCount = 1;
-        var totalCount = _fonts.Count + defaultCount - 1;
+        var totalCount = fonts.Count + defaultCount - 1;
 
         if (!"<fonts count=\""u8.TryCopyTo(span, ref written)) return false;
         if (!SpanHelper.TryWrite(totalCount, span, ref written)) return false;
@@ -48,21 +53,21 @@ private readonly bool TryWriteHeader(Span<byte> bytes, ref int bytesWritten)
             """<font><sz val="11"/><name val="Calibri"/></font>"""u8;
         if (!defaultFont.TryCopyTo(span, ref written)) return false;
 
-        bytesWritten += written;
+        buffer.Advance(written);
         return true;
     }
 
-    private bool TryWriteFonts(Span<byte> bytes, ref int bytesWritten)
+    private bool TryWriteFonts()
     {
         var defaultFont = new ImmutableFont { Size = Font.DefaultSize };
-        var fonts = _fonts;
+        var fontsLocal = fonts;
 
-        for (; _nextIndex < fonts.Count; ++_nextIndex)
+        for (; _nextIndex < fontsLocal.Count; ++_nextIndex)
         {
             var font = fonts[_nextIndex];
             if (font.Equals(defaultFont)) continue;
 
-            var span = bytes.Slice(bytesWritten);
+            var span = buffer.GetSpan();
             var written = 0;
 
             if (!"<font>"u8.TryCopyTo(span, ref written)) return false;
@@ -85,7 +90,7 @@ private bool TryWriteFonts(Span<byte> bytes, ref int bytesWritten)
             if (!SpanHelper.TryWrite(fontName, span, ref written)) return false;
             if (!"\"/></font>"u8.TryCopyTo(span, ref written)) return false;
 
-            bytesWritten += written;
+            buffer.Advance(written);
         }
 
         return true;
diff --git a/SpreadCheetah/MetadataXml/Styles/NumberFormatsXmlPart.cs b/SpreadCheetah/MetadataXml/Styles/NumberFormatsXmlPart.cs
new file mode 100644
index 00000000..b9aaa275
--- /dev/null
+++ b/SpreadCheetah/MetadataXml/Styles/NumberFormatsXmlPart.cs
@@ -0,0 +1,92 @@
+using SpreadCheetah.Helpers;
+
+namespace SpreadCheetah.MetadataXml.Styles;
+
+internal struct NumberFormatsXmlPart(
+    List<KeyValuePair<string, int>>? customNumberFormats,
+    SpreadsheetBuffer buffer)
+{
+    private Element _next;
+    private int _nextIndex;
+
+    public bool TryWrite()
+    {
+        while (MoveNext())
+        {
+            if (!Current)
+                return false;
+        }
+
+        return true;
+    }
+
+    public bool Current { get; private set; }
+
+    public bool MoveNext()
+    {
+        Current = _next switch
+        {
+            Element.Header => TryWriteHeader(),
+            Element.NumberFormats => TryWriteNumberFormats(),
+            _ => TryWriteFooter()
+        };
+
+        if (Current)
+            ++_next;
+
+        return _next < Element.Done;
+    }
+
+    private readonly bool TryWriteHeader()
+    {
+        if (customNumberFormats is not { } formats)
+            return buffer.TryWrite("""<numFmts count="0"/>"""u8);
+
+        var span = buffer.GetSpan();
+        var written = 0;
+
+        if (!"<numFmts count=\""u8.TryCopyTo(span, ref written)) return false;
+        if (!SpanHelper.TryWrite(formats.Count, span, ref written)) return false;
+        if (!"\">"u8.TryCopyTo(span, ref written)) return false;
+
+        buffer.Advance(written);
+        return true;
+    }
+
+    private bool TryWriteNumberFormats()
+    {
+        if (customNumberFormats is not { } formats)
+            return true;
+
+        for (; _nextIndex < formats.Count; ++_nextIndex)
+        {
+            var format = formats[_nextIndex];
+            var span = buffer.GetSpan();
+            var written = 0;
+
+            if (!"<numFmt numFmtId=\""u8.TryCopyTo(span, ref written)) return false;
+            if (!SpanHelper.TryWrite(format.Value, span, ref written)) return false;
+            if (!"\" formatCode=\""u8.TryCopyTo(span, ref written)) return false;
+
+            // TODO: This can be longer than the minimum buffer length. Should use the "long string" approach
+            var numberFormat = XmlUtility.XmlEncode(format.Key);
+            if (!SpanHelper.TryWrite(numberFormat, span, ref written)) return false;
+            if (!"\"/>"u8.TryCopyTo(span, ref written)) return false;
+
+            buffer.Advance(written);
+        }
+
+        return true;
+    }
+
+    private readonly bool TryWriteFooter()
+        => customNumberFormats is null || buffer.TryWrite("</numFmts>"u8);
+
+    private enum Element
+    {
+        Header,
+        NumberFormats,
+        Footer,
+        Done
+    }
+}
diff --git a/SpreadCheetah/MetadataXml/Styles/StylesXml.cs b/SpreadCheetah/MetadataXml/Styles/StylesXml.cs
new file mode 100644
index 00000000..6303b29f
--- /dev/null
+++ b/SpreadCheetah/MetadataXml/Styles/StylesXml.cs
@@ -0,0 +1,254 @@
+using SpreadCheetah.Styling;
+using SpreadCheetah.Styling.Internal;
+using System.IO.Compression;
+
+namespace SpreadCheetah.MetadataXml.Styles;
+
+internal struct StylesXml
+{
+    public static async ValueTask WriteAsync(
+        ZipArchive archive,
+        CompressionLevel compressionLevel,
+        SpreadsheetBuffer buffer,
+        StyleManager styleManager,
+        CancellationToken token)
+    {
+        var entry = archive.CreateEntry("xl/styles.xml", compressionLevel);
+        var stream = entry.Open();
+#if NETSTANDARD2_0
+        using (stream)
+#else
+        await using (stream.ConfigureAwait(false))
+#endif
+        {
+            var writer = new StylesXml(
+                styles: styleManager.StyleElements,
+                namedStyles: styleManager.GetEmbeddedNamedStyles(),
+                namedStylesDictionary: styleManager.NamedStyles,
+                buffer: buffer);
+
+            foreach (var success in writer)
+            {
+                if (!success)
+                    await buffer.FlushToStreamAsync(stream, token).ConfigureAwait(false);
+            }
+
+            await buffer.FlushToStreamAsync(stream, token).ConfigureAwait(false);
+        }
+    }
+
+    private static ReadOnlySpan<byte> Header =>
+        """<?xml version="1.0" encoding="utf-8"?>"""u8 +
+        """<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">"""u8;
+
+    private static ReadOnlySpan<byte> Footer =>
+        """<dxfs count="0"/>"""u8 +
+        """</styleSheet>"""u8;
+
+    private readonly List<StyleElement> _styles;
+    private readonly List<(string, ImmutableStyle, StyleNameVisibility)>? _namedStyles;
+    private readonly Dictionary<string, int>? _customNumberFormats;
+    private readonly Dictionary<string, (StyleId StyleId, int NamedStyleIndex)>? _namedStylesDictionary;
+    private readonly Dictionary<ImmutableBorder, int> _borders;
+    private readonly Dictionary<ImmutableFill, int> _fills;
+    private readonly Dictionary<ImmutableFont, int> _fonts;
+    private readonly SpreadsheetBuffer _buffer;
+    private NumberFormatsXmlPart _numberFormatsXml;
+    private BordersXmlPart _bordersXml;
+    private FillsXmlPart _fillsXml;
+    private FontsXmlPart _fontsXml;
+    private CellStylesXmlPart _cellStylesXml;
+    private Element _next;
+    private int _nextIndex;
+
+    private StylesXml(
+        List<StyleElement> styles,
+        List<(string, ImmutableStyle, StyleNameVisibility)>? namedStyles,
+        Dictionary<string, (StyleId StyleId, int NamedStyleIndex)>? namedStylesDictionary,
+        SpreadsheetBuffer buffer)
+    {
+        _customNumberFormats = CreateCustomNumberFormatDictionary(styles);
+        _borders = CreateBorderDictionary(styles);
+        _fills = CreateFillDictionary(styles);
+        _fonts = CreateFontDictionary(styles);
+        _buffer = buffer;
+        _numberFormatsXml = new NumberFormatsXmlPart(_customNumberFormats is { } formats ? [.. formats] : null, buffer);
+        _bordersXml = new BordersXmlPart([.. _borders.Keys], buffer);
+        _fillsXml = new FillsXmlPart([.. _fills.Keys], buffer);
+        _fontsXml = new FontsXmlPart([.. _fonts.Keys], buffer);
+        _cellStylesXml = new CellStylesXmlPart(namedStyles, buffer);
+        _styles = styles;
+        _namedStyles = namedStyles;
+        _namedStylesDictionary = namedStylesDictionary;
+    }
+
+    public readonly StylesXml GetEnumerator() => this;
+    public bool Current { get; private set; }
+
+    private static Dictionary<string, int>? CreateCustomNumberFormatDictionary(List<StyleElement> styles)
+    {
+        Dictionary<string, int>? dictionary = null;
+        var numberFormatId = 165; // Custom formats start sequentially from this ID
+
+        foreach (var (style, _, _) in styles)
+        {
+            var numberFormat = style.Format;
+            if (numberFormat is not { } format) continue;
+            if (format.CustomFormat is null) continue;
+
+            dictionary ??= new Dictionary<string, int>(StringComparer.Ordinal);
+            if (dictionary.TryAdd(format.CustomFormat, numberFormatId))
+                ++numberFormatId;
+        }
+
+        return dictionary;
+    }
+
+    private static Dictionary<ImmutableBorder, int> CreateBorderDictionary(List<StyleElement> styles)
+    {
+        var defaultBorder = new ImmutableBorder();
+        const int defaultCount = 1;
+
+        var uniqueBorders = new Dictionary<ImmutableBorder, int> { { defaultBorder, 0 } };
+        var borderIndex = defaultCount;
+
+        foreach (var (style, _, _) in styles)
+        {
+            if (uniqueBorders.TryAdd(style.Border, borderIndex))
+                ++borderIndex;
+        }
+
+        return uniqueBorders;
+    }
+
+    private static Dictionary<ImmutableFill, int> CreateFillDictionary(List<StyleElement> styles)
+    {
+        var defaultFill = new ImmutableFill();
+        const int defaultCount = 2;
+
+        var uniqueFills = new Dictionary<ImmutableFill, int> { { defaultFill, 0 } };
+        var fillIndex = defaultCount;
+
+        foreach (var (style, _, _) in styles)
+        {
+            if (uniqueFills.TryAdd(style.Fill, fillIndex))
+                ++fillIndex;
+        }
+
+        return uniqueFills;
+    }
+
+    private static Dictionary<ImmutableFont, int> CreateFontDictionary(List<StyleElement> styles)
+    {
+        var defaultFont = new ImmutableFont { Size = Font.DefaultSize };
+        const int defaultCount = 1;
+
+        var uniqueFonts = new Dictionary<ImmutableFont, int> { { defaultFont, 0 } };
+        var fontIndex = defaultCount;
+
+        foreach (var (style, _, _) in styles)
+        {
+            if (uniqueFonts.TryAdd(style.Font, fontIndex))
+                ++fontIndex;
+        }
+
+        return uniqueFonts;
+    }
+
+    public bool MoveNext()
+    {
+        Current = _next switch
+        {
+            Element.Header => _buffer.TryWrite(Header),
+            Element.NumberFormats => _numberFormatsXml.TryWrite(),
+            Element.Fonts => _fontsXml.TryWrite(),
+            Element.Fills => _fillsXml.TryWrite(),
+            Element.Borders => _bordersXml.TryWrite(),
+            Element.CellStyleXfsStart => TryWriteCellStyleXfsStart(),
+            Element.CellStyleXfsEntries => TryWriteCellStyleXfsEntries(),
+            Element.CellXfsStart => TryWriteCellXfsStart(),
+            Element.CellXfsEntries => TryWriteCellXfsEntries(),
+            Element.CellXfsEnd => _buffer.TryWrite("</cellXfs>"u8),
+            Element.CellStyles => _cellStylesXml.TryWrite(),
+            _ => _buffer.TryWrite(Footer),
+        };
+
+        if (Current)
+            ++_next;
+
+        return _next < Element.Done;
+    }
+
+    private readonly bool TryWriteCellStyleXfsStart()
+    {
+        var count = (_namedStyles?.Count ?? 0) + 1;
+        return _buffer.TryWrite(
+            $"{"<cellStyleXfs count=\""u8}" +
+            $"{count}" +
+            $"{"\"><xf numFmtId=\"0\" fontId=\"0\"/>"u8}");
+    }
+
+    private bool TryWriteCellStyleXfsEntries()
+    {
+        if (_namedStyles is not { } namedStyles)
+            return true;
+
+        var xfXml = new XfXmlPart(_buffer, _customNumberFormats, _borders, _fills, _fonts, false);
+
+        for (; _nextIndex < _namedStyles.Count; ++_nextIndex)
+        {
+            var (_, style, _) = namedStyles[_nextIndex];
+            if (!xfXml.TryWrite(style, null))
+                return false;
+        }
+
+        _nextIndex = 0;
+        return true;
+    }
+
+    private readonly bool TryWriteCellXfsStart()
+    {
+        return _buffer.TryWrite(
+            $"{"</cellStyleXfs><cellXfs count=\""u8}" +
+            $"{_styles.Count}" +
+            $"{"\">"u8}");
+    }
+
+    private bool TryWriteCellXfsEntries()
+    {
+        var xfXml = new XfXmlPart(_buffer, _customNumberFormats, _borders, _fills, _fonts, true);
+        var styles = _styles;
+
+        for (; _nextIndex < styles.Count; ++_nextIndex)
+        {
+            var (style, name, visibility) = _styles[_nextIndex];
+            int? embeddedNamedStyleIndex = name is not null && visibility is not null
+                && _namedStylesDictionary is { } namedStyles && namedStyles.TryGetValue(name, out var value)
+                ? value.NamedStyleIndex
+                : null;
+
+            if (!xfXml.TryWrite(style, embeddedNamedStyleIndex))
+                return false;
+        }
+
+        _nextIndex = 0;
+        return true;
+    }
+
+    private enum Element
+    {
+        Header,
+        NumberFormats,
+        Fonts,
+        Fills,
+        Borders,
+        CellStyleXfsStart,
+        CellStyleXfsEntries,
+        CellXfsStart,
+        CellXfsEntries,
+        CellXfsEnd,
+        CellStyles,
+        Footer,
+        Done
+    }
+}
diff --git a/SpreadCheetah/MetadataXml/Styles/XfXmlPart.cs b/SpreadCheetah/MetadataXml/Styles/XfXmlPart.cs
new file mode 100644
index 00000000..590947f8
--- /dev/null
+++ b/SpreadCheetah/MetadataXml/Styles/XfXmlPart.cs
@@ -0,0 +1,125 @@
+using SpreadCheetah.Helpers;
+using SpreadCheetah.Styling;
+using SpreadCheetah.Styling.Internal;
+
+namespace SpreadCheetah.MetadataXml.Styles;
+
+internal readonly struct XfXmlPart(
+    SpreadsheetBuffer buffer,
+    Dictionary<string, int>? customNumberFormats,
+    Dictionary<ImmutableBorder, int> borders,
+    Dictionary<ImmutableFill, int> fills,
+    Dictionary<ImmutableFont, int> fonts,
+    bool cellXfsEntry)
+{
+    public bool TryWrite(in ImmutableStyle style, int? embeddedNamedStyleIndex)
+    {
+        var span = buffer.GetSpan();
+        var written = 0;
+
+        var numberFormatId = GetNumberFormatId(style.Format, customNumberFormats);
+
+        if (!"<xf numFmtId=\""u8.TryCopyTo(span, ref written)) return false;
+        if (!SpanHelper.TryWrite(numberFormatId, span, ref written)) return false;
+        if (!"\""u8.TryCopyTo(span, ref written)) return false;
+        if (numberFormatId > 0 && !" applyNumberFormat=\"1\""u8.TryCopyTo(span, ref written)) return false;
+
+        if (!TryWriteFont(style.Font, span, ref written)) return false;
+        if (!TryWriteFill(style.Fill, span, ref written)) return false;
+
+        if (borders.TryGetValue(style.Border, out var borderIndex) && borderIndex > 0)
+        {
+            if (!" borderId=\""u8.TryCopyTo(span, ref written)) return false;
+            if (!SpanHelper.TryWrite(borderIndex, span, ref written)) return false;
+            if (!"\" applyBorder=\"1\""u8.TryCopyTo(span, ref written)) return false;
+        }
+
+        if (cellXfsEntry && !TryWriteXfId(embeddedNamedStyleIndex, span, ref written)) return false;
+
+        if (style.Alignment == default)
+        {
+            if (!"/>"u8.TryCopyTo(span, ref written)) return false;
+        }
+        else
+        {
+            if (!""" applyAlignment="1">"""u8.TryCopyTo(span, ref written)) return false;
+            if (!TryWriteAlignment(style.Alignment, span, ref written)) return false;
+            if (!"</xf>"u8.TryCopyTo(span, ref written)) return false;
+        }
+
+        buffer.Advance(written);
+        return true;
+    }
+
+    private static bool TryWriteXfId(int? embeddedNamedStyleIndex, Span<byte> span, ref int written)
+    {
+        var xfId = (embeddedNamedStyleIndex + 1) ?? 0;
+        if (!" xfId=\""u8.TryCopyTo(span, ref written)) return false;
+        if (!SpanHelper.TryWrite(xfId, span, ref written)) return false;
+        return "\""u8.TryCopyTo(span, ref written);
+    }
+
+    private readonly bool TryWriteFont(ImmutableFont font, Span<byte> bytes, ref int bytesWritten)
+    {
+        var fontIndex = fonts.GetValueOrDefault(font);
+        if (!" fontId=\""u8.TryCopyTo(bytes, ref bytesWritten)) return false;
+        if (!SpanHelper.TryWrite(fontIndex, bytes, ref bytesWritten)) return false;
+        if (!"\""u8.TryCopyTo(bytes, ref bytesWritten)) return false;
+        return fontIndex == 0 || " applyFont=\"1\""u8.TryCopyTo(bytes, ref bytesWritten);
+    }
+
+    private readonly bool TryWriteFill(ImmutableFill fill, Span<byte> bytes, ref int bytesWritten)
+    {
+        var fillIndex = fills.GetValueOrDefault(fill);
+        if (!" fillId=\""u8.TryCopyTo(bytes, ref bytesWritten)) return false;
+        if (!SpanHelper.TryWrite(fillIndex, bytes, ref bytesWritten)) return false;
+        if (!"\""u8.TryCopyTo(bytes, ref bytesWritten)) return false;
+        return fillIndex == 0 || " applyFill=\"1\""u8.TryCopyTo(bytes, ref bytesWritten);
+    }
+
+    private static int GetNumberFormatId(NumberFormat? numberFormat, Dictionary<string, int>? customNumberFormats)
+    {
+        if (numberFormat is not { } format) return 0;
+        if (format.StandardFormat is { } standardFormat) return (int)standardFormat;
+        if (format.CustomFormat is null) return 0;
+        return customNumberFormats?.GetValueOrDefault(format.CustomFormat) ?? 0;
+    }
+
+    private static bool TryWriteAlignment(ImmutableAlignment alignment, Span<byte> bytes, ref int bytesWritten)
+    {
+        var span = bytes.Slice(bytesWritten);
+        var written = 0;
+
+        if (!"<alignment"u8.TryCopyTo(span, ref written)) return false;
+        if (!TryWriteHorizontalAlignment(alignment.Horizontal, span, ref written)) return false;
+        if (!TryWriteVerticalAlignment(alignment.Vertical, span, ref written)) return false;
+        if (alignment.WrapText && !" wrapText=\"1\""u8.TryCopyTo(span, ref written)) return false;
+
+        if (alignment.Indent > 0)
+        {
+            if (!" indent=\""u8.TryCopyTo(span, ref written)) return false;
+            if (!SpanHelper.TryWrite(alignment.Indent, span, ref written)) return false;
+            if (!"\""u8.TryCopyTo(span, ref written)) return false;
+        }
+
+        if (!"/>"u8.TryCopyTo(span, ref written)) return false;
+
+        bytesWritten += written;
+        return true;
+    }
+
+    private static bool TryWriteHorizontalAlignment(HorizontalAlignment alignment, Span<byte> bytes, ref int bytesWritten) => alignment switch
+    {
+        HorizontalAlignment.Left => " horizontal=\"left\""u8.TryCopyTo(bytes, ref bytesWritten),
+        HorizontalAlignment.Center => " horizontal=\"center\""u8.TryCopyTo(bytes, ref bytesWritten),
+        HorizontalAlignment.Right => " horizontal=\"right\""u8.TryCopyTo(bytes, ref bytesWritten),
+        _ => true
+    };
+
+    private static bool TryWriteVerticalAlignment(VerticalAlignment alignment, Span<byte> bytes, ref int bytesWritten) => alignment switch
+    {
+        VerticalAlignment.Center => " vertical=\"center\""u8.TryCopyTo(bytes, ref bytesWritten),
+        VerticalAlignment.Top => " vertical=\"top\""u8.TryCopyTo(bytes, ref bytesWritten),
+        _ => true
+    };
+}
diff --git a/SpreadCheetah/MetadataXml/StylesXml.cs b/SpreadCheetah/MetadataXml/StylesXml.cs
deleted file mode 100644
index e96d3e84..00000000
--- a/SpreadCheetah/MetadataXml/StylesXml.cs
+++ /dev/null
@@ -1,295 +0,0 @@
-using SpreadCheetah.Helpers;
-using SpreadCheetah.Styling;
-using SpreadCheetah.Styling.Internal;
-using System.IO.Compression;
-
-namespace SpreadCheetah.MetadataXml;
-
-internal struct StylesXml : IXmlWriter
-{
-    public static ValueTask WriteAsync(
-        ZipArchive archive,
-        CompressionLevel compressionLevel,
-        SpreadsheetBuffer buffer,
-        Dictionary<ImmutableStyle, int> styles,
-        CancellationToken token)
-    {
-        var entry = archive.CreateEntry("xl/styles.xml", compressionLevel);
-        var writer = new StylesXml([.. styles.Keys]);
-#pragma warning disable EPS06 // Hidden struct copy operation
-        return writer.WriteAsync(entry, buffer, token);
-#pragma warning restore EPS06 // Hidden struct copy operation
-    }
-
-    private static ReadOnlySpan<byte> Header =>
-        """<?xml version="1.0" encoding="utf-8"?>"""u8 +
-        """<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">"""u8;
-
-    private static ReadOnlySpan<byte> Footer =>
-        """</cellXfs>"""u8 +
-        """<cellStyles count="1">"""u8 +
-        """<cellStyle name="Normal" xfId="0" builtinId="0"/>"""u8 +
-        """</cellStyles>"""u8 +
-        """<dxfs count="0"/>"""u8 +
-        """</styleSheet>"""u8;
-
-    private readonly List<ImmutableStyle> _styles;
-    private readonly Dictionary<string, int>? _customNumberFormats;
-    private readonly Dictionary<ImmutableBorder, int> _borders;
-    private readonly Dictionary<ImmutableFill, int> _fills;
-    private readonly Dictionary<ImmutableFont, int> _fonts;
-    private StyleNumberFormatsXml _numberFormatsXml;
-    private StyleBordersXml _bordersXml;
-    private StyleFillsXml _fillsXml;
-    private StyleFontsXml _fontsXml;
-    private Element _next;
-    private int _nextIndex;
-
-    private StylesXml(List<ImmutableStyle> styles)
-    {
-        _customNumberFormats = CreateCustomNumberFormatDictionary(styles);
-        _borders = CreateBorderDictionary(styles);
-        _fills = CreateFillDictionary(styles);
-        _fonts = CreateFontDictionary(styles);
-        _numberFormatsXml = new StyleNumberFormatsXml(_customNumberFormats is { } formats ? [.. formats] : null);
-        _bordersXml = new StyleBordersXml([.. _borders.Keys]);
-        _fillsXml = new StyleFillsXml([.. _fills.Keys]);
-        _fontsXml = new StyleFontsXml([.. _fonts.Keys]);
-        _styles = styles;
-    }
-
-    private static Dictionary<string, int>? CreateCustomNumberFormatDictionary(List<ImmutableStyle> styles)
-    {
-        Dictionary<string, int>? dictionary = null;
-        var numberFormatId = 165; // Custom formats start sequentially from this ID
-
-        foreach (var style in styles)
-        {
-            var numberFormat = style.Format;
-            if (numberFormat is not { } format) continue;
-            if (format.CustomFormat is null) continue;
-
-            dictionary ??= new Dictionary<string, int>(StringComparer.Ordinal);
-            if (dictionary.TryAdd(format.CustomFormat, numberFormatId))
-                ++numberFormatId;
-        }
-
-        return dictionary;
-    }
-
-    private static Dictionary<ImmutableBorder, int> CreateBorderDictionary(List<ImmutableStyle> styles)
-    {
-        var defaultBorder = new ImmutableBorder();
-        const int defaultCount = 1;
-
-        var uniqueBorders = new Dictionary<ImmutableBorder, int> { { defaultBorder, 0 } };
-        var borderIndex = defaultCount;
-
-        foreach (var style in styles)
-        {
-            if (uniqueBorders.TryAdd(style.Border, borderIndex))
-                ++borderIndex;
-        }
-
-        return uniqueBorders;
-    }
-
-    private static Dictionary<ImmutableFill, int> CreateFillDictionary(List<ImmutableStyle> styles)
-    {
-        var defaultFill = new ImmutableFill();
-        const int defaultCount = 2;
-
-        var uniqueFills = new Dictionary<ImmutableFill, int> { { defaultFill, 0 } };
-        var fillIndex = defaultCount;
-
-        foreach (var style in styles)
-        {
-            if (uniqueFills.TryAdd(style.Fill, fillIndex))
-                ++fillIndex;
-        }
-
-        return uniqueFills;
-    }
-
-    private static Dictionary<ImmutableFont, int> CreateFontDictionary(List<ImmutableStyle> styles)
-    {
-        var defaultFont = new ImmutableFont { Size = Font.DefaultSize };
-        const int defaultCount = 1;
-
-        var uniqueFonts = new Dictionary<ImmutableFont, int> { { defaultFont, 0 } };
-        var fontIndex = defaultCount;
-
-        foreach (var style in styles)
-        {
-            if (uniqueFonts.TryAdd(style.Font, fontIndex))
-                ++fontIndex;
-        }
-
-        return uniqueFonts;
-    }
-
-    public bool TryWrite(Span<byte> bytes, out int bytesWritten)
-    {
-        bytesWritten = 0;
-
-        if (_next == Element.Header && !Advance(Header.TryCopyTo(bytes, ref bytesWritten))) return false;
-        if (_next == Element.NumberFormats && !Advance(_numberFormatsXml.TryWrite(bytes, ref bytesWritten))) return false;
-        if (_next == Element.Fonts && !Advance(_fontsXml.TryWrite(bytes, ref bytesWritten))) return false;
-        if (_next == Element.Fills && !Advance(_fillsXml.TryWrite(bytes, ref bytesWritten))) return false;
-        if (_next == Element.Borders && !Advance(_bordersXml.TryWrite(bytes, ref bytesWritten))) return false;
-        if (_next == Element.CellXfsStart && !Advance(TryWriteCellXfsStart(bytes, ref bytesWritten))) return false;
-        if (_next == Element.Styles && !Advance(TryWriteStyles(bytes, ref bytesWritten))) return false;
-        if (_next == Element.Footer && !Advance(Footer.TryCopyTo(bytes, ref bytesWritten))) return false;
-
-        return true;
-    }
-
-    private bool Advance(bool success)
-    {
-        if (success)
-            ++_next;
-
-        return success;
-    }
-
-    private readonly bool TryWriteCellXfsStart(Span<byte> bytes, ref int bytesWritten)
-    {
-        var span = bytes.Slice(bytesWritten);
-        var written = 0;
-
-        ReadOnlySpan<byte> xml =
-            """<cellStyleXfs count="1"><xf numFmtId="0" fontId="0"/></cellStyleXfs>"""u8 +
-            "<cellXfs count=\""u8;
-
-        if (!xml.TryCopyTo(span, ref written)) return false;
-        if (!SpanHelper.TryWrite(_styles.Count, span, ref written)) return false;
-        if (!"\">"u8.TryCopyTo(span, ref written)) return false;
-
-        bytesWritten += written;
-        return true;
-    }
-
-    private bool TryWriteStyles(Span<byte> bytes, ref int bytesWritten)
-    {
-        var styles = _styles;
-
-        for (; _nextIndex < styles.Count; ++_nextIndex)
-        {
-            var style = _styles[_nextIndex];
-            var span = bytes.Slice(bytesWritten);
-            var written = 0;
-
-            var numberFormatId = GetNumberFormatId(style.Format, _customNumberFormats);
-
-            if (!"<xf numFmtId=\""u8.TryCopyTo(span, ref written)) return false;
-            if (!SpanHelper.TryWrite(numberFormatId, span, ref written)) return false;
-            if (!"\""u8.TryCopyTo(span, ref written)) return false;
-            if (numberFormatId > 0 && !" applyNumberFormat=\"1\""u8.TryCopyTo(span, ref written)) return false;
-
-            if (!TryWriteFont(style.Font, span, ref written)) return false;
-            if (!TryWriteFill(style.Fill, span, ref written)) return false;
-
-            if (_borders.TryGetValue(style.Border, out var borderIndex) && borderIndex > 0)
-            {
-                if (!" borderId=\""u8.TryCopyTo(span, ref written)) return false;
-                if (!SpanHelper.TryWrite(borderIndex, span, ref written)) return false;
-                if (!"\" applyBorder=\"1\""u8.TryCopyTo(span, ref written)) return false;
-            }
-
-            if (!" xfId=\"0\""u8.TryCopyTo(span, ref written)) return false;
-
-            var defaultAlignment = new ImmutableAlignment();
-            if (style.Alignment == defaultAlignment)
-            {
-                if (!"/>"u8.TryCopyTo(span, ref written)) return false;
-            }
-            else
-            {
-                if (!""" applyAlignment="1">"""u8.TryCopyTo(span, ref written)) return false;
-                if (!TryWriteAlignment(style.Alignment, span, ref written)) return false;
-                if (!"</xf>"u8.TryCopyTo(span, ref written)) return false;
-            }
-
-            bytesWritten += written;
-        }
-
-        return true;
-    }
-
-    private readonly bool TryWriteFont(ImmutableFont font, Span<byte> bytes, ref int bytesWritten)
-    {
-        var fontIndex = _fonts.GetValueOrDefault(font);
-        if (!" fontId=\""u8.TryCopyTo(bytes, ref bytesWritten)) return false;
-        if (!SpanHelper.TryWrite(fontIndex, bytes, ref bytesWritten)) return false;
-        if (!"\""u8.TryCopyTo(bytes, ref bytesWritten)) return false;
-        return fontIndex == 0 || " applyFont=\"1\""u8.TryCopyTo(bytes, ref bytesWritten);
-    }
-
-    private readonly bool TryWriteFill(ImmutableFill fill, Span<byte> bytes, ref int bytesWritten)
-    {
-        var fillIndex = _fills.GetValueOrDefault(fill);
-        if (!" fillId=\""u8.TryCopyTo(bytes, ref bytesWritten)) return false;
-        if (!SpanHelper.TryWrite(fillIndex, bytes, ref bytesWritten)) return false;
-        if (!"\""u8.TryCopyTo(bytes, ref bytesWritten)) return false;
-        return fillIndex == 0 || " applyFill=\"1\""u8.TryCopyTo(bytes, ref bytesWritten);
-    }
-
-    private static int GetNumberFormatId(NumberFormat? numberFormat, IReadOnlyDictionary<string, int>? customNumberFormats)
-    {
-        if (numberFormat is not { } format) return 0;
-        if (format.StandardFormat is { } standardFormat) return (int)standardFormat;
-        if (format.CustomFormat is null) return 0;
-        return customNumberFormats?.GetValueOrDefault(format.CustomFormat) ?? 0;
-    }
-
-    private static bool TryWriteAlignment(ImmutableAlignment alignment, Span<byte> bytes, ref int bytesWritten)
-    {
-        var span = bytes.Slice(bytesWritten);
-        var written = 0;
-
-        if (!"<alignment"u8.TryCopyTo(span, ref written)) return false;
-        if (!TryWriteHorizontalAlignment(alignment.Horizontal, span, ref written)) return false;
-        if (!TryWriteVerticalAlignment(alignment.Vertical, span, ref written)) return false;
-        if (alignment.WrapText && !" wrapText=\"1\""u8.TryCopyTo(span, ref written)) return false;
-
-        if (alignment.Indent > 0)
-        {
-            if (!" indent=\""u8.TryCopyTo(span, ref written)) return false;
-            if (!SpanHelper.TryWrite(alignment.Indent, span, ref written)) return false;
-            if (!"\""u8.TryCopyTo(span, ref written)) return false;
-        }
-
-        if (!"/>"u8.TryCopyTo(span, ref written)) return false;
-
-        bytesWritten += written;
-        return true;
-    }
-
-    private static bool TryWriteHorizontalAlignment(HorizontalAlignment alignment, Span<byte> bytes, ref int bytesWritten) => alignment switch
-    {
-        HorizontalAlignment.Left => " horizontal=\"left\""u8.TryCopyTo(bytes, ref bytesWritten),
-        HorizontalAlignment.Center => " horizontal=\"center\""u8.TryCopyTo(bytes, ref bytesWritten),
-        HorizontalAlignment.Right => " horizontal=\"right\""u8.TryCopyTo(bytes, ref bytesWritten),
-        _ => true
-    };
-
-    private static bool TryWriteVerticalAlignment(VerticalAlignment alignment, Span<byte> bytes, ref int bytesWritten) => alignment switch
-    {
-        VerticalAlignment.Center => " vertical=\"center\""u8.TryCopyTo(bytes, ref bytesWritten),
-        VerticalAlignment.Top => " vertical=\"top\""u8.TryCopyTo(bytes, ref bytesWritten),
-        _ => true
-    };
-
-    private enum Element
-    {
-        Header,
-        NumberFormats,
-        Fonts,
-        Fills,
-        Borders,
-        CellXfsStart,
-        Styles,
-        Footer,
-        Done
-    }
-}
diff --git a/SpreadCheetah/MetadataXml/WorksheetStartXml.cs b/SpreadCheetah/MetadataXml/WorksheetStartXml.cs
index d5da893f..ad8e7895 100644
--- a/SpreadCheetah/MetadataXml/WorksheetStartXml.cs
+++ b/SpreadCheetah/MetadataXml/WorksheetStartXml.cs
@@ -49,8 +49,8 @@ public bool MoveNext()
         Current = _next switch
         {
             Element.Header => _buffer.TryWrite(Header),
-            Element.SheetViews => TryWriteSheetViews(_buffer),
-            Element.Columns => TryWriteColumns(_buffer),
+            Element.SheetViews => TryWriteSheetViews(),
+            Element.Columns => TryWriteColumns(),
             _ => _buffer.TryWrite(SheetDataBegin)
         };
 
@@ -60,13 +60,13 @@ public bool MoveNext()
         return _next < Element.Done;
     }
 
-    private readonly bool TryWriteSheetViews(SpreadsheetBuffer buffer)
+    private readonly bool TryWriteSheetViews()
     {
         var options = _options;
         if (options?.FrozenColumns is null && options?.FrozenRows is null)
             return true;
 
-        var span = buffer.GetSpan();
+        var span = _buffer.GetSpan();
         var written = 0;
 
         if (!"<sheetViews><sheetView workbookViewId=\"0\"><pane "u8.TryCopyTo(span, ref written)) return false;
@@ -128,7 +128,7 @@ private readonly bool TryWriteySplit(Span<byte> bytes, ref int bytesWritten)
         return "\" "u8.TryCopyTo(bytes, ref bytesWritten);
     }
 
-    private bool TryWriteColumns(SpreadsheetBuffer buffer)
+    private bool TryWriteColumns()
     {
         if (_columns is not { } columns) return true;
 
@@ -140,7 +140,7 @@ private bool TryWriteColumns(SpreadsheetBuffer buffer)
             if (options.Width is null && !options.Hidden)
                 continue;
 
-            var span = buffer.GetSpan();
+            var span = _buffer.GetSpan();
             var written = 0;
 
             if (!anyColumnWritten)
@@ -166,13 +166,13 @@ private bool TryWriteColumns(SpreadsheetBuffer buffer)
 
             _anyColumnWritten = anyColumnWritten;
 
-            buffer.Advance(written);
+            _buffer.Advance(written);
         }
 
         if (!anyColumnWritten)
             return true;
 
-        return buffer.TryWrite("</cols>"u8);
+        return _buffer.TryWrite("</cols>"u8);
     }
 
     private enum Element
diff --git a/SpreadCheetah/SpreadCheetah.csproj b/SpreadCheetah/SpreadCheetah.csproj
index ae3d88af..86a9dcd3 100644
--- a/SpreadCheetah/SpreadCheetah.csproj
+++ b/SpreadCheetah/SpreadCheetah.csproj
@@ -34,7 +34,7 @@
 
     <!-- Package validation -->
     <EnablePackageValidation>true</EnablePackageValidation>
-    <PackageValidationBaselineVersion>1.15.0</PackageValidationBaselineVersion>
+    <PackageValidationBaselineVersion>1.16.0</PackageValidationBaselineVersion>
     <EnableStrictModeForCompatibleTfms>true</EnableStrictModeForCompatibleTfms>
     <EnableStrictModeForCompatibleFrameworksInPackage>true</EnableStrictModeForCompatibleFrameworksInPackage>
   </PropertyGroup>
diff --git a/SpreadCheetah/Spreadsheet.cs b/SpreadCheetah/Spreadsheet.cs
index 7216e2a3..6947ae06 100644
--- a/SpreadCheetah/Spreadsheet.cs
+++ b/SpreadCheetah/Spreadsheet.cs
@@ -3,6 +3,7 @@
 using SpreadCheetah.Images;
 using SpreadCheetah.Images.Internal;
 using SpreadCheetah.MetadataXml;
+using SpreadCheetah.MetadataXml.Styles;
 using SpreadCheetah.SourceGeneration;
 using SpreadCheetah.Styling;
 using SpreadCheetah.Styling.Internal;
@@ -28,10 +29,8 @@ public sealed class Spreadsheet : IDisposable, IAsyncDisposable
     private readonly CompressionLevel _compressionLevel;
     private readonly SpreadsheetBuffer _buffer;
     private readonly bool _writeCellReferenceAttributes;
-    private readonly NumberFormat? _defaultDateTimeFormat;
-    private DefaultStyling? _defaultStyling;
-    private Dictionary<ImmutableStyle, int>? _styles;
     private FileCounter? _fileCounter;
+    private StyleManager? _styleManager;
     private Worksheet? _worksheet;
     private bool _disposed;
     private bool _finished;
@@ -50,8 +49,12 @@ private Spreadsheet(ZipArchive archive, CompressionLevel compressionLevel, int b
         _archive = archive;
         _compressionLevel = compressionLevel;
         _buffer = new SpreadsheetBuffer(bufferSize);
-        _defaultDateTimeFormat = defaultDateTimeFormat;
         _writeCellReferenceAttributes = writeCellReferenceAttributes;
+
+        // If no style is ever added to the spreadsheet, then we can skip creating the styles.xml file.
+        // If we have any style, the built-in default style must be the first one (meaning the first <xf> element in styles.xml).
+        if (defaultDateTimeFormat is { } format)
+            _styleManager = new(format);
     }
 
     /// <summary>
@@ -70,12 +73,6 @@ public static async ValueTask<Spreadsheet> CreateNewAsync(
 
         var spreadsheet = new Spreadsheet(archive, compressionLevel, bufferSize, defaultDateTimeFormat, writeCellReferenceAttributes);
         await spreadsheet.InitializeAsync(cancellationToken).ConfigureAwait(false);
-
-        // If no style is ever added to the spreadsheet, then we can skip creating the styles.xml file.
-        // If we have any style, the built-in default style must be the first one (meaning the first <xf> element in styles.xml).
-        if (defaultDateTimeFormat is not null)
-            spreadsheet.AddDefaultStyle();
-
         return spreadsheet;
     }
 
@@ -133,7 +130,7 @@ public ValueTask StartWorksheetAsync(string name, WorksheetOptions? options = nu
     /// The worksheet name must satisfy these requirements:
     /// <list type="bullet">
     ///   <item><description>Can not be empty or consist only of whitespace.</description></item>
-    ///   <item><description>Can not be more than 31 characters.</description></item>
+    ///   <item><description>Can not be longer than 31 characters.</description></item>
     ///   <item><description>Can not start or end with a single quote.</description></item>
     ///   <item><description>Can not contain these characters: / \ * ? [ ] </description></item>
     ///   <item><description>Must be unique across all worksheets.</description></item>
@@ -153,7 +150,7 @@ private async ValueTask StartWorksheetInternalAsync(string name, WorksheetOption
         var path = StringHelper.Invariant($"xl/worksheets/sheet{_worksheets.Count + 1}.xml");
         var entry = _archive.CreateEntry(path, _compressionLevel);
         var entryStream = entry.Open();
-        _worksheet = new Worksheet(entryStream, _defaultStyling, _buffer, _writeCellReferenceAttributes);
+        _worksheet = new Worksheet(entryStream, _styleManager?.DefaultStyling, _buffer, _writeCellReferenceAttributes);
         await _worksheet.WriteHeadAsync(options, token).ConfigureAwait(false);
         _worksheets.Add(new WorksheetMetadata(name, path, options?.Visibility ?? WorksheetVisibility.Visible));
     }
@@ -387,47 +384,68 @@ public StyleId AddStyle(Style style)
     {
         ArgumentNullException.ThrowIfNull(style);
 
-        // If we have any style, the built-in default style must be the first one (meaning the first <xf> element in styles.xml).
-        if (_styles is null)
-            AddDefaultStyle();
-
-        return AddStyle(ImmutableStyle.From(style));
+        var styleManager = _styleManager ??= new(defaultDateTimeFormat: null);
+        return styleManager.AddStyleIfNotExists(ImmutableStyle.From(style));
     }
 
-    private void AddDefaultStyle()
+    /// <summary>
+    /// <para>
+    /// Adds a named style to the spreadsheet and returns a style ID.
+    /// This also allows for calling <see cref="GetStyleId(string)"/> with the name to get the style ID.
+    /// </para>
+    /// <para>
+    /// The <paramref name="nameVisibility"/> parameter determines whether or not the style name will be visible in the Excel UI.
+    /// If <paramref name="nameVisibility"/> is set to <see langword="null"/>, then the style name will not be part of the resulting XLSX file.
+    /// </para>
+    /// <para>
+    /// The style name must satisfy these requirements:
+    /// <list type="bullet">
+    ///   <item><description>Can not be empty or consist only of whitespace.</description></item>
+    ///   <item><description>Can not start or end with whitespace.</description></item>
+    ///   <item><description>Can not be longer than 255 characters.</description></item>
+    ///   <item><description>Can not be equal to "Normal", as that is the name of the default font.</description></item>
+    ///   <item><description>Must be unique for the spreadsheet.</description></item>
+    /// </list>
+    /// </para>
+    /// </summary>
+    public StyleId AddStyle(Style style, string name, StyleNameVisibility? nameVisibility = null)
     {
-        var defaultFont = new ImmutableFont(null, false, false, false, Font.DefaultSize, null);
-        var defaultStyle = new ImmutableStyle(new ImmutableAlignment(), new ImmutableBorder(), new ImmutableFill(), defaultFont, null);
-        var styleId = AddStyle(defaultStyle);
+        ArgumentNullException.ThrowIfNull(style);
+        ArgumentNullException.ThrowIfNull(name);
 
-        if (styleId.Id != styleId.DateTimeId)
-            _defaultStyling = new DefaultStyling(styleId.DateTimeId);
-    }
+        if (string.IsNullOrWhiteSpace(name))
+            ThrowHelper.NameEmptyOrWhiteSpace(nameof(name));
+        if (name.Length > 255)
+            ThrowHelper.StyleNameTooLong(nameof(name));
+        if (char.IsWhiteSpace(name[0]) || char.IsWhiteSpace(name[^1]))
+            ThrowHelper.StyleNameStartsOrEndsWithWhiteSpace(nameof(name));
+        if (name.Equals("Normal", StringComparison.OrdinalIgnoreCase))
+            ThrowHelper.StyleNameCanNotEqualNormal(nameof(name));
+        if (nameVisibility is { } visibility && !EnumHelper.IsDefined(visibility))
+            ThrowHelper.EnumValueInvalid(nameof(nameVisibility), nameVisibility);
 
-    private StyleId AddStyle(in ImmutableStyle style)
-    {
-        // Optionally add another style for DateTime when there is no explicit number format in the new style.
-        ImmutableStyle? dateTimeStyle = _defaultDateTimeFormat is not null && style.Format is null
-            ? style with { Format = _defaultDateTimeFormat }
-            : null;
+        var styleManager = _styleManager ??= new(defaultDateTimeFormat: null);
+        if (!styleManager.TryAddNamedStyle(name, style, nameVisibility, out var styleId))
+            ThrowHelper.StyleNameAlreadyExists(nameof(name));
 
-        _styles ??= [];
-        if (_styles.TryGetValue(style, out var id))
-        {
-            return dateTimeStyle is { } dtStyle && _styles.TryGetValue(dtStyle, out var dateTimeId)
-                ? new StyleId(id, dateTimeId)
-                : new StyleId(id, id);
-        }
+        return styleId;
+    }
 
-        var newId = _styles.Count;
-        _styles[style] = newId;
+    /// <summary>
+    /// Get the <see cref="StyleId"/> from a named style.
+    /// The named style must have previously been added to the spreadsheet with <see cref="AddStyle(Style, string, StyleNameVisibility?)"/>.
+    /// If the named style is not found, a <see cref="SpreadCheetahException"/> is thrown.
+    /// </summary>
+    public StyleId GetStyleId(string name)
+    {
+        ArgumentNullException.ThrowIfNull(name);
 
-        if (dateTimeStyle is not { } dateTimeStyleValue)
-            return new StyleId(newId, newId);
+        var styleId = _styleManager?.GetStyleIdOrDefault(name);
+        if (styleId is not null)
+            return styleId;
 
-        var newDateTimeId = newId + 1;
-        _styles[dateTimeStyleValue] = newDateTimeId;
-        return new StyleId(newId, newDateTimeId);
+        ThrowHelper.StyleNameNotFound(name);
+        return null; // Unreachable
     }
 
     /// <summary>
@@ -609,14 +627,14 @@ private async ValueTask FinishInternalAsync(CancellationToken token)
     {
         await FinishAndDisposeWorksheetAsync(token).ConfigureAwait(false);
 
-        var hasStyles = _styles != null;
+        var hasStyles = _styleManager is not null;
 
         await ContentTypesXml.WriteAsync(_archive, _compressionLevel, _buffer, _worksheets, _fileCounter, hasStyles, token).ConfigureAwait(false);
         await WorkbookRelsXml.WriteAsync(_archive, _compressionLevel, _buffer, _worksheets, hasStyles, token).ConfigureAwait(false);
         await WorkbookXml.WriteAsync(_archive, _compressionLevel, _buffer, _worksheets, token).ConfigureAwait(false);
 
-        if (_styles is not null)
-            await StylesXml.WriteAsync(_archive, _compressionLevel, _buffer, _styles, token).ConfigureAwait(false);
+        if (_styleManager is not null)
+            await StylesXml.WriteAsync(_archive, _compressionLevel, _buffer, _styleManager, token).ConfigureAwait(false);
 
         _finished = true;
 
diff --git a/SpreadCheetah/Styling/Internal/DefaultStyling.cs b/SpreadCheetah/Styling/Internal/DefaultStyling.cs
index 00d03ed5..ba58e617 100644
--- a/SpreadCheetah/Styling/Internal/DefaultStyling.cs
+++ b/SpreadCheetah/Styling/Internal/DefaultStyling.cs
@@ -1,11 +1,3 @@
 namespace SpreadCheetah.Styling.Internal;
 
-internal sealed class DefaultStyling
-{
-    public int? DateTimeStyleId { get; }
-
-    public DefaultStyling(int? dateTimeStyleId)
-    {
-        DateTimeStyleId = dateTimeStyleId;
-    }
-}
+internal sealed record DefaultStyling(int? DateTimeStyleId);
\ No newline at end of file
diff --git a/SpreadCheetah/Styling/Internal/StyleElement.cs b/SpreadCheetah/Styling/Internal/StyleElement.cs
new file mode 100644
index 00000000..a5a5cd9f
--- /dev/null
+++ b/SpreadCheetah/Styling/Internal/StyleElement.cs
@@ -0,0 +1,3 @@
+namespace SpreadCheetah.Styling.Internal;
+
+internal readonly record struct StyleElement(ImmutableStyle Style, string? Name, StyleNameVisibility? Visibility);
diff --git a/SpreadCheetah/Styling/Internal/StyleManager.cs b/SpreadCheetah/Styling/Internal/StyleManager.cs
new file mode 100644
index 00000000..03d300a2
--- /dev/null
+++ b/SpreadCheetah/Styling/Internal/StyleManager.cs
@@ -0,0 +1,106 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace SpreadCheetah.Styling.Internal;
+
+internal sealed class StyleManager
+{
+    private readonly NumberFormat? _defaultDateTimeFormat;
+    private readonly Dictionary<ImmutableStyle, int> _styleDictionary = [];
+
+    public DefaultStyling? DefaultStyling { get; }
+    public List<StyleElement> StyleElements { get; } = [];
+    public Dictionary<string, (StyleId StyleId, int NamedStyleIndex)>? NamedStyles { get; private set; }
+
+    public StyleManager(NumberFormat? defaultDateTimeFormat)
+    {
+        _defaultDateTimeFormat = defaultDateTimeFormat;
+
+        // If we have any style, the built-in default style must be the first one (meaning the first <xf> element in styles.xml).
+        var defaultFont = new ImmutableFont(null, false, false, false, Font.DefaultSize, null);
+        var defaultStyle = new ImmutableStyle(new ImmutableAlignment(), new ImmutableBorder(), new ImmutableFill(), defaultFont, null);
+        var styleId = AddStyleIfNotExists(defaultStyle);
+
+        if (styleId.Id != styleId.DateTimeId)
+            DefaultStyling = new DefaultStyling(styleId.DateTimeId);
+    }
+
+    public StyleId AddStyleIfNotExists(in ImmutableStyle style)
+    {
+        var id = AddStyleIfNotExistsInternal(style);
+
+        if (_defaultDateTimeFormat is null || style.Format is not null)
+            return new StyleId(id, id);
+
+        // Optionally add another style for DateTime when there is no explicit number format in the new style.
+        var dateTimeStyle = style with { Format = _defaultDateTimeFormat };
+        var dateTimeId = AddStyleIfNotExistsInternal(dateTimeStyle);
+
+        return new StyleId(id, dateTimeId);
+    }
+
+    private int AddStyleIfNotExistsInternal(in ImmutableStyle style)
+    {
+        if (_styleDictionary.TryGetValue(style, out var id))
+            return id;
+
+        var newId = StyleElements.Count;
+        StyleElements.Add(new StyleElement(style, null, null));
+        _styleDictionary[style] = newId;
+        return newId;
+    }
+
+    public bool TryAddNamedStyle(string name, Style style, StyleNameVisibility? visibility,
+        [NotNullWhen(true)] out StyleId? styleId)
+    {
+        styleId = null;
+
+        var namedStyles = NamedStyles ??= new(StringComparer.OrdinalIgnoreCase);
+        if (namedStyles.ContainsKey(name))
+            return false;
+
+        var immutableStyle = ImmutableStyle.From(style);
+
+        var id = StyleElements.Count;
+        StyleElements.Add(new StyleElement(immutableStyle, name, visibility));
+        var dateTimeId = id;
+
+        if (_defaultDateTimeFormat is not null && style.Format is null)
+        {
+            var dateTimeStyle = immutableStyle with { Format = _defaultDateTimeFormat };
+
+            // Style names only refer to the regular style, not the DateTime style.
+            // Since the DateTime style doesn't have a name, it can be reused like regular styles.
+            dateTimeId = AddStyleIfNotExistsInternal(dateTimeStyle);
+        }
+
+        styleId = new StyleId(id, dateTimeId);
+        namedStyles[name] = (styleId, namedStyles.Count);
+        return true;
+    }
+
+    public StyleId? GetStyleIdOrDefault(string name)
+    {
+        return NamedStyles is { } namedStyles && namedStyles.TryGetValue(name, out var value)
+            ? value.StyleId
+            : null;
+    }
+
+    public List<(string, ImmutableStyle, StyleNameVisibility)>? GetEmbeddedNamedStyles()
+    {
+        if (NamedStyles is null)
+            return null;
+
+        List<(string, ImmutableStyle, StyleNameVisibility)>? result = null;
+
+        foreach (var (style, name, visibility) in StyleElements)
+        {
+            if (name is null) continue;
+            if (visibility is not { } nameVisibility) continue;
+
+            result ??= [];
+            result.Add((name, style, nameVisibility));
+        }
+
+        return result;
+    }
+}
diff --git a/SpreadCheetah/Styling/StyleNameVisibility.cs b/SpreadCheetah/Styling/StyleNameVisibility.cs
new file mode 100644
index 00000000..33e701ae
--- /dev/null
+++ b/SpreadCheetah/Styling/StyleNameVisibility.cs
@@ -0,0 +1,13 @@
+namespace SpreadCheetah.Styling;
+
+/// <summary>
+/// Value that specifies the visibility of a style name in the Excel UI.
+/// </summary>
+public enum StyleNameVisibility
+{
+    /// <summary>Visible in the Excel UI.</summary>
+    Visible,
+
+    /// <summary>Hidden from the Excel UI.</summary>
+    Hidden
+}