Because that's the point where a perfectly clean C# codebase acquires a headless Chromium. Or a native rendering dependency that works on the dev laptop and mysteriously doesn't in the Alpine container. Or a third-party licence with a seat count attached.

TerraFluent.Chart.Reporting 2.0 is my answer to that moment. It's a fluent, MIT-licensed .NET library that renders 26 chart types as self-contained SVG, entirely in managed C#. No JavaScript runtime. No native binaries. No browser. It's the fourth package in the TerraFluent suite, and it's out now.

dotnet add package TerraFluent.Chart.Reporting

Sixty seconds to a chart

using TerraFluent.Chart.Reporting.Builder;

string svg = ChartBuilder.Create()
    .Title("Monthly Website Visitors")
    .Subtitle("Jan – Jun 2026")
    .Size(700, 400)
    .XAxis("Month", "Jan", "Feb", "Mar", "Apr", "May", "Jun")
    .YAxis("Visitors", min: 0)
    .Series(s => s
        .AddLine("Visitors", new double[] { 12400, 14800, 16200, 18500, 21000, 19800 }))
    .RenderToSvg();

That svg is a complete, standalone <svg> document. Write it to a file, inline it in a Razor page, embed it in a PDF, drop it in an email. It renders the same on every machine because nothing outside your process participated in drawing it.

That last point is the whole design. A chart that is text rather than pixels is a chart you can diff, cache, inline, and reason about — and one that stays sharp at any zoom or print resolution.

The 26 types

The catalogue is deliberately weighted toward reporting rather than scientific plotting:

Each has a matching builder method, so the API surface is predictable:

.Series(s => s.AddColumn("Units Sold", new double[] { 8400, 5200, 3100 }))
.Series(s => s.AddWaterfall(name: "P&L", data: values, totals: totalFlags))
.Series(s => s.Add("Market Share", new double[] { 38, 27, 21, 14 }).AsPie())

There are also computed overlays that derive a series from data you already handed over — AddLinearRegression, AddMovingAverage, AddExponentialSmoothing — which saves the usual detour through a stats helper before you can draw a trend line.

Sankey, Gantt, Treemap, Stream and Parliament are worth calling out: those are the ones that normally push teams toward a JavaScript library, because most server-side .NET plotting libraries simply don't have them.

Three render modes, one API

This is the feature I'd point at first, because it solves a problem most charting libraries don't acknowledge: the same chart has to survive very different destinations.

ChartBuilder.Create().AsStatic()       // pure SVG — no JS, no CSS hover, no SMIL
ChartBuilder.Create().AsAnimated()     // SVG + CSS hover + SMIL, still zero JavaScript
ChartBuilder.Create().AsInteractive()  // adds embedded JS: tooltips, legend toggling, export

• Static is what goes in a PDF or an email client. Outlook will not run your JavaScript, and a PDF rasteriser will not honour your hover rules.
• Animated uses SMIL and CSS only, which means a chart that moves in a Blazor app or an embedded HTML report without shipping a script bundle.
• Interactive is the browser-only mode, for when the chart lives on a real page.

Duration is a separate knob — .Animate(800) in milliseconds, with easing options .EaseOut(), .EaseInOut(), .Bounce(), .Elastic() and .Linear(). Switching modes doesn't change the rest of the chart definition: you build it once and pick the output at the end.

The parts that matter in real reports

Announcement posts love to list chart types. Here's what actually saves you time on the third sprint:

Axes and formatting — label templates like .YAxisFormat("${value}k") or "{value}%", .LabelRotation = -45 for crowded category labels, explicit .Min/.Max/.TickInterval for numeric axes, and a secondary axis via .YAxis2() when a report genuinely calls for one.

Annotations — plot bands to shade a target range, and reference lines with labels and dash styles for thresholds and SLAs. Most "why is this number bad?" questions get answered by a line at 95%, not by another series.

Stacking — .StackNormal() for cumulative totals, .StackPercent() for composition normalised to 100%.

Missing data is a first-class case. Series accept double?[], and null renders as a genuine gap rather than a zero or an interpolated lie. If you have ever shipped a dashboard where a failed ETL run showed up as a dramatic cliff to zero, you know why this matters.

Output where you need it — RenderToSvg(), RenderToFile(), RenderToBytes(), RenderToDataUri() (handy for inlining straight into an <img> or an email), and RenderToHtml()/RenderToHtmlFile(), which wrap the SVG in a <figure> with an optional caption and CSS class. RenderToStream() is there for the synchronous path, with async variants and CancellationToken support on .NET 6+.

Dependency injection and .Fork() — register IChartBuilder and call .Fork() to take an isolated deep copy of the builder state. That's how you keep a shared base configuration (corporate theme, fonts, size) without one request mutating another's chart. It also makes "render this same chart static for the PDF and interactive for the web" a two-line operation.

ISvgRenderer — the rendering engine is replaceable. Useful for snapshot-testing chart output, or bending the markup to an in-house design system.

It's part of a suite, and that's the point

A chart on its own is a picture. A chart inside a document is a deliverable. Because the output is a self-contained SVG string, it drops straight into the rest of the suite:

• TerraFluent.Pdf.Reporting — embed as vector graphics, so the chart stays sharp at print resolution instead of being a blurry PNG
• TerraFluent.Html.Reporting — inline it in a paginated, print-ready HTML report
• TerraFluent.Docx.Reporting — embed in a real Word document

The packages share no runtime dependency, so taking the chart library doesn't drag in the other three.

How it compares

Here's where I'll be straight with you, because a comparison table that says "everything else is bad" is worth nothing.

.NET already has genuinely excellent charting libraries. ScottPlot and LiveCharts2 in particular are superb at things this library deliberately doesn't attempt. The honest question isn't "which is best" — it's "which problem are you solving."

Facts below verified against NuGet in September 2026:

ScottPlot

ScottPlot is a fantastic library and the right answer for a large class of problems — interactive plotting, scientific work, and rendering datasets with millions of points, where its raster pipeline genuinely outperforms vector approaches at scale.

The trade-off is the dependency chain. ScottPlot 5 pulls SkiaSharp, SkiaSharp.HarfBuzz and HarfBuzzSharp, which means a native libSkiaSharp in your deployment. On Linux that historically means reaching for SkiaSharp.NativeAssets.Linux.NoDependencies, and installing libfreetype6, libfontconfig1 and fontconfig if you'd rather your text didn't render as tofu boxes. It does have SaveSvg() and GetSvgXml(), but SVG is an export path over a Skia canvas rather than the native output format, and the tracker carries the occasional rough edge there.

Pick ScottPlot when: you're building a desktop app, exploring data interactively, or plotting very large datasets.

OxyPlot

OxyPlot is the closest genuine alternative, and I want to be fair about that: OxyPlot.Core has no dependencies on netstandard2.0/net6/net8, and its SvgExporter produces SVG without any native code. If dependency-free server-side SVG is your only requirement, OxyPlot already does that and has done for years.

Two things to weigh. First, text measurement: without supplying an ITextMeasurer, SVG export falls back to the PDF render context's measurer, which handles simple Type-1 fonts (Helvetica/Arial, Roman, Courier) limited to WinAnsi encoding — a real constraint if your labels aren't Latin. Second, cadence: OxyPlot.Core 2.2.0 shipped in September 2024, and the chart catalogue is oriented toward classic plotting rather than the reporting forms (Sankey, Gantt, Treemap, Funnel, Parliament) that business documents keep asking for.

Pick OxyPlot when: you want a mature, dependency-free plotting library with a long track record and your chart needs are the classic set.

LiveCharts2

LiveCharts2 has the nicest data-binding story of the four. MVVM-friendly, observable collections that animate when the underlying data changes, full MAUI support. For a desktop or mobile app where charts are live UI, it's a joy.

It's also built on SkiaSharp, and it's optimised for a rendering loop attached to a view — not for a stateless request that has to emit a chart into a PDF and forget about it.

Pick LiveCharts2 when: your charts live in a WPF/Avalonia/MAUI app and need to react to changing data.

The commercial suites

Syncfusion, DevExpress and Telerik all ship comprehensive, mature charting with professional support behind it. If you're already paying for one of those suites, use it — you've bought it, and it's good.

The consideration is commercial rather than technical: per-developer licensing, renewal cycles, and redistribution terms that need reading before you ship a product that embeds them. TerraFluent.Chart is MIT, which means no seat count, no revenue threshold, and no "contact sales" step between you and production.

The headless browser approach

Chart.js or Highcharts driven through Puppeteer/Playwright gets you the enormous JavaScript charting ecosystem, which is a genuine advantage in breadth.

It also gets you a Chromium in your container image, a Node runtime, a process lifecycle to babysit, a memory profile that surprises people, cold starts that make serverless painful, and a browser to patch every time a CVE lands. For one chart in a monthly PDF, that is an enormous amount of operational surface. (Highcharts also carries commercial licensing for most business use.)

Where this library is the wrong choice

Worth saying plainly:

• Millions of data points. Vector SVG means one DOM node per mark. For dense scientific plotting, a raster pipeline like ScottPlot's is the correct architecture, not a compromise.
• Charts as live app UI. If the chart is bound to an observable collection and animates on change, LiveCharts2 is built for that and this isn't.
• 3D or GPU-accelerated visualisation. Not attempted.
• You already own a commercial suite. Use what you've paid for.

What's left — and it's a large, underserved slice — is server-side charts that end up inside documents: invoices, monthly statements, compliance reports, emailed dashboards, anything that has to render identically on a build server, in a container, and in a Lambda, with nothing installed.

That's the job this library is built for.

Getting started

dotnet add package TerraFluent.Chart.Reporting

It runs on netstandard2.0 and up, which means a .NET Framework 4.6.1 app that's been in production for a decade can use it just as happily as a brand-new .NET 10 minimal API.

• 📊 Docs: terrafluent.dev/chart
• 🖼️ Showcase: all 26 types, rendered
• 📦 NuGet: TerraFluent.Chart.Reporting
• 📜 Release notes: terrafluent.dev/releases

If you try it, I'd genuinely like to know where it falls short. The chart types in this release exist because people told me which ones they were being forced into JavaScript for — that feedback loop is the whole reason the flow and hierarchy family got built.

Happy charting. 📈

AI Coding Agents Are the Real Shift

Autocomplete-style AI (finish my line, suggest my function) is old news at this point. What's actually trending now is agentic coding — tools like Claude Code, Cursor, and Windsurf that don't just suggest a line, they take a task ("fix this failing test," "migrate this module to the new API," "review this PR") and go do it across the whole repo: reading files, running commands, iterating on failures.

This is the biggest workflow shift I've personally felt in years. The unit of delegation moved from "autocomplete a line" to "here's a task, go." That said — the honest caveat everyone glosses over — you still need to understand what shipped. Reviewing the diff is non-negotiable. The value isn't "I don't need to think anymore," it's "the mechanical parts stopped eating my afternoon."

Zed Is Quietly Pulling People Off VS Code

VS Code isn't going anywhere, but Zed has genuinely picked up momentum — built by some of the same people behind Atom, written in Rust, and it's fast in a way that's hard to appreciate until you've used it. Native AI integration, real-time collaboration built in, and a UI that doesn't need forty extensions to feel complete.

Is it a wholesale VS Code replacement yet? For a lot of people, no — the extension ecosystem still doesn't fully match up. But it's the one editor genuinely stealing mindshare instead of just existing.

Warp Is Rethinking the Terminal

Terminals didn't change much for a couple of decades — then Warp showed up with blocks-based output, AI command search ("how do I undo the last git commit" right in the terminal), and actual collaboration features. It won't replace your shell, it is a shell wrapper, but the workflow feels noticeably different once you're used to it.

Bun and uv: Runtimes and Package Managers Got Fast Again

On the JavaScript side, Bun keeps eating into Node's territory — a single binary that's runtime, bundler, test runner, and package manager, and it's fast enough that people notice immediately. On the Python side, uv did something similar to package management: pip installs that used to take minutes now take seconds. Both are examples of the same trend — tooling that got comfortable and slow finally getting rewritten from scratch for speed.

Bruno and Hoppscotch: API Testing Without the Cloud Tax

This trend isn't new but it's accelerating: developers moving off Postman as it leans harder into being a cloud platform with an account wall. Bruno stores your API collections as plain files you can commit and diff like actual code. Hoppscotch does similar as an open-source, browser-based alternative. If your team got annoyed the last time Postman asked you to sign in to save a local request, this is where people are going instead.

Local LLMs Are Becoming a Real Option, Not a Novelty

Tools like Ollama and LM Studio made running models locally (Llama, Mistral, and friends) trivially easy — no cloud account, no per-token bill, your code and prompts never leave your machine. It's not replacing hosted frontier models for serious agentic work yet, but for quick, private, offline tasks it's gone from "cute experiment" to "actually part of people's workflow."

Edge-First Infra: Cloudflare Workers, Neon, Turso

The infra trend right now is compute and data getting closer to the user by default. Cloudflare Workers for edge compute, Neon for serverless Postgres that branches like git, Turso for edge SQLite — all built around the same idea: don't make every request round-trip to one data center on the other side of the planet. Worth a look even for a side project, since the free tiers make experimenting nearly free.

shadcn/ui Changed How People Think About Component Libraries

Instead of installing a component library as a dependency, shadcn/ui gives you the actual component code, dropped straight into your project, that you then own and modify. It flipped the usual "black box npm package" model on its head, and enough people liked owning their components that the approach is showing up in copies and forks across the ecosystem now.

What I'd Actually Skip For Now

Not everything trending is worth chasing immediately:

• Fully autonomous "build my whole app" AI tools — impressive demos, but production code still needs a human steering it. Great for scaffolding, not for unsupervised feature work.
• Yet another JavaScript framework — there's always a new one. Wait for it to survive a year before betting a real project on it.
• Chasing every AI IDE fork — Cursor, Windsurf, and half a dozen others are all racing each other on the same core idea. Pick one, don't subscribe to all of them out of FOMO.

The Actual Takeaway

The common thread across everything actually worth adopting here: it removes real friction, not imagined friction. Agentic AI removes the friction of mechanical busywork. Bun and uv remove the friction of slow tooling. Bruno removes the friction of an account wall. That's the filter I'd apply to any "trending" tool before installing it — does it solve something that's actually been annoying you, or does it just look good in a demo video?

What's on your radar that I didn't mention? Genuinely curious what's caught your attention lately.

I got tired of that wall. So I built TerraFluent: a small family of .NET reporting libraries that produce PDF, HTML, DOCX, and SVG charts from one consistent, fluent, code-first API. It's pure managed C#, MIT licensed, and there are no watermarks, no page limits, and no paid tiers hiding behind a "contact sales" button.

Updated September 2026. TerraFluent has grown a fourth package since this post first went up: TerraFluent.Chart.Reporting, which renders 26 chart types as self-contained SVG with no JavaScript and no browser. Current versions: Pdf 2.2.1, Html 1.2.0, Docx 1.4.0, Chart 2.0.0.

This is the sibling project to TerraPDF, and everything I learned building that went straight into TerraFluent. Let me show you around.

The idea: describe the document, not the plumbing

TerraFluent ships as four focused NuGet packages, each tuned to its output but sharing the same design philosophy:

• TerraFluent.Pdf.Reporting — a pure managed C# PDF engine (PDF 1.7)
• TerraFluent.Html.Reporting — paginated, print-ready, self-contained HTML
• TerraFluent.Docx.Reporting — native Open XML Word documents
• TerraFluent.Chart.Reporting — 26 chart types rendered as self-contained SVG

You install only what you need:

dotnet add package TerraFluent.Pdf.Reporting
dotnet add package TerraFluent.Html.Reporting
dotnet add package TerraFluent.Docx.Reporting
dotnet add package TerraFluent.Chart.Reporting

The packages are genuinely independent — they share no common runtime dependency, so taking one does not drag in the others.

The core idea across all four is the same: you declare what the document should contain — pages, headers, columns, tables, charts — and TerraFluent handles measurement, layout, and pagination for you. No manual cursor tracking. No y += 20. No guessing where the page break lands.

Your first PDF

Here's a complete, runnable PDF report. Notice how it reads top-to-bottom like the document it produces:

using TerraFluent.Pdf.Reporting.Core;
using TerraFluent.Pdf.Reporting.Helpers;

PdfDocument.Create(container =>
{
    container.Page(page =>
    {
        page.Size(PageSize.A4);
        page.Margin(2, Unit.Centimetre);
        page.DefaultTextStyle(s => s.FontSize(11));

        page.Header()
            .Text("My Report").Bold().FontSize(24)
            .FontColor(Color.Blue.Darken2);

        page.Content().Column(col =>
        {
            col.Spacing(8);
            col.Item().Text("Hello, TerraFluent.Pdf.Reporting!");
            col.Item()
               .Margin(6).Background(Color.Grey.Lighten4).Padding(10)
               .Text("Indented callout box").Bold();
        });

        page.Footer().AlignCenter().Text(t =>
        {
            t.Span("Page ");
            t.CurrentPageNumber().FontSize(9);
            t.Span(" / ");
            t.TotalPages().FontSize(9);
        });
    });
})
.PublishPdf("output.pdf");

That's the whole program. PublishPdf writes the file; the header, footer, page numbering, and spacing are all declarative. If the content grows past one page, TerraFluent paginates it and repeats the header and footer automatically.

Tables that know how to break

Real reports are mostly tables, and real tables overflow pages. TerraFluent tables use a column definition and flow their rows across pages, repeating header rows as they go:

container.Table(table =>
{
    table.ColumnsDefinition(cols =>
    {
        cols.RelativeColumn(4);
        cols.RelativeColumn(1);
        cols.ConstantColumn(70);
    });

    table.HeaderRow(row =>
    {
        row.Cell().Background("#1a4a8a").Padding(6)
           .Text("Description").Bold().FontColor(Color.White);
        row.Cell().Background("#1a4a8a").Padding(6).AlignCenter()
           .Text("Qty").Bold().FontColor(Color.White);
        row.Cell().Background("#1a4a8a").Padding(6).AlignRight()
           .Text("Price").Bold().FontColor(Color.White);
    });

    foreach (var item in lineItems)
    {
        table.Row(row =>
        {
            row.Cell().Padding(6).Text(item.Name);
            row.Cell().Padding(6).AlignCenter().Text(item.Qty.ToString());
            row.Cell().Padding(6).AlignRight().Text($"${item.Price:N2}");
        });
    }
});

Mix RelativeColumn and ConstantColumn to get fluid layouts with fixed columns where you need them — exactly the kind of thing you'd otherwise fight a low-level PDF API over.

Barcodes and QR codes, natively

No plugins, no image pre-rendering, no third-party barcode library. Barcodes and QR codes are drawn as crisp vectors:

container.Barcode("SKU-00042-A", width: 260, height: 50,
    hexColor: "#1A3C5E", showCaption: true);

container.QrCode("https://terrafluent.dev/", size: 90,
    level: QrErrorCorrectionLevel.Q);

Because they're vector-rendered, they stay razor-sharp at any zoom or print resolution.

AES-256 encryption in a few lines

Sensitive documents shouldn't require a separate tool to lock down. Encryption is first-class, with separate user/owner passwords and granular permissions:

PdfDocument.Create(container =>
{
    container.Encrypt(new EncryptionOptions
    {
        UserPassword  = "open123",
        OwnerPassword = "admin456",
        Permissions   = PdfPermissions.Print | PdfPermissions.CopyText,
    });

    container.Page(page =>
    {
        page.Size(PageSize.A4);
        page.Content().Text("This PDF is password-protected.").Bold();
    });
})
.PublishPdf("protected.pdf");

When you need to draw

Sometimes a report needs a custom diagram, a signature line, or a bit of branded chrome. There's a vector canvas for that:

container.Canvas(120, c =>
{
    c.FillRect(0, 0, 200, 80, Color.Blue.Lighten4);
    c.StrokeRect(0, 0, 200, 80, Color.Blue.Darken2, 1.5);
    c.Line(0, 40, 200, 40, Color.Blue.Medium, 0.5);
});

The same report, as HTML

Here's where the "family" idea pays off. The HTML package shares the same declarative spirit, with an entry point tuned for the web:

using TerraFluent.Html.Reporting.Model;

var report = ReportDocument.Create(PageSize.A4, PageOrientation.Portrait)
    .SetMargins(40, 40, 60, 60)
    .Header(h => h.AddText("Monthly Sales Report").AlignCenter().Bold())
    .Footer(f => f.AddPageNumber("Page {page} of {totalPages}"))
    .Content(c =>
    {
        c.AddHeading("Sales Summary", HeadingLevel.H1);
        c.AddParagraph("This report summarizes sales activity for the period.");
        c.AddTable(t =>
        {
            t.AddColumns("Product", "Qty", "Revenue");
            t.AddRow("Widget A", "120", "$2,400");
            t.AddRow("Widget B", "85", "$1,700");
        });
    })
    .Build();

report.RenderHtmlDocument("monthly-sales.html");

The output is self-contained HTML and CSS — nothing else to deploy. It opens in any browser and prints straight to PDF, so it's perfect for emailed reports, in-app previews, or an "Export" button that just works.

A few HTML niceties worth calling out:

Merged cells with ColSpan / RowSpan:

table.AddColumns("Category", "Item", "Qty", "Total");

table.AddRow(new TableCell[]
{
    new TableCell("Electronics") { RowSpan = 3 },
    "Wireless Mouse", "2", "$39.98",
});
table.AddRow(new TableCell[] { "Mechanical Keyboard", "1", "$89.00" });
table.AddRow(new TableCell[] { "USB-C Dock", "1", "$64.50" });

Multiple render targets — a string when you want to inline it, a file when you want to save it, and an async variant for large reports:

string html = report.RenderHtml();                 // in-memory string
report.RenderHtmlDocument("report.html");           // save to file

await report.RenderHtmlDocumentAsync(
    Path.Combine(outputDir, "report.html"),
    cancellationToken: cancellationToken);           // async + cancellation

Layout warnings — if content can't fit cleanly, you get structured warnings instead of a silently broken page:

using TerraFluent.Html.Reporting.Layout;

var layout = LayoutEngine.Paginate(report);

foreach (var warning in layout.Warnings)
{
    logger.LogWarning("{ReportWarning}", warning);
}

The same report, as a real Word document

The DOCX package generates native Open XML — no Office install, no COM interop, no Microsoft.Office.Interop nightmares on a server. And crucially, the output is genuinely editable: real Word tables, real styles, and real, editable Word charts.

Document.Create(doc =>
{
    doc.MetadataTitle("Quarterly Report")
       .MetadataAuthor("Northwind Consulting");

    doc.Page(page =>
    {
        page.Size(PageSize.A4);
        page.Margin(Unit.Centimetre(2));
        page.Header().Text("Quarterly Report", t => t.Bold().AlignCenter());
        page.Footer().Text(t =>
        {
            t.Span("Page ");
            t.CurrentPageNumber();
            t.Span(" of ");
            t.TotalPages();
            t.AlignCenter();
        });

        page.Content().H1("Executive Summary");
        page.Content().Text("Revenue improved across every practice.");
    });
}).PublishDocx("quarterly-report.docx");

Want a chart your users can actually double-click and edit in Word? That's a first-class element:

page.Content().Chart(chart => chart
    .Title("Stacked Revenue by Quarter")
    .Width(430).Height(250)
    .AlignCenter()
    .Legend(ChartLegendPosition.Bottom)
    .CategoryAxisTitle("Quarter")
    .ValueAxisTitle("Revenue ($M)")
    .DataLabels()
    .Stacked()
    .Series("Product",  s => s.Bar("Q1", 4.1).Bar("Q2", 4.3).Color(Colors.Blue.L700))
    .Series("Services", s => s.Bar("Q1", 2.2).Bar("Q2", 2.6).Color(Colors.Orange.L700)));

And because so many Word workflows are really "fill in the blanks," there's template filling via placeholders and content controls:

DocxTemplate.Open("template.docx")
    .Replace("CustomerName", "Ada Lovelace")
    .ReplaceContentControl("InvoiceTotal", "$1,250.00")
    .SaveAs("output.docx");

You even get document protection ("Restrict Editing"), auto-numbered figure/table captions, floating images with text wrapping, and Code 128 barcodes rendered as vector shapes.

Charts, without a browser

Charts are where most .NET reporting stacks quietly give up and shell out to a headless Chromium. TerraFluent.Chart.Reporting renders them server-side as plain SVG instead — no JavaScript runtime, no native binary, nothing to install in the container:

using TerraFluent.Chart.Reporting.Builder;

string svg = ChartBuilder.Create()
    .Title("Monthly Website Visitors")
    .Subtitle("Jan – Jun 2026")
    .Size(700, 400)
    .XAxis("Month", "Jan", "Feb", "Mar", "Apr", "May", "Jun")
    .YAxis("Visitors", min: 0)
    .Series(s => s
        .AddLine("Visitors", new double[] { 12400, 14800, 16200, 18500, 21000, 19800 }))
    .RenderToSvg();

There are 26 chart types, grouped roughly as:

Three render modes cover the places a chart ends up:

• Static — pure SVG, no animation, no script. This is what you embed in a PDF or an email.
• Animated — SMIL animation and CSS hover effects, still with no JavaScript.
• Interactive — adds embedded JavaScript for tooltips, legend toggling, and an export menu. Browser only.

Besides RenderToSvg() there's RenderToFile() and RenderToHtmlFile(), which wraps the chart in a <figure> with an optional caption. Because the output is a self-contained SVG string, it drops into the other three packages: as vector graphics in a PDF, as an image in an HTML report, or embedded in a Word document.

One matrix, wide reach

TerraFluent runs where you run. Here's the framework support at a glance:

That netstandard2.0 target for HTML, DOCX, and Chart matters: it means these libraries drop into a legacy .NET Framework 4.6.1 app just as happily as a brand-new .NET 10 minimal API or an AWS Lambda.

Why "zero dependency" is the whole point

Every feature above — layout, tables, barcodes, QR codes, SVG charts, encryption, Open XML packaging — is pure managed code. No native binaries. No headless browser to install. No system libraries to apt-get into your container image. No P/Invoke that works on your laptop and mysteriously segfaults in production.

That has real consequences:

• Containers stay tiny and reproducible. Nothing to install beyond the NuGet package.
• Serverless just works. Cold starts don't have to warm up a native rendering engine.
• Security review is trivial. There's no third-party runtime surface to audit.
• Async and streaming are built in, so large reports don't pin a thread or blow up memory.

When you build a document library on top of a browser or a native toolkit, all of that becomes your operations team's problem. TerraFluent refuses to make it one.

From TerraPDF to TerraFluent

If you've used TerraPDF, TerraFluent will feel familiar — it's the same values (fluent, dependable, dependency-free) taken to their logical conclusion: one way of thinking about documents, four packages out the other end. TerraPDF remains a fantastic, focused choice when PDF is all you need — and it has kept growing in its own right, with a vector canvas and font subsetting landing in 2.1 and 2.2. TerraFluent is for when a single codebase has to speak PDF, HTML, and Word — and draw the charts — without four different libraries and four different headaches.

Try it

TerraFluent is MIT licensed and free for personal, commercial, and open-source use — no page limits, no watermarks, no tiers.

• 🌐 Website & docs: terrafluent.dev
• 📄 PDF reporting: terrafluent.dev/pdf · TerraFluent.Pdf.Reporting
• 🌍 HTML reporting: terrafluent.dev/html · TerraFluent.Html.Reporting
• 📝 DOCX reporting: terrafluent.dev/docx · TerraFluent.Docx.Reporting
• 📊 Charts: terrafluent.dev/chart · TerraFluent.Chart.Reporting
• 📜 Release notes: terrafluent.dev/releases

Install a package, generate your first report, and let me know what you build. If you hit a rough edge or have a feature in mind, I'd genuinely love to hear it — this project gets better with real-world reports throwing real-world edge cases at it.

Happy reporting. 🚀

Most developers reach for iText, PdfSharp, or QuestPDF. They work, but they're heavyweight, require external dependencies, or lack clean APIs for permission control.

TerraPDF changes this. With just 5 lines, you get enterprise-grade AES-256 encryption — on by default since v1.4 — plus user/owner passwords and granular permission flags. No external libraries. No licensing concerns. Zero boilerplate.

Updated for TerraPDF 2.2. AES-256 (Standard Security Handler Revision 6, SHA-2 key derivation, PDF 2.0 output) is now the default. AES-128 is still available as an opt-in legacy mode for very old readers — see Choosing the Algorithm below.

The Problem: PDF Encryption Is Messy

Standard PDF libraries make encryption tedious:

The TerraPDF Way: 5 Lines to Encryption

Document.Create(container =>
{
    container.Encrypt(new EncryptionOptions
    {
        UserPassword  = "confidential",    // Required to open
        OwnerPassword = "admin123",        // Bypass permissions
        Permissions   = PdfPermissions.Print | PdfPermissions.ExtractForAccessibility,
    });

    container.Page(page =>
    {
        page.Size(PageSize.A4);
        page.Margin(2, Unit.Centimetre);
        page.Content().Text("TOP SECRET FINANCIAL REPORT").Bold().FontSize(20);
        page.Content().Text("Encryption: AES-256 | User Password Protected");
    });
})
.PublishPdf("report.pdf");

That's it. The PDF opens in any viewer—Adobe Acrobat, Chrome, Edge, Firefox, Preview—with password protection enforced.

Choosing the Algorithm

You get AES-256 without asking for it. The only reason to change that is a reader old enough to predate Acrobat 9:

// Default — AES-256, Revision 6, SHA-2 key derivation, PDF 2.0 output.
container.Encrypt(new EncryptionOptions
{
    UserPassword = "open123",
    Permissions  = PdfPermissions.Print,
});

// Opt-in legacy — AES-128, Revision 4, MD5 key derivation, PDF 1.6 output.
container.Encrypt(new EncryptionOptions
{
    UserPassword = "open123",
    Permissions  = PdfPermissions.Print,
    Algorithm    = EncryptionAlgorithm.Aes128,
});

Unless you know you are shipping to a museum-piece reader, leave it alone.

Why This Matters: Permission Granularity

Traditional libraries offer generic "encrypt yes/no" options. TerraPDF gives you fine-grained control:

// View-only: No printing, no copying
container.Encrypt(new EncryptionOptions
{
    UserPassword = "readonly",
    Permissions = PdfPermissions.None,
});

// Allow printing, but not copying or modification
container.Encrypt(new EncryptionOptions
{
    UserPassword = "print_only",
    Permissions = PdfPermissions.Print,
});

// Restrict all except text extraction for accessibility
container.Encrypt(new EncryptionOptions
{
    UserPassword = "access_friendly",
    Permissions = PdfPermissions.ExtractForAccessibility,
});

// Full encryption, no user password, owner-only control
container.Encrypt(new EncryptionOptions
{
    OwnerPassword = "admin",
    Permissions = PdfPermissions.None,   // Viewer opens unlocked but can't print/copy
});

Permission flags available:

• Print — Allow high-quality printing
• PrintLowResolution — Degraded printing only
• CopyText — Allow copy/paste of text and graphics
• ModifyContents — Allow document editing
• ModifyAnnotations — Add/modify annotations
• FillForms — Fill form fields
• ExtractForAccessibility — Screen reader text extraction
• AssembleDocument — Insert/rotate/delete pages
• All — Unrestricted
• None — View-only

Real-World Use Cases

Scenario 1: Confidential Invoices

public byte[] GenerateConfidentialInvoice(Invoice inv)
{
    return Document.Create(container =>
    {
        // Restrict to view and print only—no copying invoice numbers
        container.Encrypt(new EncryptionOptions
        {
            UserPassword = $"inv_{inv.Number}",  // Generate per invoice
            Permissions = PdfPermissions.Print,
        });

        container.Page(page =>
        {
            page.Content().Text($"Invoice #{inv.Number}").Bold().FontSize(18);
            page.Content().Table(t => BuildInvoiceTable(t, inv));
        });
    })
    .PublishPdf();
}

Scenario 2: Internal Reports (Admin-Protected)

var reportPdf = Document.Create(container =>
{
    container.Encrypt(new EncryptionOptions
    {
        OwnerPassword = "C0rp_Admin!2025",   // Only admins can remove restrictions
        UserPassword = null,                  // Opens without password
        Permissions = PdfPermissions.Print,  // Users can only print
    });

    container.Page(page =>
    {
        page.Content().Text("Q1 2025 Financial Summary");
        page.Content().Text("⚠️ Confidential — Print-only, no copy/export allowed");
    });
})
.PublishPdf("q1-report.pdf");

Scenario 3: Public PDFs with Accessibility

container.Encrypt(new EncryptionOptions
{
    UserPassword = "open",
    Permissions = PdfPermissions.ExtractForAccessibility | PdfPermissions.Print,
});
// Users can print and screen readers can extract text,
// but copy-paste from the document is blocked

Under the Hood: Enterprise-Grade Encryption

TerraPDF doesn't cut corners on security:

Algorithm (default):

• Cipher: AES-256 CBC
• Key derivation: SHA-2, per Standard Security Handler Revision 6
• IV: 16-byte random per object
• Revision: 6 (PDF 2.0 output)

Algorithm (legacy opt-in):

• Cipher: AES-128 CBC
• Key derivation: MD5 (per PDF spec §7.6.3.3)
• Revision: 4 (PDF 1.6 output — the minimum version that permits AES)

What gets encrypted:

• ✅ Page content streams (drawing operators)
• ✅ Image XObjects (PNG/JPEG pixel data)
• ✅ Document metadata
• ✅ Bookmark titles and hyperlink URIs

What doesn't (per PDF spec):

• The encryption dictionary itself
• Cross-reference data and trailer
• Stream /Length values
• File header

Zero external dependencies — uses only System.Security.Cryptography:

• Aes for content encryption
• SHA256 (AES-256) / MD5 (legacy AES-128) for PDF-mandated key derivation
• RandomNumberGenerator for IV generation

Comparison: iText vs PdfSharp vs QuestPDF vs TerraPDF

iText Example (boilerplate-heavy)

using iText.Kernel.Pdf;

// Requires external license or AGPL compliance
PdfDocument pdfDocument = new PdfDocument(
    new PdfWriter("document.pdf", 
        new WriterProperties()
            .SetStandardEncryption(
                "userpass".GetBytes(Encoding.UTF8),
                "ownerpass".GetBytes(Encoding.UTF8),
                EncryptionConstants.ALLOW_PRINTING,
                EncryptionConstants.STANDARD_ENCRYPTION_128)));

Document doc = new Document(pdfDocument);
doc.Add(new Paragraph("Hello World"));
doc.Close();

Downsides:

• Complex license (AGPL for open source)
• External dependency (BouncyCastle)
• Verbose flag setup — note the encryption strength is spelled out per call (STANDARD_ENCRYPTION_128, or ENCRYPTION_AES_256 if you want the stronger cipher)
• 15+ lines for basic encryption

PdfSharp Example (clunky API)

using PdfSharp.Pdf;
using PdfSharp.Pdf.Security;

PdfDocument document = new PdfDocument();
document.SecuritySettings.UserPassword = "user";
document.SecuritySettings.OwnerPassword = "owner";
document.SecuritySettings.PermitAccessibilityExtractContent = true;
document.SecuritySettings.PermitAssembleDocument = false;
document.SecuritySettings.PermitChangeDocument = false;
document.SecuritySettings.PermitCopy = false;
document.SecuritySettings.PermitEditAnnotations = false;
document.SecuritySettings.PermitFillIn = false;
document.SecuritySettings.PermitModifyDocument = false;
document.SecuritySettings.PermitPrint = true;

PdfPage page = document.AddPage();
// ... drawing code
document.Save("document.pdf");

Downsides:

• Verbose property assignments
• No fluent API
• Unclear permission semantics
• 12+ lines of config

QuestPDF Example (close cousin)

Document.Create(container =>
{
    // QuestPDF gained native encryption in 2024.12:
    // 40-bit, 128-bit, or 256-bit AES with permission flags.

    container.Page(page =>
    {
        page.Size(PageSizes.A4);
        page.Content().Text("Encrypted Document");
    });
})
.GeneratePdf("document.pdf");

Trade-offs:

• Encryption strength is chosen per document rather than defaulting to AES-256
• Community MIT license only under a revenue threshold — commercial licensing applies above it
• Pulls in a native SkiaSharp rendering dependency, so it is not zero-dependency

TerraPDF (clean, fluent, zero-dependency)

Document.Create(container =>
{
    container.Encrypt(new EncryptionOptions
    {
        UserPassword = "open123",
        OwnerPassword = "admin456",
        Permissions = PdfPermissions.Print | PdfPermissions.CopyText,
    });

    container.Page(page =>
    {
        page.Content().Text("Secure Document");
    });
})
.PublishPdf("document.pdf");

Advantages:

• ✅ 5 lines of encryption config
• ✅ AES-256 by default — no flag to remember
• ✅ Fluent, readable API
• ✅ Fine-grained permission flags
• ✅ Zero external dependencies
• ✅ MIT license
• ✅ No vendor lock-in
• ✅ All major PDF viewers supported

Common Encryption Patterns

View-Only (No Printing or Copying)

container.Encrypt(new EncryptionOptions
{
    UserPassword = "readonly",
    Permissions = PdfPermissions.None,
});

Print-Only (No Copying or Editing)

container.Encrypt(new EncryptionOptions
{
    UserPassword = "print_only",
    Permissions = PdfPermissions.Print,
});

Owner Password Only (No User Password)

container.Encrypt(new EncryptionOptions
{
    OwnerPassword = "admin_only",
    Permissions = PdfPermissions.None,
});
// Document opens freely but can't be printed/copied without owner password

Full Encryption, All Permissions

container.Encrypt(new EncryptionOptions
{
    UserPassword = "secret",
    Permissions = PdfPermissions.All,
});
// Content encrypted but full interactivity allowed

Integration Pattern: Reusable Encryption Component

public class SecureDocument : IComponent
{
    private readonly PdfSecurityLevel _level;
    private readonly string _title;

    public SecureDocument(string title, PdfSecurityLevel level)
    {
        _title = title;
        _level = level;
    }

    public void Compose(IContainer container)
    {
        // Apply encryption based on security level
        container.Encrypt(GetEncryptionOptions(_level));

        container.Page(page =>
        {
            page.Content().Text(_title).Bold().FontSize(20);
            page.Content().Text($"Security Level: {_level}");
        });
    }

    private EncryptionOptions GetEncryptionOptions(PdfSecurityLevel level) => level switch
    {
        PdfSecurityLevel.Public => new() 
        { 
            Permissions = PdfPermissions.All 
        },
        PdfSecurityLevel.Internal => new() 
        { 
            UserPassword = "internal",
            Permissions = PdfPermissions.Print | PdfPermissions.ExtractForAccessibility
        },
        PdfSecurityLevel.Confidential => new() 
        { 
            UserPassword = "confidential",
            OwnerPassword = "admin_override",
            Permissions = PdfPermissions.Print
        },
        _ => throw new ArgumentException("Unknown security level"),
    };
}

public enum PdfSecurityLevel { Public, Internal, Confidential }

// Usage
Document.Create(new SecureDocument("Financial Report", PdfSecurityLevel.Confidential))
    .PublishPdf("report.pdf");

Technical FAQ

Q: Do I need to do anything to get AES-256? A: No. It is the default. container.Encrypt(new EncryptionOptions { ... }) writes a Revision 6, PDF 2.0 encrypted document with SHA-2 key derivation. AES-128 is now the thing you have to ask for, via Algorithm = EncryptionAlgorithm.Aes128.

Q: Is AES-128 still strong enough if I need the legacy mode? A: Yes. AES-128 is NIST-approved and fine for standard business documents. The reason to prefer AES-256 is not that AES-128 is broken — it is that Revision 6 replaces the PDF spec's MD5-based key derivation with SHA-2.

Q: Can users bypass the encryption? A: No. The user password is required to open. The owner password bypasses permission flags (printing, copying) but the document remains encrypted. There's no "password bypass" mode.

Q: Do all PDF viewers support TerraPDF encryption? A: In practice, yes. AES-256 (Revision 6) has been supported since Acrobat 9 in 2008, and works in Chrome, Edge, Firefox, Preview (Mac), Foxit, and Okular. If you are targeting something older than that, switch to EncryptionAlgorithm.Aes128 and you are back to Revision 4 / PDF 1.6 compatibility.

Q: Can I generate a per-user password? A: Yes. Generate passwords dynamically:

var userPassword = $"user_{invoice.CustomerId}_{DateTime.Now:yyyyMMdd}";
container.Encrypt(new EncryptionOptions { UserPassword = userPassword });

Q: What if I only want to encrypt but not require a password? A: Leave UserPassword null and set OwnerPassword. The document opens freely but permissions are enforced.

Why Choose TerraPDF for Encryption

1. 5-line setup — Clean, fluent API
2. Zero dependencies — No external packages or native binaries
3. Fine-grained permissions — 8 distinct permission flags
4. Production-ready — Enterprise AES-256 encryption by default, AES-128 on request
5. MIT licensed — No licensing restrictions
6. Universal compatibility — Works in every PDF viewer
7. Fast — Pure C# with no external calls
8. Maintainable — Easy to read, test, and update

Conclusion

If you're building .NET applications that generate confidential PDFs—financial reports, invoices, legal documents, medical records—you need encryption.

TerraPDF delivers it with less code, fewer dependencies, and more control than iText, PdfSharp, or QuestPDF.

5 lines. AES-256 by default. All major viewers. MIT license. Zero external packages.

That's the TerraPDF difference.

Get started:

dotnet add package TerraPDF

Documentation:

• TerraPDF Encryption Docs
• TerraPDF Changelog
• GitHub Repository
• Website: terrapdf.com

TerraPDF changes this. Its declarative, layout-first API lets you build professional invoices in 30 lines of actual generation code.

Setup

dotnet add package TerraPDF  # MIT-licensed, zero dependencies, .NET 8/9/10

Complete 30-Line Invoice Generator

using TerraPDF.Core;
using TerraPDF.Helpers;

public record Invoice(string Number, DateTime Date, string Customer, List<Item> Items)
{
    public decimal Subtotal => Items.Sum(i => i.LineTotal);
    public decimal Tax      => Math.Round(Subtotal * 0.10m, 2);
    public decimal Total    => Subtotal + Tax;
}
public record Item(string Description, int Quantity, decimal UnitPrice)
{
    public decimal LineTotal => Quantity * UnitPrice;
}

public static class InvoiceGenerator
{
    public static byte[] Generate(Invoice inv)
    {
        return Document.Create(doc =>
        {
            doc.Page(page =>
            {
                page.Size(PageSize.A4);
                page.Margin(2, Unit.Centimetre);
                page.DefaultTextStyle(s => s.FontSize(10));

                // ── Header ───────────────────────────────────────────────────
                page.Header().Column(h =>
                {
                    h.Item().Text("INVOICE").Bold().FontSize(22).FontColor("#1a4a8a");
                    h.Item().Row(r =>
                    {
                        r.RelativeItem().Text($"#: {inv.Number}  |  Date: {inv.Date:yyyy-MM-dd}");
                        r.AutoItem().AlignRight()
                           .Text($"Due: {inv.Date.AddDays(30):yyyy-MM-dd}")
                           .FontColor(Color.Red.Medium);
                    });
                    h.Item().LineHorizontal(1, "#1a4a8a");
                });

                // ── Content ──────────────────────────────────────────────────
                page.Content().Column(c =>
                {
                    c.Spacing(12);

                    // Bill-from / Bill-to
                    c.Item().Row(r =>
                    {
                        r.RelativeItem().Text("Your Company\n123 Main St\nCity, Country");
                        r.RelativeItem().AlignRight().Text($"BILL TO:\n{inv.Customer}");
                    });

                    // Line-items table
                    c.Item().Table(t =>
                    {
                        t.ColumnsDefinition(cols =>
                        {
                            cols.RelativeColumn(5);  // Description
                            cols.RelativeColumn(1);  // Qty
                            cols.RelativeColumn(2);  // Unit Price
                            cols.RelativeColumn(2);  // Total
                        });

                        t.HeaderRow(row =>
                        {
                            row.Cell().Background("#1a4a8a").Padding(5)
                               .Text("Description").Bold().FontColor(Color.White);
                            row.Cell().Background("#1a4a8a").Padding(5).AlignCenter()
                               .Text("Qty").Bold().FontColor(Color.White);
                            row.Cell().Background("#1a4a8a").Padding(5).AlignRight()
                               .Text("Price").Bold().FontColor(Color.White);
                            row.Cell().Background("#1a4a8a").Padding(5).AlignRight()
                               .Text("Total").Bold().FontColor(Color.White);
                        });

                        foreach (var item in inv.Items)
                        {
                            t.Row(row =>
                            {
                                row.Cell().Padding(5).Text(item.Description);
                                row.Cell().Padding(5).AlignCenter().Text(item.Quantity.ToString());
                                row.Cell().Padding(5).AlignRight().Text($"{item.UnitPrice:C}");
                                row.Cell().Padding(5).AlignRight().Text($"{item.LineTotal:C}");
                            });
                        }
                    });

                    // Totals block (right-aligned)
                    c.Item().Row(r =>
                    {
                        r.RelativeItem(7); // left spacer

                        r.RelativeItem(3).Column(tot =>
                        {
                            tot.Item().LineHorizontal(1, Color.Grey.Lighten2);
                            tot.Item().Row(tr =>
                            {
                                tr.RelativeItem().Text("Subtotal:");
                                tr.RelativeItem().AlignRight().Text($"{inv.Subtotal:C}");
                            });
                            tot.Item().Row(tr =>
                            {
                                tr.RelativeItem().Text("Tax (10%):");
                                tr.RelativeItem().AlignRight().Text($"{inv.Tax:C}");
                            });
                            tot.Item().LineHorizontal(1.5, "#1a4a8a");
                            tot.Item().Row(tr =>
                            {
                                tr.RelativeItem().Text("TOTAL DUE").Bold();
                                tr.RelativeItem().AlignRight().Text($"{inv.Total:C}").Bold()
                                   .FontColor("#1a4a8a");
                            });
                        });
                    });

                    // Payment terms
                    c.Item().MarginTop(8).Border(1, Color.Grey.Lighten2)
                      .Padding(8).Text(
                        "Payment due within 30 days. Late payments incur 1.5% monthly interest.")
                      .FontSize(9).FontColor(Color.Grey.Darken1).Justify();

                    // Thank you
                    c.Item().AlignCenter()
                      .Text("Thank you for your business!").FontSize(9).FontColor(Color.Grey.Medium);
                });

                // ── Footer ───────────────────────────────────────────────────
                page.Footer().AlignCenter().Text(t =>
                {
                    t.Span("Page "); t.CurrentPageNumber();
                    t.Span(" of "); t.TotalPages();
                });
            });
        }).PublishPdf();  // returns byte[]
    }
}

Usage:

var inv = new Invoice("INV-2025-001", DateTime.Today, "Acme Corp", new()
{
    new("Web Development", 40, 150m),
    new("Server Maintenance", 10, 100m),
});

File.WriteAllBytes("invoice.pdf", InvoiceGenerator.Generate(inv));

What you get: Header, bill-from/to, multi-line table with auto page breaks, totals, payment terms, footer with page numbers — all in 30 lines inside the Document.Create lambda.

Why This Works: Layout-First, Not Coordinate-First

Traditional PDF libraries force you to:

• ❌ Calculate Y positions manually (y -= 18)
• ❌ Check for page overflow and create new pages
• ❌ Draw table grid lines individually
• ❌ Recreate font objects repeatedly

TerraPDF handles it:

• ✅ Automatic pagination and text wrapping
• ✅ Native tables with repeating headers across pages
• ✅ Built-in page numbering (X of Y)
• ✅ Declarative containers (Column, Row) manage spacing

You describe what to render. TerraPDF handles how to position it.

Advanced: Multi-Page Tables With Auto Headers

TerraPDF tables automatically repeat header rows on page breaks — no extra code needed. 100 items? It splits across as many pages as required:

table.HeaderRow(row =>  // This repeats on every page
{
    row.Cell().Background("#1a4a8a").Text("Description").Bold();
    // ... other headers
});

foreach (var item in largeItemList)  // Automatic page breaks
    table.Row(row => { /* cells */ });

This is extremely hard in PdfSharp or DIY approaches.

Comparison: TerraPDF vs PdfSharp vs DIY for Invoices

Production Pattern: Reusable Components

For larger projects, extract into a reusable IComponent:

public class InvoiceDocument : IComponent
{
    private readonly Invoice _data;
    public InvoiceDocument(Invoice data) => _data = data;

    public void Compose(IContainer container) => container.Page(page =>
    {
        page.Header().Text($"INVOICE #{_data.Number}").Bold();
        page.Content().Table(t => BuildInvoiceTable(t));
        page.Footer().Text($"Page {page.PageNumber}");
    });

    private void BuildInvoiceTable(ITableDescriptor t) { /* table logic */ }
}

Document.Create(new InvoiceDocument(invoice)).PublishPdf("invoice.pdf");

Quick Enhancements

• Add logo: r.ConstantItem(120).Image("logo.png", 40);
• Add QR code: native since v1.5 — container.QrCode($"https://pay.example/{inv.Number}", size: 90);
• Add a barcode: container.Barcode(inv.Number, width: 260, height: 50, showCaption: true);
• Lock it down: container.Encrypt(new EncryptionOptions { UserPassword = ..., Permissions = PdfPermissions.Print }); — AES-256 by default
• Multi-currency: Use CultureInfo for formatting
• Non-Latin customer names: embed a TrueType font; TerraPDF subsets it automatically and shapes Devanagari correctly
• Conditional sections: Use .ShowIf(condition) decorator

Best Practices

1. Use records for data models (concise, immutable)
2. Centralize constants (colors, sizes) to const fields
3. Extract table building to separate methods
4. Validate input before generation
5. Reuse styles with page.DefaultTextStyle() instead of repeating on every call
6. Unit test by parsing PDF text with a PDF library

Why This Matters

TerraPDF makes PDF generation approachable. No coordinate math. No manual page breaks. No grid-drawing loops.

In 30 lines you get:

• Professional multi-page invoices
• Auto-pagination with repeating table headers
• Built-in page numbers
• Clean, maintainable code
• MIT license

If you've avoided PDF generation, TerraPDF changes the game.

Written against TerraPDF 2.2. See the changelog for what's landed since, or the samples for more complete documents.

Updated for TerraPDF 2.2 (September 2026). TerraPDF has moved a long way since this comparison was first written: AES-256 encryption (v1.4), barcodes and QR codes (v1.5), custom TrueType font embedding with Devanagari shaping (v2.0), automatic font subsetting (v2.1), and a vector canvas with images, arcs, pie sectors and rotated text (v2.2). The feature matrix and limitations below reflect that.

Overview of the Contenders

TerraPDF

TerraPDF is a modern, lightweight, zero-dependency, pure C# library for generating professional PDF documents — PDF 1.7 normally, PDF 2.0 when you encrypt. Developed as an open-source project under the MIT license, it provides a fluent, composable API with no external dependencies, targeting .NET 8, .NET 9, and .NET 10.

Key Features:

• Zero dependencies — single NuGet package, no native binaries
• Fluent, intuitive API with declarative layout
• Text styling (bold, italic, strikethrough, underline, color, line height)
• Tables with auto-repeating header rows on multi-page splits
• PNG and JPEG image embedding
• Automatic Table of Contents generation from H1–H6 headings
• PDF bookmarks/outlines with hierarchical nesting
• Hyperlinks (URI) and internal document links (GoTo)
• Margins, padding, backgrounds, borders (full, rounded, per-edge)
• Column, Row, and Table layout containers
• Headers, footers, and automatic page numbering
• Reusable components via IComponent interface
• Conditional rendering via ShowIf
• AES-256 encryption by default, with user/owner passwords and permission flags
• Code128 barcodes and ISO/IEC 18004 QR codes, rendered as vectors
• Custom TrueType font embedding with automatic subsetting and Devanagari shaping
• Vector canvas: shapes, Bezier paths, dashed strokes, arcs, pie sectors, rotated text, and positioned images
• MIT License — completely free for commercial use

Installation — get TerraPDF from NuGet:

📦 https://www.nuget.org/packages/TerraPDF/

dotnet add package TerraPDF

iTextSharp (iText 7)

iTextSharp is the .NET port of the popular Java iText library (now iText 7). It's one of the most widely-used enterprise PDF libraries with decades of development, but comes with significant licensing considerations.

Key Features:

• Complete PDF 2.0 specification support
• Extensive document manipulation (edit existing PDFs)
• PDF/A (all variants), PDF/UA accessibility compliance
• Digital signatures with timestamping and encryption
• Advanced form creation (AcroForms and XFA)
• Rich graphics engine (Bézier curves, gradients, transparency)
• Large community, extensive documentation
• AGPL or commercial license (must open-source your code under AGPL if using free version)

PdfSharp

PdfSharp is a mature, open-source .NET PDF library originally created by Stefan Steiger (empira). It's been a popular choice for simple PDF generation due to its straightforward API and permissive MIT license.

Key Features:

• Simple, straightforward imperative API (drawing model)
• MIT license — completely free
• Basic drawing primitives (lines, rectangles, curves)
• Text rendering with basic fonts
• PDF/A-1b support
• Image embedding (limited formats)
• Primarily for PDF generation, not full manipulation
• Mono-compatible

Licensing Comparison — The Critical Decision Factor

This is often the single most important factor for project selection.

Critical Licensing Notes:

iTextSharp AGPL Trap: iText's AGPL license is viral—if you use iText in your application (even as a library), your entire application must be licensed under AGPL and its source code made publicly available. Many companies have been forced to open-source proprietary code or purchase expensive commercial licenses ($5,000+ per year) after discovering this too late.

TerraPDF & PdfSharp: Both use the permissive MIT license with no strings attached. You can use them in closed-source commercial applications, modify them, redistribute them—no restrictions.

Performance Benchmarks

Based on independent testing (PDF generation of a 50-page mixed document with text and images on .NET 8, Release build). Treat these as indicative rather than authoritative — run your own benchmark against your own documents before making a decision on performance alone:

Observations:

• TerraPDF leads in text rendering and complex layouts due to its optimized layout engine
• PdfSharp uses the least memory but struggles with concurrent operations and complex multi-page tables
• iText 7 is middle-of-the-pack but has the largest feature gap closure potential with paid add-ons

API Design and Developer Experience

TerraPDF — Modern Fluent API

TerraPDF uses a declarative, fluent API that reads like a document structure description:

using TerraPDF.Core;
using TerraPDF.Helpers;

Document.Create(container =>
{
    container.Page(page =>
    {
        page.Size(PageSize.A4);
        page.Margin(2, Unit.Centimetre);
        page.PageColor(Color.White);
        page.DefaultTextStyle(s => s.FontSize(11));

        page.Header()
            .Text("Annual Report 2025")
            .Bold().FontSize(24).FontColor(Color.Blue.Darken2);

        page.Content().Column(col =>
        {
            col.Spacing(8);
            col.Item().Text("Hello, TerraPDF!").Bold();
            col.Item().Text("This paragraph is emphasized.")
                .Italic().FontColor(Color.Grey.Darken2);
            col.Item()
               .Margin(6).Background(Color.Grey.Lighten4).Padding(10)
               .Text("Important note: Always validate input.").Bold();
        });

        page.Footer()
            .AlignCenter()
            .Text(t =>
            {
                t.Span("Page ");
                t.CurrentPageNumber();
                t.Span(" / ");
                t.TotalPages();
            });
    });
})
.PublishPdf("report.pdf");

Advantages:

• Declarative, easy to read
• Automatic pagination (text flows to next page automatically)
• Built-in headers/footers with page numbers
• Layout-aware (Column, Row, Table containers)
• Minimal boilerplate

Disadvantages:

• Less control over low-level PDF objects
• No PDF editing/modification (generation only)
• Younger library (smaller community)

iText 7 — Verbose but Powerful

iText uses an object-oriented approach with fine-grained control:

using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;

using var writer = new PdfWriter("output.pdf");
using var pdf = new PdfDocument(writer);
var document = new Document(pdf);

document.Add(new Paragraph("Hello World")
    .SetFontSize(12)
    .SetBold()
    .SetFontColor(iText.Kernel.Colors.DeviceRgb.BLUE));

document.Close();

Advantages:

• Extremely fine-grained control over every PDF object
• Can edit existing PDFs (add text, stamps, annotations)
• Most comprehensive feature set (forms, signatures, accessibility)
• Mature, battle-tested in enterprise for 20+ years
• Extensive documentation and examples

Disadvantages:

• Verbose, more boilerplate
• AGPL licensing is a deal-breaker for most commercial apps
• Steeper learning curve
• API feels dated compared to modern fluent APIs

PdfSharp — Simple but Limited

PdfSharp uses a GDI+-inspired drawing model:

using PdfSharp.Pdf;
using PdfSharp.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
page.Size = PdfSharp.PageSize.A4;

var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("Arial", 12, XFontStyle.Bold);

graphics.DrawString("Hello World", font, XBrushes.Black,
    new XPoint(50, 50));

document.Save("output.pdf");

Advantages:

• Simple, imperative style familiar to GDI+ developers
• MIT license — worry-free commercial use
• Good for basic one-page documents
• Works with System.Drawing concepts

Disadvantages:

• Manual positioning — no automatic layout
• No built-in pagination; you manage page breaks
• Limited table support (must draw manually)
• No support for editing existing PDFs
• Aging codebase, slower updates

Feature Matrix — What Each Library Actually Does

Real-World TerraPDF Code Samples

From the official TerraPDF samples repository (verified real code):

Invoice with 30 line items, multi-page table:

using TerraPDF.Core;
using TerraPDF.Helpers;

const string brand = "#1a4a8a";
const string lightBrand = "#EBF2FF";

string logoPath = "small_logo.jpg";

var items = new (string Desc, int Qty, decimal Unit)[]
{
    ("Web Development - Phase 1",     1, 2500.00m),
    ("UI/UX Design",                  1,  800.00m),
    ("Server Setup",                  1,  600.00m),
    // ... 27 more items ...
};

Document.Create(doc =>
{
    doc.Page(page =>
    {
        page.Size(PageSize.A4);
        page.Margin(2, Unit.Centimetre);
        page.DefaultTextStyle(s => s.FontSize(10));

        page.Header().Column(col =>
        {
            // Logo + invoice metadata
            col.Item().Row(row =>
            {
                row.RelativeItem().Column(c =>
                {
                    if (File.Exists(logoPath))
                        c.Item().Image(logoPath, 80);
                });

                row.AutoItem().AlignRight().Column(info =>
                {
                    info.Item().AlignRight()
                        .Text("INVOICE").Bold().FontSize(26).FontColor(brand);
                    info.Item().AlignRight().Text("Invoice # INV-2025-0042");
                    info.Item().AlignRight().Text("Date: June 15, 2025");
                });
            });

            // Bill-from/Bill-to
            col.Item().Row(row =>
            {
                row.RelativeItem().Column(c =>
                {
                    c.Item().Text("FROM").Bold().FontSize(8).FontColor(Color.Grey.Medium);
                    c.Item().Text("TerraPDF Co. Ltd.").Bold().FontColor(brand);
                    c.Item().Text("42 Innovation Drive, Suite 7");
                });

                row.RelativeItem().MarginLeft(12)
                   .Background(lightBrand).Padding(8)
                   .Column(c =>
                {
                    c.Item().Text("BILL TO").Bold().FontSize(8).FontColor(Color.Grey.Medium);
                    c.Item().Text("Acme Global Solutions Inc.").Bold().FontColor(brand);
                    c.Item().Text("Mr. Jonathan Harker, CFO");
                });
            });
        });

        page.Content().PaddingVertical(0.6, Unit.Centimetre).Column(col =>
        {
            // Multi-page table with repeating header
            col.Item().Table(table =>
            {
                table.ColumnsDefinition(c =>
                {
                    c.RelativeColumn(5);  // Description
                    c.RelativeColumn(1);  // Qty
                    c.RelativeColumn(2);  // Unit price
                    c.RelativeColumn(2);  // Line total
                });

                table.HeaderRow(row =>
                {
                    row.Cell().Background(brand).Padding(6)
                       .Text("Description").Bold().FontColor(Color.White);
                    row.Cell().Background(brand).Padding(6).AlignCenter()
                       .Text("Qty").Bold().FontColor(Color.White);
                    row.Cell().Background(brand).Padding(6).AlignRight()
                       .Text("Unit Price").Bold().FontColor(Color.White);
                    row.Cell().Background(brand).Padding(6).AlignRight()
                       .Text("Total").Bold().FontColor(Color.White);
                });

                foreach (var (desc, qty, unit) in items)
                {
                    decimal line = qty * unit;
                    table.Row(row =>
                    {
                        row.Cell().Padding(6).Text(desc);
                        row.Cell().Padding(6).AlignCenter().Text(qty.ToString());
                        row.Cell().Padding(6).AlignRight().Text($"${unit:N2}");
                        row.Cell().Padding(6).AlignRight().Text($"${line:N2}");
                    });
                }
            });

            // Totals block (right-aligned)
            col.Item().Row(row =>
            {
                row.RelativeItem(6); // spacer
                row.RelativeItem(4).Column(totals =>
                {
                    totals.Item().LineHorizontal(1, Color.Grey.Lighten2);
                    totals.Item().Row(r =>
                    {
                        r.RelativeItem().Text("Subtotal");
                        r.RelativeItem().AlignRight().Text($"${subtotal:N2}");
                    });
                    totals.Item().Row(r =>
                    {
                        r.RelativeItem().Text("Tax (10%)");
                        r.RelativeItem().AlignRight().Text($"${tax:N2}");
                    });
                    totals.Item().LineHorizontal(1.5, brand);
                    totals.Item().Row(r =>
                    {
                        r.RelativeItem().Text("TOTAL DUE").Bold();
                        r.RelativeItem().AlignRight().Text($"${total:N2}").Bold();
                    });
                });
            });
        });

        page.Footer().Column(col =>
        {
            col.Item().LineHorizontal(1, Color.Grey.Lighten2);
            col.Item().PaddingTop(4).Row(row =>
            {
                row.RelativeItem()
                   .Text("Thank you for your business!")
                   .FontColor(Color.Grey.Medium).FontSize(9);
                row.AutoItem().AlignRight().Text(t =>
                {
                    t.Span("Page ");
                    t.CurrentPageNumber();
                    t.Span(" / ");
                    t.TotalPages();
                });
            });
        });
    });
}).PublishPdf("invoice.pdf");

Table of Contents (auto-generated from headings):

Document.Create(container =>
{
    // TOC page (automatically populated)
    container.TableOfContents(p =>
    {
        p.Size(PageSize.A4);
        p.Margin(2, Unit.Centimetre);
        p.Header().MarginBottom(12)
           .Text("Table of Contents").AlignCenter()
           .Bold().FontSize(20);
    });

    // Chapters with H1-H6 headings (auto-collected)
    container.Page(p =>
    {
        p.Content()
            .H1("Introduction")
            .H2("What is TerraPDF?")
            .H3("Core Features")
            .H4("Text Styling")
            .H5("Colors")
            .H6("Units");
    });

    container.Page(p =>
    {
        p.Content()
            .H1("Advanced Features")
            .H2("Tables")
            .H2("Images");
    });
})
.PublishPdf("document_with_toc.pdf");

Multi-span mixed formatting:

container.Text(t =>
{
    t.Span("This is ");
    t.Span("bold").Bold();
    t.Span(", ");
    t.Span("italic").Italic();
    t.Span(", and ");
    t.Span("colored").FontColor(Color.Blue.Medium);
    t.Span(" text.");
});

Real-World Use Cases: Which Library For What?

Choose TerraPDF if:

• You need a modern, zero-dependency PDF generator
• Your project requires automatic pagination and layout
• You need tables with auto-repeating headers on multi-page
• You want Table of Contents generation
• You need encrypted PDFs without pulling in BouncyCastle or a commercial license
• You need barcodes, QR codes, or non-Latin scripts in a container image with nothing installed
• MIT license is required (commercial, closed-source)
• Generating invoices, reports, newsletters, multi-page documents
• You appreciate a fluent, declarative API

Choose iText 7 if:

• You need to edit/modify existing PDFs (add stamps, fill forms, merge)
• PDF/A or PDF/UA compliance is mandatory
• Digital signatures with timestamping required
• You're building enterprise document processing systems
• Your organization already accepts AGPL or has a commercial license budget
• You need the deepest feature set (XFA forms, form filling, compliance profiles)

Choose PdfSharp if:

• Your needs are very basic (simple one-page forms, basic receipts)
• You need the smallest possible dependency footprint
• You're on a tight budget and MIT license is non-negotiable
• You prefer an imperative drawing-style API
• You only need PDF generation (no editing or complex features)

Migration Considerations

From PdfSharp to TerraPDF:

• API paradigm shift: imperative (XGraphics) → declarative (fluent containers)
• Expect 1-2 weeks of development for medium-complexity migration
• Biggest change: no manual coordinate positioning; use Column/Row/Table
• Layout rework required if using absolute positioning

From iTextSharp to TerraPDF:

• Both use fluent APIs but TerraPDF is more layout-focused
• Cannot migrate if you need PDF editing, signatures, or PDF/A compliance
• Encryption, custom fonts, and barcodes all have direct equivalents now, so those are no longer blockers
• Expect 2-4 weeks for medium projects
• Rewrite document structure; TerraPDF doesn't expose low-level PDF objects

From TerraPDF to iTextSharp:

• Only consider if you suddenly need editing or compliance features
• Significant rewrite due to different API philosophies
• Not recommended unless absolutely necessary

Limitations and Gaps

TerraPDF limitations (as of 2.2):

• ❌ No PDF editing/modification (generation only)
• ❌ No digital signatures
• ❌ No PDF/A or PDF/UA compliance
• ❌ No form fields (AcroForms/XFA)
• ⚠️ No high-level chart API — you draw charts yourself on the vector canvas, or generate SVG with TerraFluent.Chart.Reporting
• ❌ Smaller community (fewer third-party tutorials)
• ❌ Younger library (fewer battle-tested edge-case validations)

The gaps that used to headline this list — encryption, custom fonts, barcodes, graphics primitives — have all been filled since v1.3. What remains is genuinely structural: TerraPDF writes PDFs, it does not read or modify them, and it does not do signatures or formal compliance profiles.

iText 7 limitations:

• ⚠️ AGPL licensing traps
• ⚠️ Complex, verbose API
• ⚠️ Larger binary size

PdfSharp limitations:

• ❌ No automatic layout or pagination
• ❌ Very basic table support
• ❌ No headers/footers built-in
• ❌ No TOC, bookmarks, or internal links
• ❌ Limited image format support

Conclusion: Accurate Recommendations

All three libraries have distinct niches:

TerraPDF (MIT, zero-dependency) is genuinely excellent for new greenfield projects requiring clean PDF generation with automatic layout. Its fluent API is a breath of fresh air compared to the verbosity of iText and the manual labor of PdfSharp. It's not a iText killer—it doesn't try to be. It's a focused, modern generator perfect for invoices, reports, and structured documents.

Performance Reality: The benchmarks in this article are based on actual library capabilities. TerraPDF's text rendering advantage comes from its layout-first design. PdfSharp's low memory usage is because it's simpler. iText 7 is middle-of-the-pack but offers the most features when you need them.

Choosing the right tool:

• For 80% of PDF generation needs (invoices, reports, letters): TerraPDF. Clean API, zero cost, zero licensing risk, excellent performance.
• For enterprise compliance needs (signatures, PDF/A, editing existing files): iText 7 (with commercial license budget), or consider alternatives like QuestPDF (similar philosophy to TerraPDF, but with a native SkiaSharp dependency and a revenue-capped free tier) or IronPDF (commercial, feature-rich).
• For extremely simple one-pagers on a shoestring budget: PdfSharp still works, but you'll write more manual layout code.

Final verdict: TerraPDF is a legitimate, valuable addition to the .NET PDF ecosystem filling the gap between PdfSharp's simplicity and iText's complexity—with a permissive MIT license and modern developer experience. It's not inaccurate to say it's competitive for a specific class of problems: declarative document generation with automatic layout.

If your needs align with what TerraPDF actually offers (check the feature matrix), it's an excellent choice. If you need editing, signatures, or compliance, look elsewhere.

And if PDF isn't the only format you have to ship — if the same data has to come out as HTML, as a real Word document, or as a chart — the sibling project TerraFluent applies the same design to four packages instead of one.

Further reading: TerraPDF features · changelog · docs

Why Go Dependency-Free?

Before diving into implementation, let's understand why you might want to avoid third-party PDF libraries:

• Reduced deployment size: No DLLs to ship with your application
• No licensing concerns: Avoid AGPL or commercial license complications
• Improved security: Fewer dependencies means fewer vulnerability vectors
• Full control: Customize every aspect of PDF generation
• Learning opportunity: Deep understanding of the PDF format

Two Approaches to Zero-Dependency PDFs

Let's examine both.

Option 1: Building Your Own Minimal PDF Generator

A PDF file is essentially a structured binary file with these main components:

1. Header: Identifies the file as PDF (%PDF-1.7)
2. Body: Contains objects defining pages, fonts, content streams
3. Cross-reference table: Byte offsets for quick object lookup
4. Trailer: Points to root object and cross-reference table

Minimal Valid PDF

The smallest possible PDF displays "Hello World":

%PDF-1.4
1 0 obj
<< /Type /Catalog /Pages 2 0 R >>
endobj
2 0 obj
<< /Type /Pages /Kids [3 0 R] /Count 1 >>
endobj
3 0 obj
<< /Type /Page /Parent 2 0 R /MediaBox [0 0 72 72] /Contents 4 0 R /Resources << >> >>
endobj
4 0 obj
<< /Length 44 >>
stream
BT
/F1 12 Tf
50 50 Td
(Hello World) Tj
ET
endstream
endobj
xref
0 5
0000000000 65535 f
0000000009 00000 n
0000000058 00000 n
0000000115 00000 n
0000000212 00000 n
trailer
<< /Size 5 /Root 1 0 R >>
startxref
290
%%EOF

Building a C# Generator

Here's a complete minimal PDF generator (~150 lines):

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

public class SimplePdfDocument
{
    private readonly List<PdfObject> objects = new();
    private int nextObjectId = 1;
    private readonly List<int> pageObjectIds = new();

    public int AddPage()
    {
        var page = new PdfDictionary
        {
            ["Type"] = "/Page",
            ["Parent"] = 0, // updated later
            ["MediaBox"] = new PdfArray { 0, 0, 595, 842 }, // A4
            ["Contents"] = 0,
            ["Resources"] = new PdfDictionary()
        };
        int id = AddObject(page);
        pageObjectIds.Add(id);
        return id;
    }

    public void SetPageContent(int pageId, string content)
    {
        var stream = new PdfStream(Encoding.ASCII.GetBytes(content));
        int streamId = AddObject(stream);
        var page = objects[pageId - 1] as PdfDictionary;
        page["Contents"] = streamId;
    }

    public string GenerateText(string text, float x, float y, float fontSize = 12)
    {
        return $"BT\n/F1 {fontSize} Tf\n{x} {y} Td\n({Escape(text)}) Tj\nET";
    }

    private string Escape(string s) => s.Replace("(", "\\(").Replace(")", "\\)");
    private int AddObject(PdfObject obj) { obj.Number = nextObjectId++; objects.Add(obj); return obj.Number; }

    public void Save(string path)
    {
        using var w = new StreamWriter(path, false, Encoding.ASCII);
        w.WriteLine("%PDF-1.4");
        var offsets = new List<long>();
        foreach (var obj in objects)
        {
            offsets.Add(w.BaseStream.Position);
            w.Write(obj.ToString());
            w.WriteLine();
        }
        long xrefPos = w.BaseStream.Position;
        w.WriteLine("xref"); w.WriteLine($"0 {objects.Count + 1}");
        w.WriteLine("0000000000 65535 f");
        foreach (var off in offsets) w.WriteLine(off.ToString("D10") + " 00000 n");
        w.WriteLine("trailer"); w.WriteLine($"<< /Size {objects.Count + 1} /Root 1 0 R >>");
        w.WriteLine("startxref"); w.WriteLine(xrefPos); w.WriteLine("%%EOF");
    }
}

public abstract class PdfObject { public int Number { get; set; } public abstract override string ToString(); }
public class PdfDictionary : PdfObject, Dictionary<string, object>
{
    private readonly Dictionary<string, object> d = new();
    public void Add(string k, object v) => d[k] = v;
    public override string ToString()
    {
        var sb = new StringBuilder();
        sb.Append($"{Number} 0 obj\n<<\n");
        foreach (var kv in d) sb.Append($"  {kv.Key} {Serialize(kv.Value)}\n");
        sb.Append(">>\nendobj"); return sb.ToString();
    }
    private string Serialize(object v) => v switch { string s when s.StartsWith("/") => s, string s => $"/{s}", int i => i.ToString(), PdfArray a => a.ToString(), _ => v.ToString()! };
}
public class PdfArray : List<object>
{
    public override string ToString()
    {
        var sb = new StringBuilder("[ ");
        for (int i = 0; i < Count; i++) sb.Append(i > 0 ? " " : "").Append(ToStringElement(this[i]));
        sb.Append(" ]"); return sb.ToString();
    }
    private string ToStringElement(object e) => e switch { int i => i.ToString(), string s => s.StartsWith("/") ? s : $"/{s}", _ => e.ToString()! };
}
public class PdfStream : PdfObject
{
    private readonly byte[] data; public int Length => data.Length;
    public PdfStream(byte[] d) => data = d;
    public override string ToString() => $"{Number} 0 obj\n<< /Length {Length} >>\nstream\n{Encoding.ASCII.GetString(data)}\nendstream\nendobj";
}

Usage — a functional invoice generator in ~30 lines of actual logic:

var doc = new SimplePdfDocument();
int pageId = doc.AddPage();

var sb = new StringBuilder();
sb.AppendLine(doc.GenerateText("INVOICE #12345", 50, 750, 16));
sb.AppendLine(doc.GenerateText("Acme Corp", 50, 730));
sb.AppendLine(doc.GenerateText("Date: 2025-06-15", 400, 750, 9));
sb.AppendLine(doc.GenerateText("Amount Due: $1,250.00", 400, 730, 9));
sb.AppendLine(doc.GenerateText("Thank you for your business!", 220, 100, 10));

doc.SetPageContent(pageId, sb.ToString());
doc.Save("invoice.pdf");

That's 5 lines of setup, 5 lines of content building, 2 lines of save — 12 lines total for a working invoice.

Limitations of DIY PDF Generation

While educational and lightweight, roll-your-own has hard limits:

1. Fonts: Only basic 14 PDF fonts (Helvetica, Times, Courier, Symbol, ZapfDingbats) are natively supported. Custom fonts require encoding font programs into PFB/PFM formats—extremely complex.
2. Images: You must manually convert PNG/JPEG to DCT/Flate streams with proper filters and decode parameters.
3. Unicode: Requires CID fonts and CMaps; pages of mapping tables. Complex scripts are worse still — Devanagari alone needs matra reordering, conjunct ligatures, and reph positioning before a single glyph is correct.
4. Compression: Implementing DEFLATE (Flate) compression by hand is non-trivial.
5. PDF/A: XMP metadata, font embedding mandates, colour profiles—do not attempt without serious effort.
6. Complex graphics: Bézier curves, transparency groups, shadings—mathematically heavy.

Option 2: TerraPDF — Production-Ready Zero-Dependency

TerraPDF is a real, open-source (MIT) library that is genuinely zero-dependency: no external runtime packages, no native binaries, just a single managed DLL. It targets .NET 8, 9, and 10, and works cross-platform.

Installation

🚀 TerraPDF NuGet Package: https://www.nuget.org/packages/TerraPDF/

dotnet add package TerraPDF

That's it — no transitive dependencies pulled in. Verify with:

dotnet list package --include-transitive
# Output: No transitive dependencies found.

Real TerraPDF Invoice in 30 Lines

using TerraPDF.Core;
using TerraPDF.Helpers;

public record Invoice(string Number, DateTime Date, string Customer, List<Item> Items)
{
    public decimal Total => Items.Sum(i => i.LineTotal);
}
public record Item(string Desc, int Qty, decimal UnitPrice) { public decimal LineTotal => Qty * UnitPrice; }

public static byte[] GenerateInvoice(Invoice inv)
{
    return Document.Create(doc =>
    {
        doc.Page(page =>
        {
            page.Size(PageSize.A4);
            page.Margin(2, Unit.Centimetre);
            page.DefaultTextStyle(s => s.FontSize(10));

            page.Header().Column(h =>
            {
                h.Item().Text("INVOICE").Bold().FontSize(22).FontColor("#1a4a8a");
                h.Item().Row(r =>
                {
                    r.RelativeItem().Text($"#: {inv.Number}  |  Date: {inv.Date:yyyy-MM-dd}");
                    r.AutoItem().AlignRight().Text($"Due: {inv.Date.AddDays(30):yyyy-MM-dd}");
                });
                h.Item().LineHorizontal(1, "#1a4a8a");
            });

            page.Content().Column(c =>
            {
                // Customer info
                c.Item().Row(r =>
                {
                    r.RelativeItem().Text("From: Your Company\n123 Main St");
                    r.RelativeItem().Text($"Bill To:\n{inv.Customer}");
                });

                // Table
                c.Item().Table(t =>
                {
                    t.ColumnsDefinition(cols =>
                    {
                        cols.RelativeColumn(4); // Description
                        cols.RelativeColumn(1); // Qty
                        cols.RelativeColumn(2); // Price
                        cols.RelativeColumn(2); // Total
                    });

                    t.HeaderRow(row =>
                    {
                        row.Cell().Background("#1a4a8a").Padding(5)
                           .Text("Description").Bold().FontColor(Color.White);
                        row.Cell().Background("#1a4a8a").Padding(5).AlignCenter()
                           .Text("Qty").Bold().FontColor(Color.White);
                        row.Cell().Background("#1a4a8a").Padding(5).AlignRight()
                           .Text("Price").Bold().FontColor(Color.White);
                        row.Cell().Background("#1a4a8a").Padding(5).AlignRight()
                           .Text("Total").Bold().FontColor(Color.White);
                    });

                    foreach (var item in inv.Items)
                    {
                        t.Row(row =>
                        {
                            row.Cell().Padding(5).Text(item.Desc);
                            row.Cell().Padding(5).AlignCenter().Text(item.Qty.ToString());
                            row.Cell().Padding(5).AlignRight().Text($"{item.UnitPrice:C}");
                            row.Cell().Padding(5).AlignRight().Text($"{item.LineTotal:C}");
                        });
                    }
                });

                // Totals block
                c.Item().Row(r =>
                {
                    r.RelativeItem(7); // spacer
                    r.RelativeItem(3).Column(tot =>
                    {
                        tot.Item().LineHorizontal(1, Color.Grey.Lighten2);
                        tot.Item().Row(tr =>
                        {
                            tr.RelativeItem().Text("Grand Total:");
                            tr.RelativeItem().AlignRight().Text($"{inv.Total:C}").Bold();
                        });
                    });
                });

                // Footer message
                c.Item().AlignCenter()
                  .Text("Thank you for your business!").FontSize(9).FontColor(Color.Grey.Medium);
            });

            page.Footer().AlignCenter().Text(t =>
            {
                t.Span("Page "); t.CurrentPageNumber();
                t.Span(" of "); t.TotalPages();
            });
        });
    }).PublishPdf();
}

Usage:

var inv = new Invoice(
    Number: "INV-2025-001",
    Date: DateTime.Today,
    Customer: "Acme Corp\n123 Business Rd\nMetropolis, NY",
    Items: new()
    {
        new("Web Development", 40, 150m),
        new("Server Maintenance", 10, 100m),
        new("UI/UX Design", 20, 120m),
    });

byte[] pdf = GenerateInvoice(inv);
File.WriteAllBytes("invoice.pdf", pdf);

Actual line count (excluding braces, usings, record definitions): ~30 lines of generation logic inside the Document.Create callback.

What You Get Beyond the Basics

The 30-line invoice above only uses the layout engine. The same zero-dependency package also covers the things that usually force you to add a second library:

// Barcodes and QR codes — drawn as vectors, not rasterised images
container.Barcode("SKU-00042-A", width: 260, height: 50, showCaption: true);
container.QrCode("https://example.com/track/42", size: 90,
    level: QrErrorCorrectionLevel.Q);

// AES-256 encryption with permission flags
container.Encrypt(new EncryptionOptions
{
    UserPassword = "open123",
    Permissions  = PdfPermissions.Print | PdfPermissions.CopyText,
});

// A vector canvas when you need to draw something the layout engine has no opinion about
container.Canvas(160, c =>
{
    c.FillPie(240, 20, 140, 140, -90, 151.2, Color.Blue.Medium);
    c.Line(0, 10, 240, 10, Color.Grey.Darken1, 1, 1, [8, 4], 0);   // dashed
    c.Text("Vertical axis", 10, 110, fontSize: 9, angle: -90);      // rotated
});

All of it is still managed code with no native anything. That is the part that is genuinely hard to replicate in a weekend DIY generator.

What Makes TerraPDF "Zero-Dependency"?

TerraPDF's implementation uses only .NET BCL types:

• System.IO for file/stream operations
• System.Text for encoding
• No System.Drawing.Common (already deprecated on non-Windows)
• No native interop (no libgdiplus, no ICU)
• Single managed DLL (~150 KB)

This means:

• ✅ Works on Windows, Linux, macOS identically
• ✅ Works in Docker containers without extra apt-get installs
• ✅ Works in AWS Lambda, Azure Functions, Google Cloud Run
• ✅ No Visual C++ Redistributable requirements
• ✅ No ICU or fontconfig native libraries needed

Comparison: DIY vs TerraPDF

When to Build Your Own

Build your own minimal generator when:

• Learning: Understanding PDF structure is the goal
• Tiny footprint: Sub-100 line generator fits your single-use case (e.g., thermal receipt with 3 lines)
• No third-party code allowed: Air-gapped environments, extreme compliance
• Custom format: Need non-standard PDF extensions or integrations
• Educational demos: Teaching file format internals

Example where DIY wins: A 50-line thermal receipt generator for a local store's Raspberry Pi till that just needs: item × qty = total repeated 5 times, plus totals. No images, no tables, nothing fancy. The entire generator fits in one file, no NuGet, no dependencies. Perfect.

When to Use TerraPDF

Use TerraPDF when:

• Production document generation: Invoices, reports, certificates
• Multi-page documents: Needs automatic pagination
• Tables: Any tabular data with headers
• Images/logos: Corporate branding
• Professional layout: Margins, padding, headers/footers
• MIT license requirement: Commercial closed-source
• Cross-platform: Docker, Linux servers

TerraPDF hits the sweet spot: MIT-licensed, zero external dependencies, modern fluent API, and sufficient features for 80% of PDF generation use cases.

If you also need the same content as HTML or a Word document, the sibling suite TerraFluent applies the identical approach across four packages.

When to Use a Different Library

Stick with established alternatives when you need:

• PDF editing/modifying: iText (commercial), PdfSharp (some manipulation)
• Digital signatures: iText, Aspose.PDF (commercial)
• PDF/A/PDF/UA compliance: iText, callas pdfToolbox (commercial)
• AcroForms / XFA form fields: iText
• Ultra-complex layouts: QuestPDF (more layout features, but a native SkiaSharp dependency), SelectPdf
• ASP.NET Core integration: Rotativa (HTML→PDF), DinkToPdf (wkhtmltopdf wrapper)

Complete Example: Zero-Dep Invoice (Both Approaches Side-by-Side)

DIY (150 lines, manual):

// Manual page break logic, manual table cell positioning
float y = 700;
foreach (var item in items)
{
    if (y < 100) { AddNewPage(); y = 750; }
    DrawText(item.Desc, 50, y);
    DrawText(item.Qty.ToString(), 400, y);
    DrawText($"{item.Price:C}", 470, y);
    DrawText($"{item.Total:C}", 540, y);
    y -= 18;
}

TerraPDF (30 lines, automatic):

page.Content().Column(c =>
{
    c.Item().Table(t =>
    {
        t.ColumnsDefinition(cols =>
        {
            cols.RelativeColumn(4); cols.RelativeColumn(1);
            cols.RelativeColumn(2); cols.RelativeColumn(2);
        });
        t.HeaderRow(r =>
        {
            r.Cell().Background(brand).Padding(5).Text("Description").Bold().FontColor(Color.White);
            // ... other headers
        });
        foreach (var item in items)
            t.Row(r =>
            {
                r.Cell().Padding(5).Text(item.Desc);
                r.Cell().Padding(5).AlignCenter().Text(item.Qty.ToString());
                // ...
            });
    });
});

Key difference: TerraPDF handles pagination automatically—the table splits across pages and repeats headers without any extra code.

Recommendation

For zero-dependency PDF generation in .NET:

1. Try TerraPDF first — It's genuinely zero-dep, MIT-licensed, and covers 80% of use cases with a clean API. Install with dotnet add package TerraPDF and you're done.

2. Build your own only for toy problems — Educational, tiny one-offs, or when you absolutely cannot have any external package (even MIT-licensed).

3. Reach for heavier libraries only when needed — iText for editing/signatures, Aspose for enterprise features, QuestPDF for complex declarative layouts.

The "zero-dependency" space in .NET PDF has changed: TerraPDF makes DIY PDF generation largely unnecessary for real projects. You get zero dependencies plus a full-featured API, which is the best of both worlds.

Use the DIY approach to learn, then switch to TerraPDF for production.

What is Fluent 2 Design System?

Fluent 2 is Microsoft's design system that emphasizes clarity, efficiency, and beauty. It provides:

• Comprehensive color tokens and typography scales
• Consistent spacing and layout guidelines
• Accessible component specifications
• Dark mode support with carefully chosen color values
• Animation and transition guidance

Why Choose Fluent 2?

• Enterprise-Grade: Trusted by Microsoft and major organizations
• Accessibility Focus: Built with WCAG compliance in mind
• Versatile: Works across web, mobile, and desktop applications
• Consistent: Ensures visual and behavioral consistency
• Modern Design: Clean, minimal aesthetic aligned with current trends

Getting Started with Fluent 2

1. Understanding Design Tokens

Design tokens are the foundation of Fluent 2. They define colors, typography, spacing, and other design properties. Here's how to use them:

/* Using Fluent 2 color tokens */
.button {
    background-color: var(--fluent-color-brand-primary);
    color: white;
    padding: var(--fluent-spacing-m);
    border-radius: var(--fluent-border-radius-medium);
}

2. Color System

Fluent 2 provides a carefully crafted color palette for light and dark modes:

/* Light mode (default) */
:root {
    --fluent-color-brand-primary: #0078d4;
    --fluent-color-text-primary: #242424;
    --fluent-color-background-primary: #ffffff;
}

/* Dark mode */
[data-theme="dark"] {
    --fluent-color-brand-primary: #60a5fa;
    --fluent-color-text-primary: #ffffff;
    --fluent-color-background-primary: #1f1f1f;
}

3. Typography

Fluent 2 defines a typography scale for consistency:

h1 {
    font-size: var(--fluent-font-size-xxlarge);
    font-weight: var(--fluent-font-weight-bold);
    line-height: 1.2;
}

p {
    font-size: var(--fluent-font-size-base);
    line-height: 1.6;
}

4. Spacing

Fluent 2 provides consistent spacing values:

/* Spacing tokens */
--fluent-spacing-s: 8px;
--fluent-spacing-m: 16px;
--fluent-spacing-l: 24px;
--fluent-spacing-xl: 32px;
--fluent-spacing-xxl: 48px;

Building Components

Here's an example of a Fluent 2-compliant button component:

<button class="fluent-button fluent-button-primary">
    Get Started
</button>

.fluent-button {
    padding: var(--fluent-spacing-m);
    border-radius: var(--fluent-border-radius-medium);
    font-weight: var(--fluent-font-weight-semibold);
    border: none;
    cursor: pointer;
    transition: all var(--fluent-animation-duration-fast);
}

.fluent-button-primary {
    background-color: var(--fluent-color-brand-primary);
    color: white;
}

.fluent-button-primary:hover {
    background-color: var(--fluent-color-brand-secondary);
}

Dark Mode Implementation

Fluent 2 includes comprehensive dark mode support. Toggle it with a data attribute:

// Toggle dark mode
document.body.setAttribute('data-theme', 'dark');

// All CSS variables automatically adjust based on [data-theme] selector

Best Practices

• Use Design Tokens: Always reference tokens instead of hardcoding values
• Test Accessibility: Ensure sufficient color contrast in both light and dark modes
• Consistent Spacing: Use the spacing scale for all margins and padding
• Responsive Design: Test on multiple screen sizes and devices
• Documentation: Document any custom extensions to the design system

Resources

• Fluent 2 Design System Official Site
• Development Guide
• Fluent UI GitHub Repository

Conclusion

Fluent 2 provides a robust foundation for building consistent, accessible, and beautiful applications. By leveraging its design tokens and guidelines, you can create professional interfaces that work seamlessly across platforms. Whether you're building for enterprise or consumer applications, Fluent 2 offers the flexibility and polish needed for modern web design.

Start exploring Fluent 2 today and elevate your design system to the next level!

Why Performance Matters

Performance directly impacts:

• User satisfaction and engagement
• Search engine rankings
• Conversion rates
• Mobile device experience
• Server costs

Key Performance Metrics

Core Web Vitals

• Largest Contentful Paint (LCP): How quickly the main content loads
• First Input Delay (FID): How responsive the page is to user interaction
• Cumulative Layout Shift (CLS): How stable the layout is as content loads

Other Important Metrics

• First Contentful Paint (FCP)
• Time to First Byte (TTFB)
• Total Blocking Time (TBT)

Performance Optimization Techniques

1. Image Optimization

Images are often the largest assets on a website. Optimize them:

<!-- Use modern image formats -->
<picture>
    <source srcset="image.webp" type="image/webp">
    <img src="image.jpg" alt="Description">
</picture>

<!-- Use responsive images -->
<img srcset="small.jpg 640w, medium.jpg 1024w, large.jpg 1920w"
     sizes="(max-width: 640px) 100vw, 50vw"
     src="medium.jpg" alt="Description">

2. Minification and Compression

• Minify CSS, JavaScript, and HTML
• Enable gzip compression on your server
• Use brotli compression for better compression ratios

3. Code Splitting

Break your JavaScript into smaller chunks:

// Lazy load components
const component = await import('./heavy-component.js');

4. Caching Strategies

• Implement browser caching with proper cache headers
• Use a Content Delivery Network (CDN)
• Cache API responses appropriately

5. Lazy Loading

Defer loading of non-critical resources:

<!-- Lazy load images -->
<img src="placeholder.jpg" 
     data-src="full-image.jpg" 
     loading="lazy" 
     alt="Description">

<!-- Lazy load iframes -->
<iframe src="content.html" loading="lazy"></iframe>

6. Font Optimization

Optimize web fonts for faster loading:

/* Use font-display for better performance */
@font-face {
    font-family: 'Custom Font';
    src: url('font.woff2') format('woff2');
    font-display: swap; /* Show fallback font immediately */
}

7. Critical Rendering Path

Minimize the critical rendering path:

1. Reduce the number of critical resources
2. Shorten the critical path length
3. Reduce the size of critical bytes

<!-- Preload critical resources -->
<link rel="preload" href="critical.css" as="style">
<link rel="preload" href="font.woff2" as="font">

<!-- Prefetch non-critical resources -->
<link rel="prefetch" href="next-page.html">

Tools for Performance Testing

• Google Lighthouse: Comprehensive performance audit
• WebPageTest: Detailed waterfall charts
• GTmetrix: Performance metrics and recommendations
• Pingdom: Uptime and performance monitoring

Real-World Example

Here's a performance checklist for a typical web project:

• [ ] Optimize all images (compress, use WebP)
• [ ] Minify CSS, JavaScript, and HTML
• [ ] Implement lazy loading for below-fold content
• [ ] Use a CDN for static assets
• [ ] Enable gzip/brotli compression
• [ ] Minimize render-blocking resources
• [ ] Implement service workers for caching
• [ ] Optimize third-party scripts
• [ ] Remove unused CSS and JavaScript
• [ ] Monitor Core Web Vitals

Conclusion

Website performance optimization is an ongoing process. Start with the most impactful optimizations and continuously monitor your metrics. Small improvements can add up to significant performance gains, resulting in better user experience and improved business metrics.

Remember: Fast websites create happy users and rank higher in search results!

Why Accessibility Matters

• Inclusivity: Ensures all users can access your content
• Legal Compliance: WCAG guidelines are often mandatory
• SEO Benefits: Accessible websites rank better
• Better UX: Accessibility improvements benefit all users
• Business Impact: Reach a larger audience

Web Content Accessibility Guidelines (WCAG)

WCAG has four principles:

1. Perceivable

Content must be perceivable by all users:

<!-- Always include alt text for images -->
<img src="image.jpg" alt="Descriptive text about the image">

<!-- Provide captions for videos -->
<video>
    <source src="video.mp4">
    <track kind="captions" src="captions.vtt">
</video>

<!-- Ensure sufficient color contrast -->
<!-- Use tools to check contrast ratios -->

2. Operable

Users must be able to navigate your website:

<!-- Use semantic HTML for better navigation -->
<nav>
    <ul>
        <li><a href="/">Home</a></li>
        <li><a href="/about">About</a></li>
    </ul>
</nav>

<!-- Make interactive elements keyboard accessible -->
<button onclick="handleClick()">Click me</button>

<!-- Provide skip links -->
<a href="#main-content" class="skip-link">Skip to main content</a>

3. Understandable

Content must be understandable:

<!-- Use clear, simple language -->
<!-- Avoid jargon where possible -->

<!-- Use proper heading hierarchy -->
<h1>Main Title</h1>
<h2>Section Subtitle</h2>
<p>Content...</p>

<!-- Use lists for related items -->
<ul>
    <li>Item 1</li>
    <li>Item 2</li>
</ul>

<!-- Label form inputs clearly -->
<label for="email">Email Address:</label>
<input type="email" id="email" name="email">

4. Robust

Your website must work with assistive technologies:

<!-- Use semantic HTML5 elements -->
<header>...</header>
<nav>...</nav>
<main>...</main>
<article>...</article>
<aside>...</aside>
<footer>...</footer>

<!-- Use ARIA attributes when semantic HTML isn't enough -->
<div role="alert" aria-live="polite">
    Important message for screen readers
</div>

<!-- Provide proper landmarks -->
<main id="main-content">
    <!-- Your main content -->
</main>

Best Practices for Accessibility

1. Use Semantic HTML

<!-- Good -->
<button onclick="toggleMenu()">Toggle Menu</button>

<!-- Avoid -->
<div onclick="toggleMenu()">Toggle Menu</div>

2. Color and Contrast

• Never rely solely on color to convey information
• Ensure at least 4.5:1 contrast ratio for normal text
• Use tools like WebAIM Contrast Checker

3. Keyboard Navigation

/* Ensure focus states are visible */
:focus {
    outline: 2px solid var(--fluent-color-brand-primary);
    outline-offset: 2px;
}

/* Provide hover states too */
button:hover {
    background-color: var(--fluent-color-brand-secondary);
}

4. ARIA Attributes

<!-- Provide names for interactive elements -->
<button aria-label="Close menu">×</button>

<!-- Indicate dynamic content updates -->
<div aria-live="polite" aria-label="Notifications">
    <!-- Content updates here -->
</div>

<!-- Describe complex widgets -->
<div role="tablist">
    <button role="tab" aria-selected="true" aria-controls="panel-1">Tab 1</button>
    <div id="panel-1" role="tabpanel">Content 1</div>
</div>

5. Testing for Accessibility

Essential tools:

• WAVE: Visual feedback on accessibility issues
• Axe DevTools: Comprehensive accessibility testing
• Lighthouse: Built-in accessibility audit
• Screen Readers: NVDA (Windows), JAWS, VoiceOver (Mac)
• Keyboard Navigation: Tab through your site

Common Accessibility Mistakes to Avoid

• ❌ Using <div> for buttons (use <button>)
• ❌ Missing alt text on images
• ❌ Poor color contrast
• ❌ Keyboard traps
• ❌ Auto-playing media
• ❌ Not testing with real assistive technologies
• ❌ Using images of text
• ❌ Missing form labels

Accessibility Checklist

• [ ] Use semantic HTML elements
• [ ] Add alt text to all images
• [ ] Ensure keyboard navigation works
• [ ] Check color contrast ratios
• [ ] Test with screen readers
• [ ] Provide focus indicators
• [ ] Use ARIA when needed
• [ ] Test with real users with disabilities
• [ ] Make videos captioned
• [ ] Avoid time-based content

Conclusion

Building accessible web applications is not just a technical requirement—it's about respecting and including all users. Start by using semantic HTML, then add ARIA attributes and test with real assistive technologies. Remember that accessibility is an ongoing process, not a one-time task.

Make your websites inclusive and welcoming for everyone!

What is a Static Site Generator?

A Static Site Generator takes source content (Markdown, HTML) and templates, then generates static HTML files. This approach offers:

• Performance: No server-side processing needed
• Security: No database vulnerabilities
• Simplicity: Easy to deploy and maintain
• Cost: Hosting is cheap (GitHub Pages, Netlify)
• Version Control: Content is source-controlled

Popular Static Site Generators

1. Eleventy (11ty)

Best for: Flexible, content-focused sites

npm install -g @11ty/eleventy
eleventy --serve

Strengths:

• Zero config, but highly customizable
• Supports multiple template languages
• Great for blogs and documentation
• Perfect for GitHub Pages

Perfect use case: Personal blogs, documentation sites

2. Hugo

Best for: Speed and simplicity

hugo new site my-site
hugo server -D

Strengths:

• Extremely fast build times
• Large ecosystem of themes
• Built-in features (CMS, internationalization)
• Simple configuration

Perfect use case: Large blogs, news sites

3. Jekyll

Best for: GitHub Pages integration

jekyll new my-site
jekyll serve

Strengths:

• Native GitHub Pages support
• Simple setup for beginners
• Good documentation
• Large community

Perfect use case: GitHub Pages-hosted projects

4. Next.js

Best for: React-based static sites

npx create-next-app@latest
npm run build && npm run export

Strengths:

• Use React for templates
• Dynamic features possible
• Excellent developer experience
• Great for component-based sites

Perfect use case: React applications with static export

5. Astro

Best for: Modern, fast static sites

npm create astro@latest
npm run dev

Strengths:

• Build-time optimization
• Multiple framework support
• Excellent performance
• Modern development experience

Perfect use case: Performance-critical websites

Comparison Table

Getting Started with Eleventy

Here's a minimal Eleventy setup:

// .eleventy.js
module.exports = function(eleventyConfig) {
  eleventyConfig.addPassthroughCopy("src/assets");
  
  return {
    dir: {
      input: "src",
      output: "_site"
    }
  };
};

Create templates:

<!-- src/_includes/base.njk -->
<!DOCTYPE html>
<html>
<head>
    <title>Static Site Generators (SSGs) have revolutionized how we build websites</title>
</head>
<body>
    
</body>
</html>

Create content:

---
layout: base
title: My Post
---

# Hello World

This is my first post!

Deployment Options

GitHub Pages (Free)

# Push to GitHub and enable Pages in settings
git push origin main

Netlify (Free tier available)

# Connect your repository and configure build settings
# Automatic deployments on push

Vercel (Free tier available)

# Similar to Netlify with Next.js native support

Traditional Hosting

# Build locally and upload _site/ folder
npm run build
# FTP/SSH to your server

When to Use Static Site Generators

✅ Use SSGs when:

• Building blogs or documentation
• Content doesn't change frequently
• You want optimal performance
• Security is critical
• You're comfortable with version control

❌ Avoid SSGs when:

• Real-time data updates needed
• Dynamic user content (comments)
• Large-scale e-commerce with inventory
• Complex user authentication needed
• Frequent content updates (real-time)

Migration Tips

If migrating from WordPress or other CMS:

1. Export your content to Markdown
2. Choose your SSG
3. Create templates/layouts
4. Set up deployment
5. Redirect old URLs properly
6. Monitor analytics post-migration

Workflow Example

# 1. Create content
echo "# My New Post" > src/posts/my-post.md

# 2. Test locally
npm run start

# 3. Build for production
npm run build

# 4. Deploy
git push origin main  # If using Netlify/GitHub Pages
# or manually upload _site/ folder

Conclusion

Static Site Generators are powerful tools for building fast, secure, and maintainable websites. Whether you choose Eleventy for flexibility, Hugo for speed, or another option, you'll benefit from:

• Better performance
• Improved security
• Version-controlled content
• Cost-effective hosting
• Simplified deployment

Choose the SSG that best fits your needs and project requirements. Happy building!

Hey there, fellow developers! If you're diving into the world of web development, you know how important it is to have well-documented APIs. ASP.NET Core 9 has got your back with enhanced support for OpenAPI, making it super easy to document your Web APIs. In this post, we'll walk you through how to leverage OpenAPI in ASP.NET Core 9 and use Swagger UI to create awesome API documentation.

What is OpenAPI?

First things first, let's talk about OpenAPI. Formerly known as Swagger, OpenAPI is a specification for building APIs. It helps you define your APIs in a standardized format, making them easier to understand, test, and integrate with other systems. Think of it as a blueprint for your API, detailing its structure, endpoints, request/response formats, and authentication methods.

Setting Up ASP.NET Core 9

Ready to get started? Make sure you have the latest version of the .NET SDK installed. You can create a new ASP.NET Core 9 project with this command:

dotnet new webapi -minimal -n MyApiProject
cd MyApiProject

Adding OpenAPI Support

ASP.NET Core 9 comes with built-in support for OpenAPI. To enable it, you'll need to add the Microsoft.AspNetCore.OpenApi package to your project. Just run:

dotnet add package Microsoft.AspNetCore.OpenApi

Next, open the Program.cs file and configure OpenAPI in the ConfigureServices and Configure methods:

var builder = WebApplication.CreateBuilder(args);

// builder.Services.AddEndpointsApiExplorer();
// builder.Services.AddSwaggerGen();
// The above two lines are not needed with ASP.Net Core 9 

// Learn more about configuring OpenAPI at https://aka.ms/aspnet/openapi
builder.Services.AddOpenApi();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    // app.UseSwagger(); This is also not needed now. Instead use function MapOpenApi()
    app.MapOpenApi("OpenApi/v1/OpenApiDoc.json");
    app.UseSwaggerUI(c =>
    {
     c.SwaggerEndpoint("/OpenApi/v1/OpenApiDoc.json", "My API Documentation V1");
    }
  
}

app.UseHttpsRedirection();

var apiGroup = app.MapGroup("/api");

apiGroup.MapGet("/greet", () => "Hello, World!")
    .WithName("Greet")
    .WithDescription("Returns a greeting message.");

app.Run();

Using Swagger UI

Swagger UI is a fantastic tool that automatically generates interactive API documentation from your OpenAPI specification. With Swagger UI, you can visualize and test your API endpoints right from your browser.

To check it out, run your application and navigate to http://localhost:5000 (or the appropriate URL for your setup). You'll see a user-friendly interface displaying your API endpoints, request/response formats, and other details.

Customizing Swagger UI

Want to make Swagger UI your own? You can customize its appearance and behavior by tweaking the SwaggerUIOptions in the Configure method. For example, you can change the theme, add custom CSS, or enable deep linking:

app.UseSwaggerUI(c =>
{
    c.SwaggerEndpoint("/OpenApi/v1/OpenApiDoc.json", "My API Documentation V1");
    c.RoutePrefix = "OpenApiDoc";
    c.DocumentTitle = "My Custom API Documentation";
    c.InjectStylesheet("/swagger-ui/custom.css");
    c.EnableDeepLinking();
});

What is EnableDeepLinking()?

The EnableDeepLinking() function in Swagger UI is a nifty feature that allows you to enable deep linking for tags and operations. This means each tag and operation in your API documentation will have a unique URL that can be bookmarked and shared. When you navigate to a specific tag or operation using its URL, Swagger UI will automatically expand and highlight the corresponding section. This is super handy for large APIs, as it lets users quickly access and share specific parts of the documentation.

Providing Descriptions for Endpoints

In Minimal APIs, you can provide descriptions for your endpoints using the WithDescription method. This method lets you add a brief description of what the endpoint does, which will be displayed in the Swagger UI. For example:

apiGroup.MapGet("/greet", () => "Hello, World!")
    .WithName("Greet")
    .WithDescription("Returns a greeting message.");

These descriptions help users understand the purpose of each endpoint and how to use them effectively.

Launch Settings for Swagger UI

To automatically open Swagger UI when you run your project, you can configure the launch settings in the launchSettings.json file. Here's how you can do it:

1. Open the Properties folder in your project.
2. Open the launchSettings.json file.
3. Add the following configuration under the profiles section:

{
  "profiles": {
    "MyApiProject": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "launchUrl": "OpenApiDoc",
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

Conclusion

OpenAPI support in ASP.NET Core 9, combined with Swagger UI, provides a powerful and user-friendly way to document your Web APIs. By following the steps outlined in this blog post, you can create comprehensive and interactive API documentation that will benefit both developers and users.

Happy coding! 😊

In today's rapidly evolving digital landscape, securing web applications is paramount. Implementing robust authentication strategies is crucial to protect sensitive data and ensure authorized access. ASP.NET Core 9 provides versatile authentication methods, allowing developers to integrate multiple ways to authenticate users within a single project. This blog will guide you through implementing both key-based and basic authentication in ASP.NET Core 9, utilizing C# sample code for seamless integration. These methods, when combined, offer enhanced security solutions tailored to specific application needs.

Understanding Authentication Mechanisms

Authentication is the process of identifying who a user is and ensuring that they are allowed to access the resources or operations they are requesting. In ASP.NET Core 9, authentication is achieved through middleware that intercepts HTTP requests and applies specific authentication logic. Two common mechanisms are key-based authentication, which involves API keys, and basic authentication, which uses user credentials like usernames and passwords.

Key-Based Authentication: This mechanism requires clients to include a secret key in their requests, enabling servers to verify the client's identity. It's often used in scenarios where non-user-based identification is needed, such as in API access for applications or services.

Basic Authentication: On the other hand, basic authentication is a simpler approach where users provide a username and password to access resources. It's straightforward but doesn't offer the strongest security, especially if used without encryption, since credentials are sent in base64 encoded format (not encrypted).

Why Use Two Authentication Methods?

Imagine you have:

• An API that external systems access using an API key.
• Endpoints for users to log in with a username and password.

Instead of picking one method, why not use both? ASP.NET Core 9 supports multiple authentication schemes, so you can cater to diverse needs seamlessly.

Getting Started

First, set up an ASP.NET Core 9 project. If you already have one, feel free to skip this part. Otherwise:

1. Open a terminal or Visual Studio.
2. Create a new web API project: dotnet new webapi -n MultiAuthDemo
3. Move to the project folder: cd MultiAuthDemo

Step 1: Configure Authentication in Program.cs

In ASP.NET Core, the magic starts in Program.cs. Here, we'll register the two authentication schemes: Key-Based and Basic Authentication. Add the following code:

using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

// Add authentication services
builder.Services.AddAuthentication()
    .AddScheme<KeyAuthenticationOptions, 
         KeyAuthenticationHandler>("KeyAuthentication", null)

    .AddScheme<BasicAuthenticationOptions, 
         BasicAuthenticationHandler>("BasicAuthentication", null);

// Configure authorization policies
builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("KeyPolicy", policy =>
        policy.AddAuthenticationSchemes("KeyAuthentication").RequireAuthenticatedUser());
    options.AddPolicy("BasicPolicy", policy =>
        policy.AddAuthenticationSchemes("BasicAuthentication").RequireAuthenticatedUser());
});

// Add controllers
builder.Services.AddControllers();

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllers();

app.Run();

Step 2: Key-Based Authentication

Key-Based Authentication requires clients to include a valid API key in the request header. Let's implement it step by step.

Create Options for API Key

using Microsoft.AspNetCore.Authentication;

public class KeyAuthenticationOptions : AuthenticationSchemeOptions
{
    public string ApiKey { get; set; } = "SuperSecretKey123";
}

Create the Authentication Handler

using Microsoft.AspNetCore.Authentication;
using Microsoft.Extensions.Options;
using System.Security.Claims;

public class KeyAuthenticationHandler : AuthenticationHandler<KeyAuthenticationOptions>
{
    public KeyAuthenticationHandler(
        IOptionsMonitor<KeyAuthenticationOptions> options,
        ILoggerFactory logger,
        System.Text.Encodings.Web.UrlEncoder encoder,
        ISystemClock clock)
        : base(options, logger, encoder, clock) { }

    protected override Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        if (!Request.Headers.TryGetValue("X-Api-Key", out var apiKey))
        {
            return Task.FromResult(AuthenticateResult.Fail("API Key not found."));
        }

        if (apiKey != Options.ApiKey)
        {
            return Task.FromResult(AuthenticateResult.Fail("Invalid API Key."));
        }

        var claims = new[] { new Claim(ClaimTypes.Name, "ApiClient") };
        var identity = new ClaimsIdentity(claims, Scheme.Name);
        var principal = new ClaimsPrincipal(identity);
        var ticket = new AuthenticationTicket(principal, Scheme.Name);

        return Task.FromResult(AuthenticateResult.Success(ticket));
    }
}

Step 3: Basic Authentication

Now let's move to Basic Authentication. Here, clients send a username and password encoded in Base64.

Create Basic Options

using Microsoft.AspNetCore.Authentication;

public class BasicAuthenticationOptions : AuthenticationSchemeOptions
{
}

Create the Authentication Handler

using Microsoft.AspNetCore.Authentication;
using System.Security.Claims;
using System.Text;

public class BasicAuthenticationHandler : AuthenticationHandler<BasicAuthenticationOptions>
{
    public BasicAuthenticationHandler(
        IOptionsMonitor<BasicAuthenticationOptions> options,
        ILoggerFactory logger,
        System.Text.Encodings.Web.UrlEncoder encoder,
        ISystemClock clock)
        : base(options, logger, encoder, clock) { }

    protected override Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        if (!Request.Headers.ContainsKey("Authorization"))
        {
            return Task.FromResult(AuthenticateResult.Fail("Authorization header is missing."));
        }

        var authHeader = Request.Headers["Authorization"].ToString();

        if (!authHeader.StartsWith("Basic ", StringComparison.OrdinalIgnoreCase))
        {
            return Task.FromResult(AuthenticateResult.Fail("Invalid Authorization header."));
        }

        var encodedCredentials = authHeader.Substring("Basic ".Length).Trim();
        var decodedBytes = Convert.FromBase64String(encodedCredentials);
        var credentials = Encoding.UTF8.GetString(decodedBytes).Split(':', 2);

        if (credentials.Length != 2 || credentials[0] != "testuser" || credentials[1] != "password123")
        {
            return Task.FromResult(AuthenticateResult.Fail("Invalid username or password."));
        }

        var claims = new[] { new Claim(ClaimTypes.Name, credentials[0]) };
        var identity = new ClaimsIdentity(claims, Scheme.Name);
        var principal = new ClaimsPrincipal(identity);
        var ticket = new AuthenticationTicket(principal, Scheme.Name);

        return Task.FromResult(AuthenticateResult.Success(ticket));
    }
}

Step 4: Create Secured Endpoints

Finally, let's set up API endpoints to test both authentication methods.

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api")]
public class ApiController : ControllerBase
{
    [HttpGet("key-secure")]
    [Authorize(Policy = "KeyPolicy")]
    public IActionResult SecureWithKey()
    {
        return Ok(new { Message = "You accessed this using an API Key!" });
    }

    [HttpGet("basic-secure")]
    [Authorize(Policy = "BasicPolicy")]
    public IActionResult SecureWithBasic()
    {
        return Ok(new { Message = "You accessed this using Basic Authentication!" });
    }
}

Step 5: Testing with Postman

For API Key Authentication

1. Open Postman and create a GET request to: https://localhost:5001/api/key-secure
2. Under the Headers tab, add:
   • Key: X-Api-Key
   • Value: SuperSecretKey123
3. Hit Send.

Response: { "message": "You accessed this using an API Key!" }

For Basic Authentication

1. Create another GET request to: https://localhost:5001/api/basic-secure
2. Under the Authorization tab, select Basic Auth and fill in:
   • Username: testuser
   • Password: password123
3. Hit Send.

Response: { "message": "You accessed this using Basic Authentication!" }

Wrapping Up

And that's it! You now have an ASP.NET Core 9 project with both Key-Based and Basic Authentication running side by side. With just a few tweaks, you can customize this setup to fit your application's needs.

Keep coding and stay secure! 🚀

The Reality Behind the Code

While software development seems like a creative profession, much of the work involves tedious debugging and maintaining existing systems. The pressure of tight deadlines can blur the lines between work and personal life, leading to sacrifices in personal time and relationships. Additionally, isolation from minimal interaction with colleagues can contribute to loneliness and mental health challenges.

Developers must continuously learn to keep up with evolving technologies, often at the cost of personal time and hobbies. Long hours and strict deadlines strain work-life balance, resulting in stress and burnout. Prioritizing self-care is crucial to maintaining long-term well-being in this demanding field.

You might not think that programmers are artists, but programming is an extremely creative profession. It's logic-based creativity. – John Romero

Lifelong Learning is Essential

To succeed, software developers need a mindset of lifelong learning. Staying updated with industry trends equips them with the necessary skills to remain relevant and opens up new opportunities. Resources like online courses and industry conferences are essential for ongoing education.

Handling Constant Pressure

Effective time management and communication are key to handling constant pressure. Setting realistic goals and maintaining collaboration within teams can help minimize misunderstandings and enhance productivity.

The Power of Collaboration

Collaboration is vital in software development. Working together allows for diverse skills and perspectives, leading to innovative solutions. Effective teamwork fosters a supportive environment and improves overall efficiency.

Maintaining Work-Life Balance

Maintaining a healthy work-life balance is essential for personal well-being. Developers must prioritize relaxation and set boundaries to avoid burnout. Recognizing signs of stress and implementing coping strategies are crucial for sustaining mental health.

Conclusion

Being a software developer is challenging yet rewarding. It requires dedication, resilience, and the ability to find balance between professional and personal life. By acknowledging the challenges and prioritizing self-care, developers can thrive in this impactful field. Thank you for joining this journey, and may the insights shared empower you to navigate the realities of software development with confidence.

☕ Programmer: A machine that turns coffee into code !!!

1. Native Support for Blazor Hybrid Apps

With ASP.NET Core 9, Blazor apps can now seamlessly integrate with native desktop and mobile platforms. This feature allows developers to share UI components across web and native platforms.

Example: Blazor Component for Both Web and Native

<h1>Hello, Blazor Hybrid!</h1>
<p>This component works on both web and native platforms.</p>

To use this component in a hybrid app:

• Add it to a .razor file in your project.
• Use it in a web or native application via the same Razor syntax.

2. Improved Minimal APIs

Minimal APIs have been further enhanced in ASP.NET Core 9, making it easier than ever to build lightweight services.

Example: Minimal API with OpenAPI Documentation

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/api/hello", () => Results.Ok("Hello, World!"))
   .WithName("GetHello")
   .WithOpenApi(); // Automatically generates OpenAPI documentation

app.Run();

Now, by running your app, OpenAPI documentation will be generated and available at /swagger.

3. Enhanced Middleware Pipelines

Middleware is at the heart of ASP.NET Core, and the latest version provides more flexibility, including middleware chaining with better error handling.

Example: Conditional Middleware Execution

app.Use(async (context, next) =>
{
    if (context.Request.Path == "/admin")
    {
        await context.Response.WriteAsync("Admin Access Only");
    }
    else
    {
        await next();
    }
});
app.MapGet("/", () => "Welcome to ASP.NET Core 9!");

4. Performance Improvements with Native AOT

ASP.NET Core 9 introduces Native Ahead-Of-Time (AOT) compilation, which dramatically improves the performance of your apps by precompiling them into optimized machine code.

Example: Enabling Native AOT

In your project file:

<PropertyGroup>
  <PublishAot>true</PublishAot>
</PropertyGroup>

Publish your app using:

dotnet publish -c Release

5. SignalR Enhancements

SignalR has received updates for better real-time communication, including reduced latency and extended protocol support.

Example: Simple SignalR Setup

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapHub<ChatHub>("/chat");

public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

app.Run();

On the client side, use JavaScript or .NET to connect to /chat.

6. Cross-Origin Resource Sharing (CORS) Improvements

CORS is more configurable in ASP.NET Core 9, allowing granular control over cross-origin requests.

Example: Configuring CORS

builder.Services.AddCors(options =>
{
    options.AddPolicy("AllowSpecificOrigin",
        builder => builder.WithOrigins("https://example.com")
                          .AllowAnyMethod()
                          .AllowAnyHeader());
});

app.UseCors("AllowSpecificOrigin");
app.MapGet("/", () => "CORS Configured!");

7. Modernized Dependency Injection

ASP.NET Core 9 introduces better ways to register and resolve services, including dynamic service providers.

Example: Registering Services

builder.Services.AddSingleton<IMyService, MyService>();

public interface IMyService
{
    string GetData();
}

public class MyService : IMyService
{
    public string GetData() => "Hello from MyService!";
}

app.MapGet("/service", (IMyService service) => service.GetData());

Conclusion

ASP.NET Core 9 continues to set the benchmark for web development frameworks by combining performance, simplicity, and versatility. Whether you're building a simple API or a complex hybrid application, these features enable you to deliver high-quality solutions efficiently.

What are Minimal APIs?

Minimal APIs simplify the process of building HTTP APIs by reducing boilerplate code. They leverage the flexibility of ASP.NET Core's middleware pipeline and focus on defining endpoints using simple and intuitive syntax.

Features of Minimal APIs

1. Concise Syntax: Define endpoints in a few lines of code.
2. Integrated Dependency Injection (DI): Seamlessly access services.
3. Built-in OpenAPI Support: Auto-generate Swagger documentation.
4. High Performance: Lower overhead compared to MVC.
5. Customizable Middleware: Fine-grained control over request/response processing.

Minimal API Example

Here's how to build a simple CRUD API using Minimal APIs in ASP.NET Core 9:

Step 1: Setting Up a Simple API

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// In-memory data store
var products = new List<Product>();

app.MapGet("/products", () => Results.Ok(products))
   .WithName("GetAllProducts")
   .WithOpenApi();

app.MapGet("/products/{id}", (int id) =>
{
    var product = products.FirstOrDefault(p => p.Id == id);
    return product is not null ? Results.Ok(product) : Results.NotFound();
}).WithName("GetProductById");

app.MapPost("/products", (Product product) =>
{
    products.Add(product);
    return Results.Created($"/products/{product.Id}", product);
}).WithName("CreateProduct");

app.MapPut("/products/{id}", (int id, Product updatedProduct) =>
{
    var product = products.FirstOrDefault(p => p.Id == id);
    if (product is null) return Results.NotFound();

    product.Name = updatedProduct.Name;
    product.Price = updatedProduct.Price;
    return Results.Ok(product);
}).WithName("UpdateProduct");

app.MapDelete("/products/{id}", (int id) =>
{
    var product = products.FirstOrDefault(p => p.Id == id);
    if (product is null) return Results.NotFound();

    products.Remove(product);
    return Results.NoContent();
}).WithName("DeleteProduct");

app.Run();

public record Product(int Id, string Name, decimal Price);

Benefits Over MVC

Benefits of Minimal APIs

1. Reduced Boilerplate: Less code to maintain.
2. Improved Developer Productivity: Quick to set up and deploy.
3. High Performance: Direct routing and middleware execution reduce processing time.
4. Easy Learning Curve: Simple for new developers to understand.
5. Versatility: Suitable for microservices, server-less functions, and lightweight APIs.

Market Adoption

Minimal APIs have gained traction, particularly in scenarios where rapid development and scalability are essential, such as:

1. Microservices Architecture: Ideal for creating small, independently deployable services.
2. Serverless Computing: Works seamlessly with platforms like Azure Functions and AWS Lambda.
3. Startups and Prototypes: Great for MVPs and proof-of-concept applications.

Performance Comparison: Minimal API vs MVC

Below is a comparison chart based on typical benchmarking scenarios:

Conclusion

Minimal APIs in ASP.NET Core 9 represent a paradigm shift for building lightweight, high-performance APIs. With features like integrated OpenAPI support, dependency injection, and streamlined syntax, they are poised to play a crucial role in modern web development. While MVC remains a powerful tool for complex applications, Minimal APIs shine in scenarios requiring simplicity, speed, and efficiency.

By leveraging Minimal APIs, developers can focus on delivering value faster, making it a must-have skill in your development toolkit.

1. Meaningful and Consistent Naming Conventions

One of the fundamental principles of writing clean code is to use meaningful names for variables, functions, classes, and other entities. Ensure that your code follows a consistent naming convention (e.g., camel case or Pascal case) throughout the project. Meaningful names make code more readable, self-documenting, and provide context to fellow developers. Consistency is an essential aspect of clean code. Adopt a consistent naming convention for variables, functions, and classes. Use descriptive names that convey their purpose, making it easier for others to understand and maintain the code.

// Example of meaningful variable names
int studentAge = 20;
string studentName = "John Doe";

// Example of meaningful function names
public bool IsAdult(int age)
{
    return age >= 18;
}

2. Proper Indentation and Formatting

Consistent indentation and code formatting greatly enhance code readability. Use proper spacing and line breaks to organize your code logically. Avoid long lines of code and wrap them to fit within a reasonable length (80-120 characters) for better legibility.

// Example of properly indented and formatted code
public void CalculateSum(int a, int b)
{
    int sum = a + b;
    
    Console.WriteLine("The sum of {0} and {1} is {2}", a, b, sum);
}

3. Maintain Short and Focused Methods

To promote code readability and reusability, keep your methods short, focused, and following the Single Responsibility Principle (SRP). Each method should have a clear purpose and do only one thing. Breaking down complex logic into smaller, modular methods not only aids comprehension but also simplifies testing and debugging. Divide your code into smaller, more manageable modules that each have a single responsibility. This approach allowing for code reuse, easier testing, and improved readability. Avoid long and monolithic functions or classes that become hard to comprehend and maintain.

// Example of breaking down complex logic into smaller methods
public int CalculateSum(int a, int b)
{
    return a + b;
}

public void DisplaySum(int sum)
{
    Console.WriteLine("The sum is: " + sum);
}

// Usage
int result = CalculateSum(3, 4);
DisplaySum(result);

4. Effective Error Handling

Clean code should handle errors gracefully and provide helpful messages for debugging and troubleshooting. Utilize exception handling techniques such as try-catch-finally blocks to catch and handle exceptions appropriately. Avoid using broad catch-all exceptions; instead, catch specific exceptions that you can handle explicitly.

// Example of proper error handling
try
{
    int[] numbers = new int[] { 1, 2, 3 };
    int result = numbers[4]; // accessing an out-of-bounds index
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}

5. Optimize Code for Performance

Clean code also means optimizing performance by reducing unnecessary computations, memory usage, and improving code efficiency. Utilize built-in data structures and algorithms whenever possible and avoid reinventing the wheel.

// Example of using built-in C# features for efficient code
List<int> numbers = new List<int>() { 1, 2, 3 };

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

6. Minimize Dependencies

Reduce coupling and dependencies between different parts of your code. Code that is tightly coupled becomes challenging to understand and maintain. Use dependency injection and interfaces to decouple components, promoting code reuse and testability.

7. Code Refactoring and Simplicity

Refactor your code frequently to eliminate duplication, improve performance, and simplify the implementation. Don't be afraid to rewrite and optimize code if necessary. Simplicity should always be prioritized over complexity to enhance readability.

Conclusion

Writing clean code in C# goes beyond adhering to a set of guidelines. It requires a mindset that prioritizes readability, error handling, and code optimization. By following best practices, using meaningful naming conventions, maintaining proper indentation, and employing efficient error handling, you can ensure your code is clean, easy to understand, and performs optimally. Remember, clean code benefits not only you but also the other developers who work on the project. So, strive for clean code and become a better programmer.

1. Discover Inspiration in Your Daily Routines

One of the easiest ways to find inspiration for your blog is to observe and reflect on your daily life. Every day presents countless moments that can spark an idea for a blog post. Whether it's a challenging problem you solved at work, an interesting conversation with a friend, or even a thought-provoking question that crossed your mind, these everyday experiences are goldmines for content creation.

Keep a notepad or use your phone's notes app to jot down ideas as they come to you throughout the day. These raw notes can later be transformed into comprehensive blog posts. By paying attention to your surroundings and the experiences you encounter, you'll find that inspiration is everywhere.

2. Show Your Unique Perspective

What sets your blog apart from thousands of others is your unique perspective and voice. Don't be afraid to share your personal viewpoint on topics you're passionate about. Your audience doesn't just want information; they want to understand how you think and what you believe. By infusing your personal perspective into your writing, you create a deeper connection with your readers.

Discuss your journey, the lessons you've learned, and the challenges you've overcome. Share your failures as well as your successes. This authenticity builds trust and makes your content more relatable and engaging.

3. Embrace Your Authenticity

Authenticity is key to building a loyal audience. Write about what genuinely interests and excites you. Don't force yourself to write about topics just because they're trending if they don't align with your passions. Your enthusiasm will shine through your writing and attract readers who share similar interests.

Remember, your blog is your platform. Use it to express yourself authentically and connect with like-minded individuals. When you're passionate about what you're writing, it becomes evident in the quality and depth of your content.

4. Track Your Progress and Growth

Blogging is not just about sharing knowledge; it's also about personal growth and development. Reflect on how your thoughts, skills, and understanding have evolved over time. Document your learning journey and share the milestones you've achieved. This not only provides valuable content for your blog but also allows you to track your own progress.

Write posts that highlight challenges you faced and how you overcame them. Share the tools, techniques, and resources that have helped you grow. Your journey of growth can inspire others facing similar challenges.

5. Explore Ideas Deeply

When you find a topic that interests you, don't settle for surface-level content. Dive deeper and explore multiple angles and perspectives. Ask yourself questions like "Why does this matter?" or "What can others learn from this?" Thorough exploration of topics demonstrates your expertise and provides readers with valuable insights.

Write a series of posts on a single topic from different viewpoints. This allows you to comprehensively cover a subject while maintaining reader engagement over time.

6. Build a Community Around Your Passions

Blogging is not a solitary activity. Engage with other bloggers and readers who share your interests. Participate in discussions, comment on other blogs, and respond to comments on your own blog. This community engagement can spark new ideas and provide fresh perspectives that might inspire your next blog post.

Follow industry leaders, join relevant online communities, and attend conferences or webinars related to your passions. These interactions often lead to new insights that can be transformed into compelling blog content.

7. Inspire and Motivate Others

One of the most rewarding aspects of blogging is the ability to inspire and motivate others. Share stories of how your work or insights have made a positive impact. Write about the lessons you've learned and how others can benefit from your experience. By positioning yourself as a helpful resource, you create meaningful content that adds value to your readers' lives.

Encourage your audience to share their stories and experiences in the comments section. This creates a dialogue and fosters a sense of community around your blog.

Final Thoughts

Finding inspiration for your blog doesn't require extraordinary circumstances. By staying observant, embracing authenticity, and diving deep into topics you're passionate about, you'll discover that creativity flourishes in everyday moments. Remember, the most compelling blogs are those that come from the heart and reflect the author's genuine passion and expertise.

Start small, be consistent, and let your passion guide your writing. Over time, you'll build a collection of posts that not only showcase your knowledge but also inspire and engage your audience. So, grab that notepad, observe the world around you, and start blogging your passions today. Your unique voice and perspective are exactly what the world needs to hear!

Happy blogging! 🌟

So, you've heard about Artificial Intelligence (AI), right? It's that fancy buzzword everyone's been throwing around like it's the new avocado toast. But what's all the fuss about, really? Let's dive into why AI is not just another fad, but actually your future BFF (Best Friend Forever).

The AI Hype Train: All Aboard!

Remember when smartphones were new and we couldn't stop poking at screens? Well, AI is like that, but on digital steroids. It's already driving cars, diagnosing diseases, and yes, even helping you choose the next binge-worthy show on Netflix. Imagine having a personal assistant who never sleeps, never gets grumpy, and actually loves organizing your life. Sounds dreamy, right?

AI at Home: Not Just for Sci-Fi Movies

Picture this: You wake up to the smell of freshly brewed coffee, thanks to your AI-powered coffee maker. Your AI butler, let's call him "Jarvis" (because why not), has already adjusted the room temperature to your liking and played your favorite morning jam. And the best part? You didn't have to lift a finger.

Oh, and let's not forget the AI vacuum cleaner that's not just sucking up dust but also your existential dread of cleaning.

Work: The AI Co-Worker Who's Never Late

Say goodbye to the days of stressing over spreadsheets. Your new AI co-worker handles data entry faster than you can say "Ctrl + C, Ctrl + V." It's like having an office buddy who doesn't steal your lunch from the fridge. Plus, AI can help you brainstorm, draft emails, and even schedule meetings – all while you get to focus on the fun stuff, like coming up with the next big idea (or just sipping coffee in peace).

AI in Healthcare: Because Dr. Google Needs an Upgrade

We've all been there: a quick search about a headache on Google, and suddenly you're convinced you have a rare tropical disease. With AI, you can actually get accurate health insights without the unnecessary panic. AI systems can analyze medical data, predict potential health issues, and even assist in surgeries. It's like having a doctor who's always on call and never prescribes you WebMD-induced anxiety.

The Future: AI's Crystal Ball

Now, let's peek into the future. AI could be the driving force behind flying cars, smart cities, and maybe even those cool hologram calls we've been promised since forever. Imagine a world where traffic jams are a thing of the past because AI manages the roads, or where your fridge restocks itself because it knows you've run out of milk. It's not just sci-fi anymore; it's the future we're speeding towards.

But Wait, There's More: The Fun Stuff!

Ever wished you had more time to binge-watch cat videos or scroll through memes? With AI taking over the mundane tasks, you'll have more free time for the important things in life. Plus, AI can even help you discover new hobbies or connect with people who share your quirky interests.

So, there you have it – AI isn't just about robots and algorithms; it's about making life easier, more fun, and a whole lot smarter. Embrace the AI revolution, and who knows, you might just find your new best friend in a machine.

Until next time, keep calm and let AI handle it!

Transport Layer Security (TLS) is an industry security standard to help protect data transmitted over the internet. The newest version of TLS, 1.2 provides enhanced security and it is the current standard.

.NET Framework & TLS

The .NET framework uses common language runtime, used as an execution engine and class library providing reusable code. Older versions of .NET do not support the newer TLS 1.2 so it is recommended to also upgrade .NET to at least 4.5 if you are using an older version of Windows. The .NET 4.5 supports TLS 1.2 but it is not the default protocol so you need to opt-in to use the latest TLS 1.2.

Forcing a Secure Website and Web API to Use TLS 1.2

With the recent upgrade of TLS 1.0 and 1.1 to TLS 1.2, older TLS 1.0 and TLS 1.1 are now deprecated. So, you have to force your websites and services to run over TLS 1.2.

The Problem

You might get the below error due to TLS upgrade. The latest browsers by default will make a call to service (API) using TLS1.2 and your API will not accept the request with the new TLS version. So to fix this issue you have to force your API to accept the request with new TLS 1.2 version.

Error:

GET - An unhandled exception occurred. 
System.InvalidOperationException: An error occurred while processing this request.
--->
Microsoft.OData.Client.DataServiceTransportException: The underlying connection was closed: 
An unexpected error occurred on a send. 
--->
System.Net.WebException: The underlying connection was closed: 
An unexpected error occurred on a send. 
--->
System.IO.IOException: Unable to read data from the transport connection: 
An existing connection was forcibly closed by the remote host. 
--->
System.Net.Sockets.SocketException: An existing connection was forcibly closed by the remote host

The Solution

To fix this issue, add the following lines to your global.asax file:

protected void Application_Start()  
{  
     ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls 
                | SecurityProtocolType.Tls11 
                | SecurityProtocolType.Tls12;  
}

This configuration tells your application to support TLS 1.0, 1.1, and 1.2, ensuring compatibility with modern browsers and services that require TLS 1.2.

Best Practice

While supporting multiple TLS versions maintains backward compatibility, it's recommended to eventually deprecate older versions and move exclusively to TLS 1.2 or higher for enhanced security. Make sure your infrastructure, clients, and servers are all aligned on the latest TLS versions to maintain the highest security standards.