DEV Community

IronSoftware
IronSoftware

Posted on

TuesPechkin vs IronPDF: side by side for .NET teams in 2026

#csharp #dotnet

IronPDF is a commercial .NET library using a modern Chromium rendering engine — the same technology powering Chrome and Edge. Rather than wrapping a decade-old WebKit fork, it renders HTML/CSS/JavaScript the way current browsers display content. Install via NuGet (IronPdf), no separate binary downloads required, and it targets Windows, Linux, macOS, Docker, and Azure.

The core API centers on ChromePdfRenderer with methods like RenderHtmlAsPdf() for strings, RenderUrlAsPdf() for live sites, and RenderHtmlFileAsPdf() for local templates. It handles CSS Grid, Flexbox, Web Fonts, SVG, and JavaScript execution out of the box, making it suitable for modern SaaS reporting, invoice systems, and document automation.

Where TuesPechkin Fits

Product Status

TuesPechkin is a .NET wrapper around the wkhtmltopdf native binary, distributed via the TuesPechkin NuGet package paired with TuesPechkin.Wkhtmltox.Win64 or TuesPechkin.Wkhtmltox.Win32 for the platform-specific binary. The underlying wkhtmltopdf project — built on a WebKit fork from roughly 2015 — has been archived upstream and is no longer receiving active development. Teams adopting it today inherit a dependency chain that predates modern .NET and modern web standards.

Capability Gaps

  • Limited modern CSS: CSS Grid and newer Flexbox features can render incorrectly — verify against your version
  • Constrained JavaScript execution: Complex SPAs or dynamic content may not render as expected
  • Pre-async API surface: Originally targeted .NET Framework, lacks async/await patterns
  • Manual container setup: Native library management is typically required in Docker images

Operational Constraints

  • Resident native binary: The wkhtmltox native library stays resident in the host process after conversions, which can matter for long-running web workers
  • Thread safety pattern: Typically requires a singleton/ThreadSafeConverter pattern with RemotingToolset for IIS scenarios
  • Architecture-specific deployment: Separate Win32EmbeddedDeployment vs Win64EmbeddedDeployment packages depending on target bitness
  • Azure App Service / serverless: Native-binary dependency commonly fails on locked-down PaaS hosts

Support Model

Community-maintained. There is no commercial backing, SLA, or hotfix pipeline; rendering-engine issues typically route to the upstream wkhtmltopdf tracker, which is itself archived.

Architecture Notes

The StaticDeployment pattern requires pre-extracting native DLLs to a specific folder structure before first use. This adds steps to CI/CD pipelines and can introduce race conditions in horizontally scaled environments. The RemotingToolset abstraction, while solving IIS hosting issues, adds an AppDomain boundary and serialization overhead.

Feature Comparison Overview

Aspect TuesPechkin IronPDF
Current Status Wrapper around archived wkhtmltopdf upstream Active development, regular updates
HTML Support HTML 4/5 partial, circa-2015 CSS Full HTML5, CSS3, CSS Grid, Flexbox
Rendering Engine WebKit fork (circa 2015) Chromium
Installation NuGet + native binary package + runtime deps Single NuGet package
Support Community forums Commercial support, engineering team
Future Trajectory Upstream archived Chromium-aligned roadmap

Code Comparison: HTML String Conversion

TuesPechkin — HTML String to PDF 

// NuGet: Install-Package TuesPechkin
// NuGet: Install-Package TuesPechkin.Wkhtmltox.Win64
using TuesPechkin;
using System;
using System.IO;

public class TuesPechkinExample
{
    private static IConverter _converter;

    static TuesPechkinExample()
    {
        // Pre-create deployment path for the native binary
        string deploymentPath = Path.Combine(
            AppDomain.CurrentDomain.BaseDirectory,
            "wkhtmltopdf"
        );

        Directory.CreateDirectory(deploymentPath);

        // Singleton thread-safe converter pattern (common for web apps)
        _converter = new ThreadSafeConverter(
            new RemotingToolset<PdfToolset>(
                new Win64EmbeddedDeployment(
                    new StaticDeployment(deploymentPath)
                )
            )
        );
    }

    public byte[] GenerateInvoice(string htmlContent)
    {
        var document = new HtmlToPdfDocument
        {
            GlobalSettings =
            {
                PaperSize = PaperKind.A4,
                Orientation = GlobalSettings.PaperOrientation.Portrait,
                Margins = new MarginSettings { Unit = Unit.Millimeters, Top = 10 }
            },
            Objects =
            {
                new ObjectSettings
                {
                    HtmlText = htmlContent,
                    WebSettings = { LoadImages = true }
                }
            }
        };

        return _converter.Convert(document);
    }
}
Enter fullscreen mode Exit fullscreen mode

Things to note in this pattern:

  1. The converter is typically a static singleton — it is not designed for per-request creation and disposal
  2. Win64EmbeddedDeployment is bitness-specific; 32-bit apps need the Win32 equivalent
  3. StaticDeployment requires the folder to exist before first use (worth scripting in CI rather than relying on first-call creation)
  4. The API is synchronous — there is no async overload, so the call blocks the calling thread
  5. CSS support reflects the underlying WebKit fork; modern Grid and newer Flexbox features may not render as expected
  6. The native binary is loaded into the host process and remains resident across calls

IronPDF — HTML String to PDF 

// NuGet: Install-Package IronPdf
using IronPdf;
using System.Threading.Tasks;

public class IronPdfExample
{
    public async Task<byte[]> GenerateInvoiceAsync(string htmlContent)
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

        var renderer = new ChromePdfRenderer();

        // Modern CSS rendering settings
        renderer.RenderingOptions.CssMediaType =
            IronPdf.Rendering.PdfCssMediaType.Screen;
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;

        using var pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent);
        return pdf.BinaryData;
    }
}
Enter fullscreen mode Exit fullscreen mode

IronPDF's approach eliminates the static deployment ceremony. The renderer handles native dependencies automatically, works on any CPU architecture, and disposes cleanly. The async pattern prevents thread blocking, making it suitable for high-traffic ASP.NET Core applications. Learn more about HTML string conversion and the ChromePdfRenderer API.

Code Comparison: URL to PDF with Authentication

TuesPechkin — URL Conversion 

// NuGet: Install-Package TuesPechkin
// NuGet: Install-Package TuesPechkin.Wkhtmltox.Win64
using TuesPechkin;
using System;
using System.IO;

public class TuesPechkinUrlConverter
{
    private readonly IConverter _converter;

    public TuesPechkinUrlConverter()
    {
        string deploymentPath = Path.Combine(
            AppDomain.CurrentDomain.BaseDirectory,
            "wkhtmltopdf"
        );
        Directory.CreateDirectory(deploymentPath);

        _converter = new ThreadSafeConverter(
            new RemotingToolset<PdfToolset>(
                new Win64EmbeddedDeployment(
                    new StaticDeployment(deploymentPath)
                )
            )
        );
    }

    public void ConvertUrlToPdf(string url, string outputPath)
    {
        var document = new HtmlToPdfDocument
        {
            GlobalSettings =
            {
                PaperSize = PaperKind.A4,
                Orientation = GlobalSettings.PaperOrientation.Portrait
            },
            Objects =
            {
                new ObjectSettings
                {
                    PageUrl = url,
                    WebSettings =
                    {
                        LoadImages = true,
                        // Basic HTTP auth surface only
                        UserStyleSheet = "print.css"
                    }
                }
            }
        };

        byte[] pdfBytes = _converter.Convert(document);
        File.WriteAllBytes(outputPath, pdfBytes);
    }
}
Enter fullscreen mode Exit fullscreen mode

Things to note in this pattern:

  1. Authentication surface is limited to basic HTTP auth — there is no first-class bearer token or OAuth flow
  2. UserStyleSheet paths are resolved against the deployment, which can be fragile in container environments — verify paths against your runtime layout
  3. JavaScript-heavy pages (SPAs) may not render fully under the WebKit fork
  4. Custom request headers and programmatic cookies are not part of the URL-loading API
  5. Modern TLS handshakes can fail with HTTPS hosts depending on the bundled binary version
  6. There is no first-class timeout knob on the URL fetch path

IronPDF — URL to PDF with Modern Auth 

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Threading.Tasks;

public class IronPdfUrlConverter
{
    public async Task<byte[]> ConvertAuthenticatedUrlAsync(
        string url,
        string bearerToken)
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

        var renderer = new ChromePdfRenderer();

        // Cookie-based credential passthrough
        renderer.LoginCredentials.CustomCookies.Add(
            new System.Net.Cookie("AuthToken", bearerToken, "/", new Uri(url).Host)
        );

        renderer.RenderingOptions.Timeout = 60; // seconds
        renderer.RenderingOptions.WaitFor.RenderDelay(500); // Wait for JS

        using var pdf = await renderer.RenderUrlAsPdfAsync(url);
        return pdf.BinaryData;
    }
}
Enter fullscreen mode Exit fullscreen mode

IronPDF handles modern authentication patterns, sets explicit timeouts, and waits for JavaScript execution. The async API prevents blocking in web contexts, and resource disposal is automatic. See the Chrome rendering engine guide for advanced scenarios.

Code Comparison: Complex Layout with Images

TuesPechkin — Layout Rendering 

// NuGet: Install-Package TuesPechkin
// NuGet: Install-Package TuesPechkin.Wkhtmltox.Win64
using TuesPechkin;
using System;
using System.IO;

public class TuesPechkinLayoutRenderer
{
    private readonly IConverter _converter;

    public TuesPechkinLayoutRenderer()
    {
        string path = Path.Combine(
            AppDomain.CurrentDomain.BaseDirectory,
            "wkhtmltopdf"
        );
        Directory.CreateDirectory(path);

        _converter = new ThreadSafeConverter(
            new RemotingToolset<PdfToolset>(
                new Win64EmbeddedDeployment(new StaticDeployment(path))
            )
        );
    }

    public byte[] RenderDashboard(string htmlWithGrid)
    {
        var document = new HtmlToPdfDocument
        {
            GlobalSettings =
            {
                PaperSize = PaperKind.A4,
                Orientation = GlobalSettings.PaperOrientation.Landscape,
                Margins = new MarginSettings
                {
                    Unit = Unit.Millimeters,
                    Top = 10,
                    Bottom = 10,
                    Left = 10,
                    Right = 10
                }
            },
            Objects =
            {
                new ObjectSettings
                {
                    HtmlText = htmlWithGrid,
                    WebSettings =
                    {
                        LoadImages = true,
                        PrintMediaType = true // Use print CSS
                    }
                    // No first-class viewport setting on this API
                }
            }
        };

        return _converter.Convert(document);
    }
}
Enter fullscreen mode Exit fullscreen mode

Things to note in this pattern:

  1. CSS Grid is not part of the underlying engine's spec coverage — Grid layouts typically need fallback markup
  2. Flexbox is partially supported; flex-wrap and newer features may not match modern browsers — verify against your version
  3. Web Fonts loaded from external CDNs can fail depending on the binary's TLS support
  4. SVG support is limited compared to a current Chromium engine
  5. Base64-encoded images may render inconsistently depending on the binary version
  6. There is no built-in viewport-width knob for responsive layouts

IronPDF — Modern Layout Rendering 

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System.Threading.Tasks;

public class IronPdfLayoutRenderer
{
    public async Task<byte[]> RenderDashboardAsync(string htmlWithGrid)
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

        var renderer = new ChromePdfRenderer();

        // Modern layout support
        renderer.RenderingOptions.PaperOrientation = 
            PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen;
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;

        // Responsive viewport for mobile-first designs
        renderer.RenderingOptions.PaperFit.UseResponsiveCssRendering(1280);

        using var pdf = await renderer.RenderHtmlAsPdfAsync(htmlWithGrid);
        return pdf.BinaryData;
    }
}
Enter fullscreen mode Exit fullscreen mode

IronPDF's Chromium engine natively supports CSS Grid, Flexbox, Web Fonts, SVG, and Canvas elements. The UseResponsiveCssRendering method allows viewport control for mobile-first layouts. Pixel-perfect rendering documentation explains advanced customization.

API Mapping Reference

TuesPechkin Concept IronPDF Equivalent
HtmlToPdfDocument ChromePdfRenderer.RenderHtmlAsPdf()
ObjectSettings.PageUrl ChromePdfRenderer.RenderUrlAsPdf()
ObjectSettings.HtmlText Pass string to RenderHtmlAsPdf()
GlobalSettings.PaperSize RenderingOptions.PaperSize
GlobalSettings.Orientation RenderingOptions.PaperOrientation
MarginSettings RenderingOptions.MarginTop/Bottom/Left/Right
WebSettings.LoadImages Enabled by default, no explicit flag
ThreadSafeConverter Renderer is thread-safe by design
StaticDeployment Automatic native dependency management
RemotingToolset Not required—no IIS special handling
Convert() method RenderHtmlAsPdf() / RenderUrlAsPdf()
PdfToolset Abstracted—no manual toolset selection
Header/Footer APIs RenderingOptions.TextHeader / TextFooter

Comprehensive Feature Comparison

Feature Category TuesPechkin IronPDF
Status & Support
Active Development Wrapper around archived wkhtmltopdf Yes (regular releases)
Commercial Support No Yes — engineering team + SLA
Security Patches Depends on upstream Regular product updates
.NET 9 Support Not first-class Yes
LTS Commitment No Multi-year roadmap
Content Creation
HTML5 Support Partial (circa-2015 WebKit fork) Full (Chromium)
CSS3 Features Limited spec coverage Grid, Flexbox, Variables
JavaScript Execution Limited Chrome V8 engine
Web Fonts Partial Full support (Google Fonts, custom)
SVG Rendering Basic Chromium-grade SVG
Responsive Layouts No viewport API UseResponsiveCssRendering()
PDF Operations
HTML to PDF Yes Yes
URL to PDF Yes Yes
Async API No Yes
Merge PDFs Out of scope Built-in PdfDocument.Merge()
Split PDFs Out of scope Yes — PdfDocument operations
Add Watermarks Out of scope Yes — text and image
Digital Signatures Out of scope Yes — X.509 certificates
Form Creation Out of scope CreatePdfFormsFromHtml = true
Extract Text Out of scope Yes — PdfDocument.ExtractAllText()
Security
Password Protection Out of scope Yes — AES
Certificate Encryption Out of scope Yes
Permissions (Print/Copy) Out of scope Yes — granular control
Redaction Out of scope Yes
Deployment
Native Binary Residency Loaded into host process Managed internally
Thread Safety Singleton + ThreadSafeConverter pattern Thread-safe
Container Deployment Manual native-binary extraction Works out of the box
Azure App Service Typically not supported Supported
Linux Compatibility Native binary only Yes (.NET Core / 5+)
macOS Support Native binary only Yes
Development
NuGet Install 2 packages + native runtime deps Single package
Code Surface Deployment ceremony required Typically 3–5 lines
Debugging Limited error messages Detailed exceptions
Samples Community-curated Extensive docs + examples

Patterns Teams Hit When Migrating

When teams move off TuesPechkin, these patterns commonly come up — verify each against your version and target environment:

  1. CSS Grid layouts: The underlying engine predates the Grid spec; layouts using Grid typically need fallback markup
  2. Native binary stays resident: The wkhtmltox library is loaded into the host process and stays loaded across calls
  3. Modern TLS/HTTPS: Older bundled binaries can struggle with current TLS handshakes
  4. JavaScript-heavy pages: SPAs and dynamic dashboards may not render fully
  5. Docker images: Containers typically need explicit native-binary extraction and runtime deps
  6. Azure App Service / locked-down PaaS: Native-binary dependencies commonly fail in these environments
  7. Bitness selection: 32-bit vs 64-bit requires the matching TuesPechkin.Wkhtmltox.Win32 / Win64 package
  8. Web Fonts from CDNs: Loading from external CDNs can fail depending on the binary's TLS support
  9. SVG rendering: SVG coverage is narrower than current browsers
  10. Synchronous API: There is no async overload; calls block the calling thread

Installation Comparison

TuesPechkin:

Install-Package TuesPechkin
Install-Package TuesPechkin.Wkhtmltox.Win64  # or .Win32 for 32-bit
# Plus the matching Visual C++ runtime on the host
Enter fullscreen mode Exit fullscreen mode 
using TuesPechkin;

// Static initialization before first use
string deployPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "wkhtmltopdf");
Directory.CreateDirectory(deployPath);
var converter = new ThreadSafeConverter(
    new RemotingToolset<PdfToolset>(
        new Win64EmbeddedDeployment(new StaticDeployment(deployPath))
    )
);
Enter fullscreen mode Exit fullscreen mode

IronPDF:

Install-Package IronPdf
Enter fullscreen mode Exit fullscreen mode 
using IronPdf;

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
pdf.SaveAs("output.pdf");
Enter fullscreen mode Exit fullscreen mode

Conclusion

TuesPechkin solved a real problem in the .NET Framework era — it gave .NET teams a clean managed surface over wkhtmltopdf. For teams maintaining legacy applications with simple layout needs and no budget for commercial tools, it can still do the job, with the caveat that the underlying wkhtmltopdf project is archived upstream and not receiving further development.

Migration tends to come up when:

  • Your CSS uses Grid, newer Flexbox, or CSS Variables
  • You deploy to Docker, Azure App Service, or Linux containers
  • Long-running web workers care about native-binary residency
  • You need async patterns for scalable web apps
  • JavaScript-heavy content (SPAs, charts) needs to render the way browsers render it today
  • You want ongoing patch management from a vendor

IronPDF approaches the problem differently: a current Chromium engine, native dependencies handled internally, and a .NET-idiomatic API. The trade-off is a commercial license in exchange for less deployment ceremony and rendering that tracks current browsers. For teams where rendering fidelity and maintenance burden are real concerns, that trade-off often pays back inside the first sprint.

What is your experience with wkhtmltopdf-based tools in modern .NET projects? Any gotchas or workarounds worth sharing?

Related Resources:

Top comments (0)