HTML to PDF in C# - The Reality of Library Options

wkhtmltopdf Wrappers — The DLL Loading Error Ecosystem

The most common search query bringing developers to these articles is some variation of:

System.DllNotFoundException: Unable to load DLL 'libwkhtmltox'

Platform-specific variants include:

Unable to load shared library 'wkhtmltox' or one of its dependencies
    (Linux — libwkhtmltox.so not found)

The specified module could not be found. (0x8007007E)
    (Windows — wkhtmltox.dll path not configured)

dyld: Library not loaded: libwkhtmltox.dylib
    (macOS — not supported on ARM64/Apple Silicon)

These errors come from DinkToPdf, NReco.PdfGenerator, WkHtmlToXSharp, and other C# wrappers around the same abandoned binary. The wkhtmltopdf GitHub organization was archived in July 2024. The underlying QtWebKit engine was deprecated by Qt in 2015. The project status page explicitly marks it as deprecated.

Beyond the DLL loading issues, the rendering engine is frozen at approximately Safari 2011 capability. No Flexbox, no Grid, limited CSS3, unreliable JavaScript. And there are unpatched critical vulnerabilities: CVE-2022-35583(CVSS 9.8) enables SSRF attacks that can exfiltrate AWS credentials through crafted HTML.

wkhtmltopdf's time has passed. The DLL loading errors are a symptom of a deeper problem: you're depending on abandoned software with no path forward.

iText 7 (pdfHTML Add-On) — Limited CSS, AGPL Licensed

Why Doesn't PdfSharp Support HTML?

PdfSharp appears in "HTML to PDF" search results because of its popularity (34.9 million NuGet downloads) and frequent recommendations. But PdfSharp has no HTML parser. It provides a coordinate-based drawing API: DrawString(), DrawRectangle(), DrawImage() with explicit X/Y positions.

The commonly suggested workaround, HtmlRenderer.PdfSharp, supports HTML 4.01 and CSS Level 2 only. If your HTML uses any CSS feature introduced after 2010 — Flexbox (2012), Grid (2017), custom properties (2017), border-radius (2011) — it won't render.

Developers who select PdfSharp expecting HTML support end up either manually positioning every element with coordinate-based code or adding a second library for HTML rendering — at which point PdfSharp is redundant.

What Makes Puppeteer Sharp Resource-Intensive?

Puppeteer Sharp controls headless Chrome via .NET bindings. Rendering accuracy matches Chrome because it is Chrome. The cost is operational: you manage external browser processes.

Here's what production Puppeteer Sharp deployment actually looks like — not the 5-line example from tutorials, but the browser pooling code you need for concurrent PDF generation:

using PuppeteerSharp;
using System.Collections.Concurrent;

public class PdfBrowserPool : IAsyncDisposable
{
    private readonly ConcurrentBag<IBrowser> _available = new();
    private readonly SemaphoreSlim _semaphore;
    private readonly int _maxBrowsers;

    public PdfBrowserPool(int maxBrowsers = 4)
    {
        _maxBrowsers = maxBrowsers;
        _semaphore = new SemaphoreSlim(maxBrowsers, maxBrowsers);
    }

    public async Task InitializeAsync()
    {
        await new BrowserFetcher().DownloadAsync(); // ~280MB download
        for (int i = 0; i < _maxBrowsers; i++)
        {
            var browser = await Puppeteer.LaunchAsync(new LaunchOptions
            {
                Headless = true,
                Args = new[] { "--no-sandbox", "--disable-setuid-sandbox",
                               "--disable-dev-shm-usage" }
            });
            _available.Add(browser);
        }
    }

    public async Task<byte[]> ConvertHtmlToPdf(string html)
    {
        await _semaphore.WaitAsync();
        IBrowser browser = null;
        try
        {
            if (!_available.TryTake(out browser))
                throw new InvalidOperationException("No browser available");

            await using var page = await browser.NewPageAsync();
            await page.SetContentAsync(html, new NavigationOptions
            {
                WaitUntil = new[] { WaitUntilNavigation.Networkidle0 }
            });
            var result = await page.PdfAsync(new PdfOptions
            {
                Format = PaperFormat.A4,
                PrintBackground = true
            });
            return result;
        }
        catch (Exception ex) when (ex is NavigationException or TargetClosedException)
        {
            // Browser crashed — replace it
            browser?.Dispose();
            browser = await Puppeteer.LaunchAsync(new LaunchOptions
            {
                Headless = true,
                Args = new[] { "--no-sandbox", "--disable-setuid-sandbox" }
            });
            throw; // Re-throw after recovery
        }
        finally
        {
            if (browser != null) _available.Add(browser);
            _semaphore.Release();
        }
    }

    public async ValueTask DisposeAsync()
    {
        foreach (var browser in _available)
        {
            await browser.CloseAsync();
            browser.Dispose();
        }
    }
}

using PuppeteerSharp;
using System.Collections.Concurrent;

public class PdfBrowserPool : IAsyncDisposable
{
    private readonly ConcurrentBag<IBrowser> _available = new();
    private readonly SemaphoreSlim _semaphore;
    private readonly int _maxBrowsers;

    public PdfBrowserPool(int maxBrowsers = 4)
    {
        _maxBrowsers = maxBrowsers;
        _semaphore = new SemaphoreSlim(maxBrowsers, maxBrowsers);
    }

    public async Task InitializeAsync()
    {
        await new BrowserFetcher().DownloadAsync(); // ~280MB download
        for (int i = 0; i < _maxBrowsers; i++)
        {
            var browser = await Puppeteer.LaunchAsync(new LaunchOptions
            {
                Headless = true,
                Args = new[] { "--no-sandbox", "--disable-setuid-sandbox",
                               "--disable-dev-shm-usage" }
            });
            _available.Add(browser);
        }
    }

    public async Task<byte[]> ConvertHtmlToPdf(string html)
    {
        await _semaphore.WaitAsync();
        IBrowser browser = null;
        try
        {
            if (!_available.TryTake(out browser))
                throw new InvalidOperationException("No browser available");

            await using var page = await browser.NewPageAsync();
            await page.SetContentAsync(html, new NavigationOptions
            {
                WaitUntil = new[] { WaitUntilNavigation.Networkidle0 }
            });
            var result = await page.PdfAsync(new PdfOptions
            {
                Format = PaperFormat.A4,
                PrintBackground = true
            });
            return result;
        }
        catch (Exception ex) when (ex is NavigationException or TargetClosedException)
        {
            // Browser crashed — replace it
            browser?.Dispose();
            browser = await Puppeteer.LaunchAsync(new LaunchOptions
            {
                Headless = true,
                Args = new[] { "--no-sandbox", "--disable-setuid-sandbox" }
            });
            throw; // Re-throw after recovery
        }
        finally
        {
            if (browser != null) _available.Add(browser);
            _semaphore.Release();
        }
    }

    public async ValueTask DisposeAsync()
    {
        foreach (var browser in _available)
        {
            await browser.CloseAsync();
            browser.Dispose();
        }
    }
}

Imports PuppeteerSharp
Imports System.Collections.Concurrent
Imports System.Threading

Public Class PdfBrowserPool
    Implements IAsyncDisposable

    Private ReadOnly _available As New ConcurrentBag(Of IBrowser)()
    Private ReadOnly _semaphore As SemaphoreSlim
    Private ReadOnly _maxBrowsers As Integer

    Public Sub New(Optional maxBrowsers As Integer = 4)
        _maxBrowsers = maxBrowsers
        _semaphore = New SemaphoreSlim(maxBrowsers, maxBrowsers)
    End Sub

    Public Async Function InitializeAsync() As Task
        Await (New BrowserFetcher()).DownloadAsync() ' ~280MB download
        For i As Integer = 0 To _maxBrowsers - 1
            Dim browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {
                .Headless = True,
                .Args = New String() {"--no-sandbox", "--disable-setuid-sandbox", "--disable-dev-shm-usage"}
            })
            _available.Add(browser)
        Next
    End Function

    Public Async Function ConvertHtmlToPdf(html As String) As Task(Of Byte())
        Await _semaphore.WaitAsync()
        Dim browser As IBrowser = Nothing
        Try
            If Not _available.TryTake(browser) Then
                Throw New InvalidOperationException("No browser available")
            End If

            Await Using page = Await browser.NewPageAsync()
                Await page.SetContentAsync(html, New NavigationOptions With {
                    .WaitUntil = New WaitUntilNavigation() {WaitUntilNavigation.Networkidle0}
                })
                Dim result = Await page.PdfAsync(New PdfOptions With {
                    .Format = PaperFormat.A4,
                    .PrintBackground = True
                })
                Return result
            End Using
        Catch ex As Exception When TypeOf ex Is NavigationException OrElse TypeOf ex Is TargetClosedException
            ' Browser crashed — replace it
            browser?.Dispose()
            browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {
                .Headless = True,
                .Args = New String() {"--no-sandbox", "--disable-setuid-sandbox"}
            })
            Throw ' Re-throw after recovery
        Finally
            If browser IsNot Nothing Then _available.Add(browser)
            _semaphore.Release()
        End Try
    End Function

    Public Async Function DisposeAsync() As ValueTask Implements IAsyncDisposable.DisposeAsync
        For Each browser In _available
            Await browser.CloseAsync()
            browser.Dispose()
        Next
    End Function
End Class

This is ~60 lines of infrastructure code before you generate a single PDF. You also need memory leak monitoring (Chromium processes accumulate memory over time), health checks, and a Dockerfile with 20+ Chromium dependencies. Docker image size increases by 300–400MB.

Compare this to the equivalent IronPDF approach:

using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
// Browser pooling, process management, crash recovery — handled internally

using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
// Browser pooling, process management, crash recovery — handled internally

Imports IronPdf

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
' Browser pooling, process management, crash recovery — handled internally

Puppeteer Sharp is viable if your team can absorb the operational overhead. For teams that want to focus on their application rather than browser infrastructure, IronPDF handles the same rendering internally.

Why Can't QuestPDF Convert HTML?

QuestPDF appears in virtually every "HTML to PDF C#" discussion on Reddit and Stack Overflow. This creates a consistent pattern: developers purchase or integrate QuestPDF expecting HTML conversion, then discover it doesn't render HTML at all.

QuestPDF is a fluent C# API for programmatic document creation. Its positioning is explicitly "stop fighting with HTML-to-PDF conversion" — it replaces the HTML approach with C# code. This is a deliberate design choice. GitHub discussions from 2022 through 2024 show developers discovering this after beginning implementation. The maintainers consistently confirm HTML support is not planned.

If your existing workflow uses HTML templates — Razor views for invoices, dashboard HTML for reports, web content for archiving — QuestPDF requires rewriting every template in C# fluent API code. For new projects where you're building document layouts from scratch with structured data, QuestPDF's API is well-designed and productive.

The Community License covers businesses under $1M annual gross revenue. Above that, commercial licensing is required.

What About Aspose.PDF?

Aspose.PDF provides broad PDF functionality with commercial licensing (starting ~$999/developer). The HTML conversion uses a custom engine, not a browser — similar to iText, it handles basic HTML but doesn't render modern CSS features accurately.

The primary concern is platform stability: Aspose depends on System.Drawing.Common, which requires libgdiplus on Linux. Microsoft deprecated this for non-Windows platforms in .NET 6+. Developers report memory leaks specific to Linux deployments that don't occur on Windows. For Windows-only environments, Aspose is capable. For cross-platform or containerized deployments, the dependency chain creates ongoing risk.

How Do I Migrate from Other Libraries?

For teams migrating from iTextSharp or wkhtmltopdf, IronPDF accepts URLs directly — useful when your existing workflow generates HTML files or serves pages:

using IronPdf;

var renderer = new ChromePdfRenderer();

// Convert from URL — useful when migrating from wkhtmltopdf URL-based workflows
var pdf = renderer.RenderUrlAsPdf("https://localhost:5001/reports/quarterly");
pdf.SaveAs("report.pdf");

// Convert from local HTML file
var pdfFromFile = renderer.RenderHtmlFileAsPdf("templates/invoice.html");
pdfFromFile.SaveAs("invoice.pdf");

using IronPdf;

var renderer = new ChromePdfRenderer();

// Convert from URL — useful when migrating from wkhtmltopdf URL-based workflows
var pdf = renderer.RenderUrlAsPdf("https://localhost:5001/reports/quarterly");
pdf.SaveAs("report.pdf");

// Convert from local HTML file
var pdfFromFile = renderer.RenderHtmlFileAsPdf("templates/invoice.html");
pdfFromFile.SaveAs("invoice.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Convert from URL — useful when migrating from wkhtmltopdf URL-based workflows
Dim pdf = renderer.RenderUrlAsPdf("https://localhost:5001/reports/quarterly")
pdf.SaveAs("report.pdf")

' Convert from local HTML file
Dim pdfFromFile = renderer.RenderHtmlFileAsPdf("templates/invoice.html")
pdfFromFile.SaveAs("invoice.pdf")

Deployment

IronPDF runs on Windows (x64), Linux (x64, ARM64), macOS (x64, Apple Silicon), and Docker containers. The Docker configuration is a standard .NET image:

FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
COPY . .
ENTRYPOINT ["dotnet", "MyApp.dll"]

No Chromium installation, no native library dependencies, no sandbox configuration.

Licensing: Perpetual licenses starting at $749. Published pricing at ironpdf.com. No AGPL, no per-document fees, no revenue thresholds.