COMPARISON

Scryber.Core vs IronPDF: Technical Comparison Guide

Published:

When .NET developers evaluate PDF generation solutions, Scryber.Core and IronPDF represent different approaches with distinct architectural philosophies and licensing models. Scryber.Core provides an open-source library using XML/HTML templates with a custom parsing engine, while IronPDF offers a Chromium-based rendering engine designed for high-fidelity HTML-to-PDF conversion. This technical comparison examines both libraries across the dimensions that matter most to professional developers and architects making PDF generation decisions for .NET applications in 2025 and beyond.

Understanding Scryber.Core

Scryber.Core is an open-source library that transforms HTML templates into PDFs using C#. The library leverages HTML's versatility and CSS styling capabilities to provide a template-driven PDF generation approach. Scryber.Core uses a custom parsing engine rather than a browser-based renderer, processing documents through its proprietary Document.ParseDocument() method.

The library operates under LGPL licensing, which means there are no direct costs to use Scryber.Core in projects as long as developers comply with the LGPL terms. However, this licensing model demands that any modifications to the library itself are open-sourced, which can be limiting for some commercial applications.

Key Consideration: Scryber.Core uses proprietary binding syntax for data templates and XML-heavy configuration approaches. The library does not execute JavaScript, providing static rendering only with limited CSS support compared to browser-based solutions.

Understanding IronPDF

IronPDF provides a commercially supported PDF generation library that uses a Chromium-based rendering engine. The library converts HTML, CSS, and JavaScript into PDF documents with full browser-level fidelity, supporting modern CSS3 features including Flexbox and CSS Grid, along with complete JavaScript ES2024 execution.

IronPDF installs as a NuGet package without the licensing restrictions associated with LGPL. The library provides extensive documentation, professional support, and a larger community compared to open-source alternatives.

Architectural Comparison

The fundamental differences between Scryber.Core and IronPDF affect rendering capabilities and development workflows:

AspectScryber.CoreIronPDF
LicenseLGPL (restrictive)Commercial
Rendering EngineCustom parserChromium
CSS SupportLimitedFull CSS3
JavaScriptNoFull ES2024
Template BindingProprietary XMLStandard (Razor, etc.)
Learning CurveCustom syntaxStandard HTML/CSS
Async SupportLimitedFull
DocumentationBasicExtensive

Feature Comparison Matrix

FeatureScryber.CoreIronPDF
HTML to PDFBasicFull Chromium
URL to PDFManual fetch requiredNative support
CSS GridLimitedSupported
FlexboxLimitedSupported
JavaScriptNoFull ES2024
Data BindingProprietary XMLUse Razor/Handlebars
Headers/FootersXML-basedHTML/CSS
Merge PDFsLimitedBuilt-in
Split PDFsNoYes
WatermarksBasicFull HTML
Digital SignaturesNoYes
PDF/ANoYes
Password ProtectionBasicFull
Cross-PlatformYesYes

HTML to PDF Conversion

The core HTML-to-PDF workflow demonstrates fundamental API differences between the libraries.

Scryber.Core HTML Conversion

Scryber.Core uses the Document.ParseDocument() method with a custom parsing engine:

// NuGet: Install-Package Scryber.Core
using Scryber.Core;
using Scryber.Core.Html;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

        using (var doc = Document.ParseDocument(html, ParseSourceType.DynamicContent))
        {
            doc.SaveAsPDF("output.pdf");
        }
    }
}
// NuGet: Install-Package Scryber.Core
using Scryber.Core;
using Scryber.Core.Html;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

        using (var doc = Document.ParseDocument(html, ParseSourceType.DynamicContent))
        {
            doc.SaveAsPDF("output.pdf");
        }
    }
}
$vbLabelText   $csharpLabel

This approach requires:

  • Explicit using statement for proper resource disposal
  • The ParseSourceType.DynamicContent parameter for HTML string parsing
  • Document-based API that differs from standard HTML rendering patterns

IronPDF HTML Conversion

IronPDF provides the ChromePdfRenderer class with direct HTML conversion:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
$vbLabelText   $csharpLabel

The RenderHtmlAsPdf method uses the Chromium rendering engine to process HTML with full CSS and JavaScript support. The API follows a straightforward render-then-save pattern without requiring explicit resource management syntax.

URL to PDF Conversion

Converting live web pages to PDF reveals a significant capability difference between the libraries.

Scryber.Core URL Handling

Scryber.Core cannot directly render URLs—developers must manually fetch HTML content:

// NuGet: Install-Package Scryber.Core
using Scryber.Core;
using Scryber.Core.Html;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();
        string html = await client.GetStringAsync("https://www.example.com");

        using (var doc = Document.ParseDocument(html, ParseSourceType.DynamicContent))
        {
            doc.SaveAsPDF("webpage.pdf");
        }
    }
}
// NuGet: Install-Package Scryber.Core
using Scryber.Core;
using Scryber.Core.Html;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();
        string html = await client.GetStringAsync("https://www.example.com");

        using (var doc = Document.ParseDocument(html, ParseSourceType.DynamicContent))
        {
            doc.SaveAsPDF("webpage.pdf");
        }
    }
}
$vbLabelText   $csharpLabel

This workaround approach:

  • Requires explicit HTTP client management
  • Downloads raw HTML without executing JavaScript
  • Cannot capture dynamically rendered content
  • Loses relative resource references (images, stylesheets)

IronPDF URL Conversion

IronPDF provides native URL-to-PDF conversion:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
$vbLabelText   $csharpLabel

The RenderUrlAsPdf method navigates to the URL using the Chromium engine, executes JavaScript, applies CSS styling, and captures the fully rendered page as a PDF document.

Custom Rendering Settings

Page configuration and rendering options demonstrate different API approaches.

Scryber.Core Custom Settings

Scryber.Core configures settings through the document's RenderOptions property:

// NuGet: Install-Package Scryber.Core
using Scryber.Core;
using Scryber.Core.Html;
using Scryber.Drawing;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body></html>";

        using (var doc = Document.ParseDocument(html, ParseSourceType.DynamicContent))
        {
            doc.RenderOptions.Compression = OutputCompressionType.FlateDecode;
            doc.RenderOptions.PaperSize = PaperSize.A4;
            doc.SaveAsPDF("custom.pdf");
        }
    }
}
// NuGet: Install-Package Scryber.Core
using Scryber.Core;
using Scryber.Core.Html;
using Scryber.Drawing;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body></html>";

        using (var doc = Document.ParseDocument(html, ParseSourceType.DynamicContent))
        {
            doc.RenderOptions.Compression = OutputCompressionType.FlateDecode;
            doc.RenderOptions.PaperSize = PaperSize.A4;
            doc.SaveAsPDF("custom.pdf");
        }
    }
}
$vbLabelText   $csharpLabel

The configuration occurs after document parsing but before saving. Margin configuration requires additional XML-based styling or programmatic page section manipulation.

IronPDF Custom Settings

IronPDF configures settings through the renderer's RenderingOptions property before conversion:

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 40;
        renderer.RenderingOptions.MarginBottom = 40;

        string html = "<html><body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("custom.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 40;
        renderer.RenderingOptions.MarginBottom = 40;

        string html = "<html><body><h1>Custom PDF</h1><p>With custom margins and settings.</p></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("custom.pdf");
    }
}
$vbLabelText   $csharpLabel

The RenderingOptions property provides direct access to paper size, margins, and other PDF settings through strongly-typed properties. The renderer can be configured once and reused for multiple conversions.

API Mapping Reference

Teams evaluating Scryber.Core migration to IronPDF can reference this mapping of equivalent operations:

Scryber.CoreIronPDF
Document.ParseDocument(html)renderer.RenderHtmlAsPdf(html)
Document.ParseTemplate(path)renderer.RenderHtmlFileAsPdf(path)
doc.SaveAsPDF(path)pdf.SaveAs(path)
doc.SaveAsPDF(stream)pdf.Stream or pdf.BinaryData
doc.Info.Titlepdf.MetaData.Title
doc.Info.Authorpdf.MetaData.Author
PDFPagepdf.Pages[i]
PDFLayoutDocumentRenderingOptions
PDFStyleCSS in HTML
Data binding ({{value}})Razor/String interpolation
doc.RenderOptions.PaperSizerenderer.RenderingOptions.PaperSize

The Template Binding Difference

Scryber.Core uses proprietary XML-based binding syntax that requires learning a custom templating language:

<!-- Scryber proprietary binding -->
<pdf:Para text='{{model.Name}}' />
<pdf:Para text='Total: {{model.Total:C}}' />
<pdf:ForEach on='{{model.Items}}'>
    <pdf:Para text='{{.Name}}: {{.Price}}' />
</pdf:ForEach>
<!-- Scryber proprietary binding -->
<pdf:Para text='{{model.Name}}' />
<pdf:Para text='Total: {{model.Total:C}}' />
<pdf:ForEach on='{{model.Items}}'>
    <pdf:Para text='{{.Name}}: {{.Price}}' />
</pdf:ForEach>
XML

IronPDF uses standard C# string interpolation or any templating engine (Razor, Handlebars):

// Standard C# with IronPDF
var items = model.Items.Select(i => $"<li>{i.Name}: {i.Price:C}</li>");

var html = $@"
<p>{model.Name}</p>
<p>Total: {model.Total:C}</p>
<ul>
    {string.Join("", items)}
</ul>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
// Standard C# with IronPDF
var items = model.Items.Select(i => $"<li>{i.Name}: {i.Price:C}</li>");

var html = $@"
<p>{model.Name}</p>
<p>Total: {model.Total:C}</p>
<ul>
    {string.Join("", items)}
</ul>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
$vbLabelText   $csharpLabel

The IronPDF approach leverages existing C# and web development skills rather than requiring developers to learn a proprietary template syntax.

Headers and Footers Implementation

Document headers and footers reveal significant workflow differences.

Scryber.Core Headers and Footers

Scryber.Core requires XML-based header and footer definitions:

<!-- Scryber XML template -->
<?xml version='1.0' encoding='utf-8' ?>
<pdf:Document xmlns:pdf='http://www.scryber.co.uk/schemas/core/release/v1/Scryber.Components.xsd'>
    <Pages>
        <pdf:Section>
            <Header>
                <pdf:Para text='Company Report' />
            </Header>
            <Footer>
                <pdf:Para text='Page {{pagenum}} of {{pagetotal}}' />
            </Footer>
            <Content>
                <pdf:H1 text='Content Here' />
            </Content>
        </pdf:Section>
    </Pages>
</pdf:Document>
<!-- Scryber XML template -->
<?xml version='1.0' encoding='utf-8' ?>
<pdf:Document xmlns:pdf='http://www.scryber.co.uk/schemas/core/release/v1/Scryber.Components.xsd'>
    <Pages>
        <pdf:Section>
            <Header>
                <pdf:Para text='Company Report' />
            </Header>
            <Footer>
                <pdf:Para text='Page {{pagenum}} of {{pagetotal}}' />
            </Footer>
            <Content>
                <pdf:H1 text='Content Here' />
            </Content>
        </pdf:Section>
    </Pages>
</pdf:Document>
XML

This approach requires XML template files with proprietary namespace declarations and element names.

IronPDF Headers and Footers

IronPDF provides fully programmatic HTML-based header and footer configuration:

using IronPdf;

var renderer = new ChromePdfRenderer();

// HTML header with full CSS support
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: center; font-size: 12pt; border-bottom: 1px solid #ccc;'>
            Company Report
        </div>",
    MaxHeight = 30
};

// HTML footer with page numbers
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: center; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    MaxHeight = 25
};

var pdf = renderer.RenderHtmlAsPdf("<h1>Content Here</h1>");
pdf.SaveAs("report.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

// HTML header with full CSS support
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: center; font-size: 12pt; border-bottom: 1px solid #ccc;'>
            Company Report
        </div>",
    MaxHeight = 30
};

// HTML footer with page numbers
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: center; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    MaxHeight = 25
};

var pdf = renderer.RenderHtmlAsPdf("<h1>Content Here</h1>");
pdf.SaveAs("report.pdf");
$vbLabelText   $csharpLabel

IronPDF's HtmlHeaderFooter class enables full HTML/CSS styling with {page} and {total-pages} placeholders for dynamic page numbering.

The LGPL Licensing Consideration

Scryber.Core's LGPL license creates specific obligations that affect commercial applications:

LGPL Requirements:

  • Any modifications to the Scryber.Core library itself must be open-sourced
  • Applications must allow users to replace the LGPL library with modified versions
  • Source disclosure may be required in some commercial distribution scenarios

IronPDF Commercial License:

  • No source disclosure requirements
  • No restrictions on modifications or distribution
  • Clear licensing without compliance complexity
  • Professional support included

For organizations evaluating long-term commercial deployment, the licensing model difference significantly affects legal and compliance planning.

When Teams Consider Scryber.Core Migration

Several factors prompt development teams to evaluate alternatives to Scryber.Core:

LGPL license concerns affect commercial applications where source disclosure obligations conflict with business requirements. IronPDF's commercial license eliminates these restrictions.

Limited CSS support becomes problematic when designs use modern CSS features. Scryber.Core's custom parser cannot render Flexbox, CSS Grid, or complex styling that a Chromium-based engine handles natively.

No JavaScript execution blocks dynamic content rendering. Single-page applications, charts, and interactive content require JavaScript execution that Scryber.Core cannot provide.

Proprietary template syntax increases learning curve and limits developer onboarding. Teams familiar with HTML/CSS must learn Scryber's custom binding syntax rather than leveraging existing skills.

Smaller community means fewer resources for troubleshooting and less third-party documentation. IronPDF's larger community provides more examples and support resources.

Limited async support affects application scalability. Modern .NET applications targeting .NET 10 and C# 14 in 2026 benefit from full async/await support throughout the PDF generation pipeline.

Strengths and Trade-offs

Scryber.Core Strengths

  • Open-source with no direct licensing costs (LGPL compliance required)
  • Cross-platform support across .NET environments
  • HTML template approach for developers familiar with web technologies
  • Suitable for projects where LGPL terms align with business model

Scryber.Core Limitations

  • LGPL licensing restricts some commercial applications
  • Custom parsing engine with limited CSS support
  • No JavaScript execution (static rendering only)
  • Proprietary XML binding syntax requires learning curve
  • Smaller community with less documentation
  • Limited async support
  • No native URL-to-PDF capability
  • No PDF manipulation features (merge, split, signatures)

IronPDF Strengths

  • Full Chromium rendering with CSS3 and JavaScript ES2024 support
  • Native URL-to-PDF conversion
  • Standard HTML/CSS templating (use Razor, Handlebars, or plain HTML)
  • Commercial license without LGPL restrictions
  • Extensive documentation and professional support
  • Full async/await support
  • PDF manipulation capabilities (merge, split, watermarks)
  • Digital signatures and security features
  • PDF/A compliance support

IronPDF Considerations

  • Commercial licensing model requires purchase
  • Chromium engine has larger footprint than custom parsers

Conclusion

Scryber.Core and IronPDF serve different organizational contexts and technical requirements. Scryber.Core provides an open-source option for developers seeking LGPL-licensed PDF generation with HTML templates and willing to work within the library's custom syntax and rendering limitations.

For applications requiring modern CSS rendering, JavaScript execution, native URL conversion, or commercial licensing without LGPL obligations, IronPDF provides comprehensive capabilities through its Chromium-based engine. The ability to use standard HTML/CSS templates, leverage existing web development skills, and access PDF manipulation features addresses common limitations teams encounter with custom-parser solutions.

When evaluating Scryber.Core migration to IronPDF, teams should consider their specific requirements around CSS complexity, JavaScript needs, licensing preferences, and template workflow preferences. For teams targeting modern .NET platforms with web-based design workflows, IronPDF's architecture aligns more naturally with contemporary development practices.

For implementation guidance, explore the IronPDF HTML-to-PDF tutorial and documentation covering PDF generation patterns for .NET applications.