What .NET Developers Are Saying About PDF Libraries

PDF Generation is one of those features every .NET developer eventually needs—and every developer has opinions about. From licensing traps to rendering nightmares, the .NET PDF ecosystem is... complicated.

I've been watching developer discussions on Twitter/X about PDF libraries, and the recurring themes are striking. Here's what .NET developers are actually saying about PDFs in 2024-2025.

What Themes Keep Coming Up?

1. "Wait, iText Requires Open-Sourcing My App?"

The most common surprise:

Developers discover AGPL licensing after integrating iText into production apps.

Typical journey:

1. Search "C# PDF library"
2. Find iText (labeled "open source")
3. Install via NuGet
4. Deploy to production
5. Someone mentions licensing
6. Read AGPL terms for the first time
7. Panic

The realization:

"TIL that using iText in my SaaS app means I have to open-source my entire codebase or pay $1,800/year. This should be disclosed upfront, not buried in legal docs."

Why this happens:

• iText is marketed as "open source" (technically true)
• AGPL is listed in NuGet (but who reads licenses?)
• Most developers don't understand copyleft vs. permissive licenses
• By the time they realize, they're already in production

The fix:
Check licenses before integrating. Use dotnet list package to audit dependencies.

2. "Why Do All My Bootstrap Layouts Break in PDFs?"

The problem:

Modern CSS frameworks (Bootstrap 4/5, Tailwind) rely heavily on Flexbox and CSS Grid. Many PDF libraries don't support these features.

Typical complaint:

"Spent 3 hours debugging why my Bootstrap invoice template renders perfectly in Chrome but breaks in my PDF. Turns out [library name] doesn't support flexbox. In 2025. Why?"

What breaks:

<div class="row">
    <div class="col">Column 1</div>
    <div class="col">Column 2</div>
    <div class="col">Column 3</div>
</div>

Expected: Three side-by-side columns
Reality (in non-Chromium libraries): Three rows stacked vertically

Libraries with this problem:

• iTextSharp (no flexbox support)
• iText 7 pdfHTML add-on (limited flexbox)
• wkhtmltopdf (outdated WebKit, no modern CSS)
• PDFSharp (no HTML rendering at all)

Libraries that handle it:

• IronPDF (Chromium-based)
• Puppeteer-Sharp (Chromium-based)
• Playwright (Chromium-based)

Developer insight:

"After wasting a day fighting CSS, I switched to IronPDF. Bootstrap layouts just work now. Should've started there."

3. "wkhtmltopdf is Abandoned, Now What?"

The backstory:

wkhtmltopdf was a popular open-source HTML-to-PDF tool. In January 2023, the maintainers announced the project is no longer maintained and recommended migrating to alternatives.

Typical reaction:

"Our entire reporting system is built on wkhtmltopdf. It was abandoned in 2023 and has unfixed CVEs. Management won't budget for a rewrite. Cool cool cool."

The problem:

• wkhtmltopdf is based on Qt WebKit (frozen in 2015)
• No modern CSS support (no flexbox, grid, CSS variables)
• Security vulnerabilities won't be fixed
• Doesn't work with .NET Core on Linux without workarounds

Wrappers affected:

• DinkToPDF (wraps wkhtmltopdf in .NET)
• Rotativa (ASP.NET wrapper for wkhtmltopdf)
• TuesPechkin (another wkhtmltopdf wrapper)

Migration paths:

• Free: Playwright or Puppeteer-Sharp (browser automation, complex deployment)
• Paid: IronPDF ($749, Chromium-based, built for production)

Developer insight:

"Migrated from wkhtmltopdf to IronPDF. Docker image went from 600MB to 300MB, and PDFs actually look like the web page now. Worth every penny."

4. "Why Does My PDF Library Download 300MB of Chromium?"

The complaint:

Puppeteer-Sharp and Playwright download full Chromium browser binaries (~300-400MB) for PDF generation.

Typical frustration:

"My Docker image is 1.2GB because Puppeteer downloads an entire browser just to generate invoices. There has to be a better way."

Why this happens:

• Puppeteer-Sharp and Playwright are browser automation tools, not PDF libraries
• They spawn headless Chrome/Chromium for rendering
• Each deployment downloads the browser binary

Comparison:

Library	Binary Size	Notes
Puppeteer-Sharp	~350MB	Full Chromium browser
Playwright	~400MB	Chromium + WebKit + Firefox
IronPDF	~100MB	Embedded Chromium rendering engine
iTextSharp	~5MB	No browser (poor HTML support)

Trade-offs:

• Puppeteer/Playwright: Free, but heavyweight and complex deployment
• IronPDF: $749, lighter footprint, purpose-built for PDFs
• iTextSharp: Small, but terrible HTML rendering and AGPL licensing

Developer insight:

"Switched from Playwright to IronPDF. Docker image dropped 200MB, deployment is simpler, and I get actual PDF manipulation features."

5. "Can Someone Explain PDF Library Pricing?"

The confusion:

PDF library pricing models vary wildly, and many have hidden costs.

Typical question:

"Why do PDF libraries cost $500-$2,000? I just need to convert HTML to PDF. Is this a racket?"

The reality:

Building a production-grade PDF library requires:

• PDF specification implementation (756-page spec)
• HTML/CSS rendering engine (Chromium is 25M+ lines of code)
• Text extraction, form fields, digital signatures
• Cross-platform support (Windows, Linux, macOS)
• Ongoing maintenance and bug fixes

Pricing models:

Library	Model	Cost
iText 7	AGPL or annual subscription	$1,800+/year per dev
Aspose.PDF	Perpetual or subscription	$1,999-$4,999 one-time
Syncfusion	Annual subscription	$995/year per dev
IronPDF	Perpetual license	$749 one-time per dev
PDFSharp	Open source (MIT)	Free (basic features)
Puppeteer-Sharp	Open source (Apache 2.0)	Free (heavyweight)

Developer insight:

"Spent $749 on IronPDF. That's ~3 hours of billable time. It's saved me at least 40 hours of fighting wkhtmltopdf. ROI is ridiculous."

6. "I Just Want to Generate a Simple Invoice PDF"

The frustration:

Simple tasks (invoices, receipts, reports) require learning complex APIs.

Typical complaint:

"I don't need to understand PDF coordinate systems, fonts, and page structures. I just want to convert this HTML invoice to PDF."

Complex APIs (iTextSharp):

var htmlStream = new MemoryStream(Encoding.UTF8.GetBytes(html));
using var pdfStream = new FileStream("invoice.pdf", FileMode.Create);
var document = new Document();
var writer = PdfWriter.GetInstance(document, pdfStream);
document.Open();
XMLWorkerHelper.GetInstance().ParseXHtml(writer, document, htmlStream, null);
document.Close();

Simple APIs (IronPDF):

using IronPdf;
// Install via NuGet: Install-Package IronPdf

var renderer = new [ChromePdfRenderer](https://ironpdf.com/blog/videos/how-to-render-html-string-to-pdf-in-csharp-ironpdf/)();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("invoice.pdf");

Developer insight:

"Why did I waste 2 days with iTextSharp when IronPDF does it in 3 lines? Read the room, library devs. We want simple."

7. "JavaScript Doesn't Execute in My PDFs"

The problem:

Many developers use JavaScript charting libraries (Chart.js, D3.js, ApexCharts) in HTML reports. Non-browser-based PDF libraries can't execute JavaScript.

Typical frustration:

"My sales dashboard has Chart.js graphs. They render fine in the browser but don't appear in the PDF. What am I missing?"

What doesn't work:

<canvas id="chart"></canvas>
<script>
    new Chart(document.getElementById('chart'), {
        type: 'bar',
        data: { labels: ['Q1', 'Q2', 'Q3'], datasets: [...] }
    });
</script>

Libraries that can't execute JavaScript:

• iTextSharp (no JavaScript engine)
• iText 7 pdfHTML (no JavaScript)
• PDFSharp (no HTML rendering at all)

Libraries that execute JavaScript:

• IronPDF (Chromium rendering)
• Puppeteer-Sharp (Chromium)
• Playwright (Chromium/Firefox/WebKit)

The fix (IronPDF):

using IronPdf;
// Install via NuGet: Install-Package IronPdf

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.RenderDelay = 500; // Wait for Chart.js to render

var pdf = renderer.RenderHtmlAsPdf(htmlWithChartJs);
pdf.SaveAs("sales-report.pdf");

Developer insight:

"Wasted a week trying to make Chart.js work with iText. Switched to IronPDF, added RenderDelay, worked first try."

8. "Why Can't I Use Google Fonts in PDFs?"

The problem:

Web fonts (Google Fonts, custom fonts) often fail to load in PDFs.

Typical complaint:

"My invoice uses Roboto from Google Fonts. Looks perfect in the browser, renders in Times New Roman in the PDF. Why?"

What goes wrong:

<link href="https://fonts.googleapis.com/css2?family=Roboto:wght@400;700&display=swap" rel="stylesheet">
<h1 style="font-family: 'Roboto', sans-serif;">Invoice</h1>

Libraries with font issues:

• iTextSharp (requires manual font embedding)
• iText 7 (better, but still requires configuration)
• wkhtmltopdf (unreliable web font loading)

Libraries that handle fonts reliably:

• IronPDF (Chromium loads fonts like a browser)
• Puppeteer-Sharp (Chromium)
• Playwright (Chromium)

Developer insight:

"Google Fonts just work in IronPDF. No font embedding, no configuration. It renders PDFs exactly like Chrome does."

Common Pain Points Summary

Based on developer discussions, here are the top PDF pain points in .NET:

1. Licensing Surprises

• iText's AGPL trap catches developers off-guard
• $1,800/year costs discovered after integration
• Lack of upfront transparency

2. HTML/CSS Rendering

• Bootstrap layouts break (no flexbox/grid support)
• Modern CSS ignored
• PDFs don't match browser output

3. Abandoned Tools

• wkhtmltopdf no longer maintained (security risk)
• iTextSharp frozen since 2016
• Migration required mid-project

4. Deployment Complexity

• Puppeteer/Playwright require 300MB+ browser binaries
• Docker images bloat
• Platform-specific dependencies

5. JavaScript Execution

• Charts don't render (Chart.js, D3.js fail)
• Dynamic content missing from PDFs
• No SPA support

6. API Complexity

• iTextSharp requires 20+ lines for simple conversions
• Steep learning curves
• Poor documentation

7. Font Loading

• Google Fonts fail to load
• Custom fonts require manual embedding
• Fallback to system fonts breaks designs

8. Cost Confusion

• Pricing models unclear (per-dev, per-server, runtime fees?)
• Hidden costs (iText pdfHTML add-on, runtime licenses)
• Free options have major trade-offs

What Developers Actually Want

From Twitter discussions, developers want:

1. Simple APIs — "3 lines to convert HTML to PDF, not 30"
2. Transparent pricing — "Show me the cost upfront, not after I integrate"
3. Modern CSS support — "If Bootstrap works in Chrome, it should work in the PDF"
4. JavaScript execution — "My charts should render"
5. Reliable fonts — "Google Fonts should just work"
6. Lightweight deployment — "I don't want 500MB Docker images"
7. Clear licensing — "No AGPL surprises"
8. Active maintenance — "Fix security bugs, support new .NET versions"

How IronPDF Addresses These Pain Points

Based on developer feedback:

using IronPdf;
// Install via NuGet: Install-Package IronPdf

// Simple API (3 lines)
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
pdf.SaveAs("output.pdf");

What developers appreciate about IronPDF:

✅ Modern CSS support — Chromium rendering (flexbox, grid, variables)
✅ JavaScript execution — Charts render correctly
✅ Google Fonts work — No manual font embedding
✅ Simple API — 3 lines for HTML to PDF
✅ Clear pricing — $749 per developer, no hidden costs
✅ No AGPL trap — Commercial-first licensing
✅ Active maintenance — Supports .NET 10, monthly updates
✅ Lighter deployment — ~100MB vs. 300MB+ for Puppeteer

The Bottom Line

From hundreds of developer discussions, the pattern is clear:

Pain points:

1. AGPL licensing traps (iText)
2. Abandoned tools (wkhtmltopdf, iTextSharp)
3. Poor HTML rendering (no flexbox/grid)
4. Complex APIs (iTextSharp, Aspose)
5. Heavyweight deployments (Puppeteer/Playwright)

What works:

• Chromium-based rendering (modern CSS, JavaScript)
• Simple APIs (HTML in, PDF out)
• Transparent commercial licensing
• Active maintenance and support

Developer verdict:

"After trying iTextSharp, wkhtmltopdf, and Puppeteer, I finally landed on IronPDF. It just works. Bootstrap renders correctly, Google Fonts load, Chart.js graphs appear. $749 well spent."

If you're building a .NET application that generates PDFs, learn from other developers' mistakes: skip the abandoned tools and licensing traps. Use a modern, Chromium-based library with transparent pricing and active support.

---

Written by Jacob Mellor, CTO at Iron Software. Jacob created IronPDF and leads a team of 50+ engineers building .NET document processing libraries.