diff --git a/CHANGELOG.md b/CHANGELOG.md
index a94fa9b9..35c79d9b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,9 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
+### Added
+- [.Net] Added possibility to customize resources for MessagesToHtmlWriter ([#400](https://github.com/cucumber/html-formatter/pull/400))
+
 ### Changed
 - Upgrade `react-components` to [23.2.0](https://github.com/cucumber/react-components/releases/tag/v23.2.0)
 
diff --git a/dotnet/Cucumber.HtmlFormatter/DefaultResourceProvider.cs b/dotnet/Cucumber.HtmlFormatter/DefaultResourceProvider.cs
new file mode 100644
index 00000000..4fe90e87
--- /dev/null
+++ b/dotnet/Cucumber.HtmlFormatter/DefaultResourceProvider.cs
@@ -0,0 +1,65 @@
+using System.Reflection;
+
+namespace Cucumber.HtmlFormatter;
+
+/// <summary>
+/// Default implementation of IResourceProvider
+/// </summary>
+public class DefaultResourceProvider : IResourceProvider
+{
+    private const string TEMPLATE_RESOURCE_NAME = "index.mustache.html";
+    private const string CSS_RESOURCE_NAME = "main.css";
+    private const string JAVASCRIPT_RESOURCE_NAME = "main.js";
+    private readonly Assembly _assembly;
+    private readonly string _resourceNamespace;
+
+    public DefaultResourceProvider()
+    {
+        _assembly = typeof(MessagesToHtmlWriter).Assembly;
+        _resourceNamespace = "Cucumber.HtmlFormatter.Resources.";
+    }
+
+    /// <summary>
+    /// Constructor with custom assembly and namespace
+    /// </summary>
+    /// <param name="assembly">The assembly to load resources from</param>
+    /// <param name="resourceNamespace">The namespace prefix for resources</param>
+    public DefaultResourceProvider(Assembly assembly, string resourceNamespace)
+    {
+        _assembly = assembly;
+        _resourceNamespace = resourceNamespace;
+    }
+
+    /// <inheritdoc />
+    public string GetTemplateResource()
+    {
+        return GetResource(TEMPLATE_RESOURCE_NAME);
+    }
+
+    /// <inheritdoc />
+    public string GetCssResource()
+    {
+        return GetResource(CSS_RESOURCE_NAME);
+    }
+
+    /// <inheritdoc />
+    public string GetJavaScriptResource()
+    {
+        return GetResource(JAVASCRIPT_RESOURCE_NAME);
+    }
+
+    /// <summary>
+    /// Gets a resource from the assembly
+    /// </summary>
+    /// <param name="name">The resource name</param>
+    /// <returns>The resource content</returns>
+    private string GetResource(string name)
+    {
+        var resourceStream = _assembly.GetManifestResourceStream(_resourceNamespace + name);
+        if (resourceStream == null)
+            throw new InvalidOperationException($"Resource '{name}' not found in assembly '{_assembly.FullName}'");
+
+        using var reader = new StreamReader(resourceStream);
+        return reader.ReadToEnd();
+    }
+}
\ No newline at end of file
diff --git a/dotnet/Cucumber.HtmlFormatter/IResourceProvider.cs b/dotnet/Cucumber.HtmlFormatter/IResourceProvider.cs
new file mode 100644
index 00000000..ce9f24ad
--- /dev/null
+++ b/dotnet/Cucumber.HtmlFormatter/IResourceProvider.cs
@@ -0,0 +1,26 @@
+namespace Cucumber.HtmlFormatter;
+
+/// <summary>
+/// Interface for providing resources to the HTML formatter.
+/// This is an experimental API for allowing customizations, will be replaced by a more flexible solution in an upcoming release.
+/// </summary>
+public interface IResourceProvider
+{
+    /// <summary>
+    /// Gets the HTML template
+    /// </summary>
+    /// <returns>The HTML template</returns>
+    string GetTemplateResource();
+    
+    /// <summary>
+    /// Gets the CSS resource
+    /// </summary>
+    /// <returns>The CSS resource</returns>
+    string GetCssResource();
+    
+    /// <summary>
+    /// Gets the JavaScript resource
+    /// </summary>
+    /// <returns>The JavaScript resource</returns>
+    string GetJavaScriptResource();
+}
\ No newline at end of file
diff --git a/dotnet/Cucumber.HtmlFormatter/MessagesToHtmlWriter.cs b/dotnet/Cucumber.HtmlFormatter/MessagesToHtmlWriter.cs
index 7c460b22..d2629d2d 100644
--- a/dotnet/Cucumber.HtmlFormatter/MessagesToHtmlWriter.cs
+++ b/dotnet/Cucumber.HtmlFormatter/MessagesToHtmlWriter.cs
@@ -9,6 +9,7 @@ public class MessagesToHtmlWriter : IDisposable
     private readonly Action<StreamWriter, Envelope> _streamSerializer;
     private readonly string _template;
     private readonly JsonInHtmlWriter _jsonInHtmlWriter;
+    private readonly IResourceProvider _resourceProvider;
     private bool _streamClosed = false;
     private bool _preMessageWritten = false;
     private bool _firstMessageWritten = false;
@@ -19,30 +20,36 @@ public class MessagesToHtmlWriter : IDisposable
     public MessagesToHtmlWriter(Stream stream, Action<StreamWriter, Envelope> streamSerializer) : this(new StreamWriter(stream), streamSerializer)
     {
     }
-    public MessagesToHtmlWriter(Stream stream, Func<StreamWriter, Envelope, Task> asyncStreamSerializer) : this(new StreamWriter(stream), asyncStreamSerializer) { }
+    
+    public MessagesToHtmlWriter(Stream stream, Func<StreamWriter, Envelope, Task> asyncStreamSerializer, IResourceProvider? resourceProvider = null) 
+        : this(new StreamWriter(stream), asyncStreamSerializer, resourceProvider) 
+    { }
 
     [Obsolete("Cucumber.HtmlFormatter moving to async only operations. Please use the MessagesToHtmlWriter(StreamWriter, Func<StreamWriter, Envelope, Task>) constructor", false)]
     public MessagesToHtmlWriter(StreamWriter writer, Action<StreamWriter, Envelope> streamSerializer)
     {
-        this._writer = writer;
-        this._streamSerializer = streamSerializer;
+        _writer = writer;
+        _streamSerializer = streamSerializer;
         // Create async wrapper for sync serializer
-        this._asyncStreamSerializer = (w, e) =>
+        _asyncStreamSerializer = (w, e) =>
         {
             streamSerializer(w, e);
             return Task.CompletedTask;
         };
-        _template = GetResource("index.mustache.html");
+        _resourceProvider = new DefaultResourceProvider();
+        _template = _resourceProvider.GetTemplateResource();
         _jsonInHtmlWriter = new JsonInHtmlWriter(writer);
         _isAsyncInitialized = false;
     }
-    public MessagesToHtmlWriter(StreamWriter writer, Func<StreamWriter, Envelope, Task> asyncStreamSerializer)
+    
+    public MessagesToHtmlWriter(StreamWriter writer, Func<StreamWriter, Envelope, Task> asyncStreamSerializer, IResourceProvider? resourceProvider = null)
     {
-        this._writer = writer;
-        this._asyncStreamSerializer = asyncStreamSerializer;
+        _writer = writer;
+        _asyncStreamSerializer = asyncStreamSerializer;
         // Create sync wrapper for async serializer (will block)
-        this._streamSerializer = (w, e) => asyncStreamSerializer(w, e).GetAwaiter().GetResult();
-        _template = GetResource("index.mustache.html");
+        _streamSerializer = (w, e) => asyncStreamSerializer(w, e).GetAwaiter().GetResult();
+        _resourceProvider = resourceProvider ?? new DefaultResourceProvider();
+        _template = _resourceProvider.GetTemplateResource();
         _jsonInHtmlWriter = new JsonInHtmlWriter(writer);
         _isAsyncInitialized = true;
     }
@@ -50,28 +57,28 @@ public MessagesToHtmlWriter(StreamWriter writer, Func<StreamWriter, Envelope, Ta
     private void WritePreMessage()
     {
         WriteTemplateBetween(_writer, _template, null, "{{css}}");
-        WriteResource(_writer, "main.css");
+        WriteResource(_writer, _resourceProvider.GetCssResource());
         WriteTemplateBetween(_writer, _template, "{{css}}", "{{messages}}");
     }
 
     private async Task WritePreMessageAsync()
     {
         await WriteTemplateBetweenAsync(_writer, _template, null, "{{css}}");
-        await WriteResourceAsync(_writer, "main.css");
+        await WriteResourceAsync(_writer, _resourceProvider.GetCssResource());
         await WriteTemplateBetweenAsync(_writer, _template, "{{css}}", "{{messages}}");
     }
 
     private void WritePostMessage()
     {
         WriteTemplateBetween(_writer, _template, "{{messages}}", "{{script}}");
-        WriteResource(_writer, "main.js");
+        WriteResource(_writer, _resourceProvider.GetJavaScriptResource());
         WriteTemplateBetween(_writer, _template, "{{script}}", null);
     }
 
     private async Task WritePostMessageAsync()
     {
         await WriteTemplateBetweenAsync(_writer, _template, "{{messages}}", "{{script}}");
-        await WriteResourceAsync(_writer, "main.js");
+        await WriteResourceAsync(_writer, _resourceProvider.GetJavaScriptResource());
         await WriteTemplateBetweenAsync(_writer, _template, "{{script}}", null);
     }
 
@@ -186,16 +193,14 @@ public async Task DisposeAsync()
         }
     }
 
-    private void WriteResource(StreamWriter writer, string v)
+    private void WriteResource(StreamWriter writer, string content)
     {
-        var resource = GetResource(v);
-        writer.Write(resource);
+        writer.Write(content);
     }
 
-    private async Task WriteResourceAsync(StreamWriter writer, string v)
+    private async Task WriteResourceAsync(StreamWriter writer, string content)
     {
-        var resource = GetResource(v);
-        await writer.WriteAsync(resource);
+        await writer.WriteAsync(content);
     }
 
     private void WriteTemplateBetween(StreamWriter writer, string template, string? begin, string? end)
@@ -216,14 +221,4 @@ private async Task WriteTemplateBetweenAsync(StreamWriter writer, string templat
         CalculateBeginAndLength(template, begin, end, out var beginIndex, out var lengthToWrite);
         await writer.WriteAsync(template.Substring(beginIndex, lengthToWrite));
     }
-
-    private string GetResource(string name)
-    {
-        var assembly = typeof(MessagesToHtmlWriter).Assembly;
-        var resourceStream = assembly.GetManifestResourceStream("Cucumber.HtmlFormatter.Resources." + name);
-        if (resourceStream == null)
-            throw new InvalidOperationException($"Resource '{name}' not found in assembly '{assembly.FullName}'");
-        var resource = new StreamReader(resourceStream).ReadToEnd();
-        return resource;
-    }
 }
diff --git a/dotnet/Cucumber.HtmlFormatterTest/DefaultResourceProviderTest.cs b/dotnet/Cucumber.HtmlFormatterTest/DefaultResourceProviderTest.cs
new file mode 100644
index 00000000..b07281d1
--- /dev/null
+++ b/dotnet/Cucumber.HtmlFormatterTest/DefaultResourceProviderTest.cs
@@ -0,0 +1,67 @@
+using Cucumber.HtmlFormatter;
+
+namespace Cucumber.HtmlFormatterTest;
+
+[TestClass]
+public class DefaultResourceProviderTest
+{
+    private DefaultResourceProvider _resourceProvider = null!;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        _resourceProvider = new DefaultResourceProvider();
+    }
+
+    [TestMethod]
+    public void GetTemplateResource_ReturnsNonEmptyString()
+    {
+        // Act
+        var template = _resourceProvider.GetTemplateResource();
+        
+        // Assert
+        Assert.IsNotNull(template, "Template resource should not be null");
+        Assert.IsTrue(!string.IsNullOrWhiteSpace(template), "Template resource should not be empty");
+        Assert.IsTrue(template.Contains("{{css}}"), "Template should contain CSS placeholder");
+        Assert.IsTrue(template.Contains("{{messages}}"), "Template should contain messages placeholder");
+        Assert.IsTrue(template.Contains("{{script}}"), "Template should contain script placeholder");
+    }
+
+    [TestMethod]
+    public void GetCssResource_ReturnsNonEmptyString()
+    {
+        // Act
+        var css = _resourceProvider.GetCssResource();
+        
+        // Assert
+        Assert.IsNotNull(css, "CSS resource should not be null");
+        Assert.IsTrue(!string.IsNullOrWhiteSpace(css), "CSS resource should not be empty");
+    }
+
+    [TestMethod]
+    public void GetJavaScriptResource_ReturnsNonEmptyString()
+    {
+        // Act
+        var javascript = _resourceProvider.GetJavaScriptResource();
+        
+        // Assert
+        Assert.IsNotNull(javascript, "JavaScript resource should not be null");
+        Assert.IsTrue(!string.IsNullOrWhiteSpace(javascript), "JavaScript resource should not be empty");
+    }
+
+    [TestMethod]
+    public void AllResources_LoadSuccessfully()
+    {
+        // This test verifies that all resources can be loaded in sequence without errors
+        
+        // Act & Assert - if any of these throw an exception, the test will fail
+        var template = _resourceProvider.GetTemplateResource();
+        Assert.IsNotNull(template, "Template resource should not be null");
+
+        var css = _resourceProvider.GetCssResource();
+        Assert.IsNotNull(css, "CSS resource should not be null");
+
+        var javascript = _resourceProvider.GetJavaScriptResource();
+        Assert.IsNotNull(javascript, "JavaScript resource should not be null");
+    }
+}
\ No newline at end of file