Switching from ABCpdf for .NET to IronPDF is a strategic upgrade for development teams aiming for simplified licensing, modern documentation, and native cross-platform support. This thorough guide offers a step-by-step migration path, complete with API mappings and code conversion examples from real-world scenarios.
Whether you're working with .NET Framework 4.6.2 or targeting .NET 9, this ABCpdf migration guide ensures an easy transition to IronPDF's Chrome-based rendering engine.
ABCpdf from WebSupergoo (current line: v13.4.4, released 9 April 2026) has been a capable .NET PDF library for years. However, several factors make IronPDF an appealing alternative for modern development teams.
ABCpdf uses a tiered licensing model that can take effort to navigate. The Standard Single Computer license is $329 (32-bit only); Professional is $479; Professional Redistribution is $4,790; the Group License runs to $33,530. Licenses are perpetual, and v13 keys also cover v8-v12. Many developers report the tier maze as a significant administrative burden when budgeting for projects.
ABCpdf was Windows-only for most of its history. Linux support was added in v13 via the ABCpdf.ABCChrome117.Linux and ABCpdf.ABCChrome123.Linux runtime packages. macOS is not supported, and a few Windows-specific features (XPS, WPF) remain unavailable on Linux.
ABCpdf's documentation, while thorough, follows an older style that can feel dated compared to modern API documentation standards. New users often struggle to find the exact examples they need, particularly when working with newer .NET versions.
ABCpdf requires explicit engine selection - EngineType.Chrome123 (default in v13), Chrome117, Chrome86, Chrome65, Gecko, WebKit, or MSHtml - and manual resource management with doc.Clear() calls. This adds boilerplate code to every PDF operation that modern developers would prefer to avoid.
The following comparison table highlights key differences between the two .NET PDF libraries:
| Feature | ABCpdf for .NET | IronPDF |
|---|---|---|
| Rendering Engine | ABCChrome (Chrome123/117/86/65), Gecko, WebKit, MSHtml | Full Chromium (CSS3, JavaScript) |
| Cross-Platform | Windows-first; Linux added in v13 (no macOS) | Native Windows, Linux, macOS, Docker |
| Licensing Model | Standard $329 / Pro $479 / Pro Redistribution $4,790 / Group $33,530, perpetual | Simple, transparent pricing |
| .NET Support | .NET Framework 4.0+, .NET Core 3.0+, .NET 5+ | Framework 4.6.2 to .NET 9 |
| Resource Management | Manual doc.Clear() required | IDisposable with using statements |
| License Setup | Often uses registry | Simple code-based license key |
| Documentation | Dated style | Modern docs with extensive examples |
Ensure your development environment meets these requirements:
Run these commands in your solution directory to locate all files using ABCpdf for .NET:
grep -r "using WebSupergoo" --include="*.cs" .
grep -r "ABCpdf" --include="*.csproj" .This audit identifies every file requiring modification, ensuring complete migration coverage.
Understanding the architectural differences between ABCpdf for .NET and IronPDF prevents surprises during migration:
| Category | ABCpdf Behavior | IronPDF Behavior | Migration Action |
|---|---|---|---|
| Object Model | Doc class is central | ChromePdfRenderer + PdfDocument | Separate rendering from document |
| Resource Cleanup | Manual doc.Clear() | IDisposable pattern | Use using statements |
| Engine Selection | doc.HtmlOptions.Engine = EngineType.Chrome123 (or Chrome117/Chrome86/Chrome65/Gecko/WebKit/MSHtml) | Built-in Chromium | Remove engine config |
| Page Indexing | 1-based (doc.Page = 1) | 0-based (pdf.Pages[0]) | Adjust index references |
| Coordinates | Point-based with doc.Rect | CSS-based margins | Use CSS or RenderingOptions |
# Remove ABCpdf
dotnet remove package ABCpdf
# Install IronPDF
dotnet add package IronPdfAdd this at application startup, before any IronPDF operations:
// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"Update all namespace references throughout your codebase:
| Find | Replace With |
|---|---|
using WebSupergoo.ABCpdf13; | using IronPdf; |
using WebSupergoo.ABCpdf13.Objects; | using IronPdf; |
using WebSupergoo.ABCpdf12; | using IronPdf; |
using WebSupergoo.ABCpdf11; | using IronPdf; |
The following table maps ABCpdf for .NET methods to their IronPDF equivalents:
| ABCpdf Method | IronPDF Method |
|---|---|
new Doc() | new ChromePdfRenderer() |
doc.AddImageUrl(url) | renderer.RenderUrlAsPdf(url) |
doc.AddImageHtml(html) | renderer.RenderHtmlAsPdf(html) |
doc.AddImageFile(path) | renderer.RenderHtmlFileAsPdf(path) |
doc.Read(path) | PdfDocument.FromFile(path) |
doc.Save(path) | pdf.SaveAs(path) |
doc.GetData() | pdf.BinaryData |
doc.Clear() | Use using statement |
| ABCpdf Method | IronPDF Method |
|---|---|
doc.PageCount | pdf.PageCount |
doc.Page = n | pdf.Pages[n-1] |
doc.Delete(pageId) | pdf.RemovePages(index) |
doc.Append(otherDoc) | PdfDocument.Merge(pdf1, pdf2) |
doc.Rect.Inset(x, y) | RenderingOptions.MarginTop/Bottom/Left/Right |
| ABCpdf Method | IronPDF Method |
|---|---|
doc.Encryption.Password | pdf.SecuritySettings.OwnerPassword |
doc.Encryption.CanPrint | pdf.SecuritySettings.AllowUserPrinting |
doc.Encryption.CanCopy | pdf.SecuritySettings.AllowUserCopyPasteContent |
doc.SetInfo("Title", value) | pdf.MetaData.Title |
This example demonstrates converting a web page to PDF, one of the most common PDF generation tasks.
ABCpdf for .NET Implementation:
// NuGet: Install-Package ABCpdf
using System;
using WebSupergoo.ABCpdf13;
using WebSupergoo.ABCpdf13.Objects;
class Program
{
static void Main()
{
Doc doc = new Doc();
doc.HtmlOptions.Engine = EngineType.Chrome123;
doc.AddImageUrl("https://www.example.com");
doc.Save("output.pdf");
doc.Clear();
}
}Imports System
Imports WebSupergoo.ABCpdf13
Imports WebSupergoo.ABCpdf13.Objects
Class Program
Shared Sub Main()
Dim doc As New Doc()
doc.HtmlOptions.Engine = EngineType.Chrome123
doc.AddImageUrl("https://www.example.com")
doc.Save("output.pdf")
doc.Clear()
End Sub
End ClassIronPDF Implementation:
// NuGet: Install-Package IronPdf
using System;
using IronPdf;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
pdf.SaveAs("output.pdf");
}
}Imports System
Imports IronPdf
Class Program
Shared Sub Main()
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
pdf.SaveAs("output.pdf")
End Sub
End ClassIronPDF's approach eliminates the need for explicit engine configuration and manual cleanup, reducing code complexity while maintaining full Chrome rendering capabilities.
Converting HTML strings to PDF is essential for generating dynamic reports and documents.
ABCpdf for .NET Implementation:
// NuGet: Install-Package ABCpdf
using System;
using WebSupergoo.ABCpdf13;
using WebSupergoo.ABCpdf13.Objects;
class Program
{
static void Main()
{
string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
Doc doc = new Doc();
doc.HtmlOptions.Engine = EngineType.Chrome123;
doc.AddImageHtml(html);
doc.Save("output.pdf");
doc.Clear();
}
}Imports System
Imports WebSupergoo.ABCpdf13
Imports WebSupergoo.ABCpdf13.Objects
Module Program
Sub Main()
Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"
Dim doc As New Doc()
doc.HtmlOptions.Engine = EngineType.Chrome123
doc.AddImageHtml(html)
doc.Save("output.pdf")
doc.Clear()
End Sub
End ModuleIronPDF Implementation:
// NuGet: Install-Package IronPdf
using System;
using IronPdf;
class Program
{
static void Main()
{
string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
}
}Imports System
Imports IronPdf
Module Program
Sub Main()
Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
End Sub
End ModuleThe IronPDF version requires fewer lines of code and uses Chrome rendering by default, ensuring consistent output across all platforms.
Combining multiple PDF documents is a frequent requirement in document processing workflows.
ABCpdf for .NET Implementation:
// NuGet: Install-Package ABCpdf
using System;
using WebSupergoo.ABCpdf13;
using WebSupergoo.ABCpdf13.Objects;
class Program
{
static void Main()
{
Doc doc1 = new Doc();
doc1.Read("document1.pdf");
Doc doc2 = new Doc();
doc2.Read("document2.pdf");
doc1.Append(doc2);
doc1.Save("merged.pdf");
doc1.Clear();
doc2.Clear();
}
}' NuGet: Install-Package ABCpdf
Imports System
Imports WebSupergoo.ABCpdf13
Imports WebSupergoo.ABCpdf13.Objects
Module Program
Sub Main()
Dim doc1 As New Doc()
doc1.Read("document1.pdf")
Dim doc2 As New Doc()
doc2.Read("document2.pdf")
doc1.Append(doc2)
doc1.Save("merged.pdf")
doc1.Clear()
doc2.Clear()
End Sub
End ModuleIronPDF Implementation:
// NuGet: Install-Package IronPdf
using System;
using System.Collections.Generic;
using IronPdf;
class Program
{
static void Main()
{
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
}
}' NuGet: Install-Package IronPdf
Imports System
Imports System.Collections.Generic
Imports IronPdf
Module Program
Sub Main()
Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")
End Sub
End ModuleIronPDF's static Merge method provides a cleaner API that accepts multiple documents, eliminating the need to track and clear individual Doc instances.
This example shows a complete before/after migration for generating PDFs with custom margins.
Before (ABCpdf for .NET):
using WebSupergoo.ABCpdf13;
using WebSupergoo.ABCpdf13.Objects;
public byte[] GeneratePdf(string html)
{
Doc doc = new Doc();
doc.HtmlOptions.Engine = EngineType.Chrome123;
doc.Rect.Inset(20, 20);
doc.AddImageHtml(html);
byte[] data = doc.GetData();
doc.Clear(); // Manual cleanup required
return data;
}Imports WebSupergoo.ABCpdf13
Imports WebSupergoo.ABCpdf13.Objects
Public Function GeneratePdf(html As String) As Byte()
Dim doc As New Doc()
doc.HtmlOptions.Engine = EngineType.Chrome123
doc.Rect.Inset(20, 20)
doc.AddImageHtml(html)
Dim data As Byte() = doc.GetData()
doc.Clear() ' Manual cleanup required
Return data
End FunctionAfter (IronPDF):
using IronPdf;
public byte[] GeneratePdf(string html)
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;
using var pdf = renderer.RenderHtmlAsPdf(html);
return pdf.BinaryData; // Automatic cleanup with 'using'
}Imports IronPdf
Public Function GeneratePdf(html As String) As Byte()
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.MarginTop = 20
renderer.RenderingOptions.MarginBottom = 20
renderer.RenderingOptions.MarginLeft = 20
renderer.RenderingOptions.MarginRight = 20
Using pdf = renderer.RenderHtmlAsPdf(html)
Return pdf.BinaryData ' Automatic cleanup with 'Using'
End Using
End FunctionFor teams building web applications with .NET 6+, here's the recommended pattern:
ABCpdf Pattern:
[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
Doc doc = new Doc();
doc.HtmlOptions.Engine = EngineType.Chrome123;
doc.AddImageHtml(request.Html);
byte[] pdfBytes = doc.GetData();
doc.Clear();
return File(pdfBytes, "application/pdf", "report.pdf");
}<HttpPost>
Public Function GeneratePdf(<FromBody> request As ReportRequest) As IActionResult
Dim doc As New Doc()
doc.HtmlOptions.Engine = EngineType.Chrome123
doc.AddImageHtml(request.Html)
Dim pdfBytes As Byte() = doc.GetData()
doc.Clear()
Return File(pdfBytes, "application/pdf", "report.pdf")
End FunctionIronPDF Pattern:
[HttpPost]
public IActionResult GeneratePdf([FromBody] ReportRequest request)
{
var renderer = new ChromePdfRenderer();
using var pdf = renderer.RenderHtmlAsPdf(request.Html);
return File(pdf.BinaryData, "application/pdf", "report.pdf");
}<HttpPost>
Public Function GeneratePdf(<FromBody> request As ReportRequest) As IActionResult
Dim renderer As New ChromePdfRenderer()
Using pdf = renderer.RenderHtmlAsPdf(request.Html)
Return File(pdf.BinaryData, "application/pdf", "report.pdf")
End Using
End FunctionABCpdf doesn't have native async support. IronPDF provides async methods for better web application performance:
using IronPdf;
public async Task<byte[]> GeneratePdfAsync(string html)
{
var renderer = new ChromePdfRenderer();
using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
return pdf.BinaryData;
}Imports IronPdf
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
Dim renderer As New ChromePdfRenderer()
Using pdf = Await renderer.RenderHtmlAsPdfAsync(html)
Return pdf.BinaryData
End Using
End FunctionRegister IronPDF in modern .NET applications using current C# patterns:
// Program.cs (.NET 6+)
builder.Services.AddSingleton<ChromePdfRenderer>();
// Or create a service wrapper
public interface IPdfService
{
Task<byte[]> GeneratePdfAsync(string html);
}
public class IronPdfService : IPdfService
{
private readonly ChromePdfRenderer _renderer;
public IronPdfService()
{
_renderer = new ChromePdfRenderer();
_renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
}
public async Task<byte[]> GeneratePdfAsync(string html)
{
using var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
return pdf.BinaryData;
}
}
// Register: builder.Services.AddSingleton<IPdfService, IronPdfService>();Imports Microsoft.Extensions.DependencyInjection
Imports System.Threading.Tasks
' Program.vb (.NET 6+)
builder.Services.AddSingleton(Of ChromePdfRenderer)()
' Or create a service wrapper
Public Interface IPdfService
Function GeneratePdfAsync(html As String) As Task(Of Byte())
End Interface
Public Class IronPdfService
Implements IPdfService
Private ReadOnly _renderer As ChromePdfRenderer
Public Sub New()
_renderer = New ChromePdfRenderer()
_renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
End Sub
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte()) Implements IPdfService.GeneratePdfAsync
Using pdf = Await _renderer.RenderHtmlAsPdfAsync(html)
Return pdf.BinaryData
End Using
End Function
End Class
' Register: builder.Services.AddSingleton(Of IPdfService, IronPdfService)()// Good: Single renderer instance
var renderer = new ChromePdfRenderer();
foreach (var html in htmlList)
{
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs($"output_{i}.pdf");
}
// Bad: New renderer each time (slower startup)
foreach (var html in htmlList)
{
var renderer = new ChromePdfRenderer(); // Overhead!
using var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs($"output_{i}.pdf");
}Imports System
' Good: Single renderer instance
Dim renderer As New ChromePdfRenderer()
For Each html In htmlList
Using pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs($"output_{i}.pdf")
End Using
Next
' Bad: New renderer each time (slower startup)
For Each html In htmlList
Dim renderer As New ChromePdfRenderer() ' Overhead!
Using pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs($"output_{i}.pdf")
End Using
Next| Scenario | ABCpdf for .NET | IronPDF |
|---|---|---|
| Single 10-page PDF | ~80 MB | ~50 MB |
| Batch 100 PDFs | High (manual cleanup) | ~100 MB |
| Large HTML (5MB+) | Variable | ~150 MB |
Symptom: Output PDF has empty pages after migration.
Solution: JavaScript content may not be fully loaded before rendering:
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.RenderDelay(2000); // Wait 2 seconds
// Or wait for specific element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.RenderDelay(2000) ' Wait 2 seconds
' Or wait for specific element:
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded")Symptom: TextHeader/TextFooter not visible in output.
Solution: Ensure margins leave room for header/footer content:
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 40; // mm - leave room for header
renderer.RenderingOptions.MarginBottom = 40; // mm - leave room for footer
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
CenterText = "Header Text",
FontSize = 12
};Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.MarginTop = 40 ' mm - leave room for header
renderer.RenderingOptions.MarginBottom = 40 ' mm - leave room for footer
renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
.CenterText = "Header Text",
.FontSize = 12
}grep -r "WebSupergoo" --include="*.cs" .using statementsDoc instantiation to ChromePdfRendererdoc.Clear() with using statements
Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.
IronPDF is a part of IRONSUITE
10 .NET API products for your office documents
When you need your PDF to look like HTML, fast.
