DEV Community: Guillermo Contreras

How to generate a PDF report in .NET with zero dependencies

Guillermo Contreras — Sun, 12 Jul 2026 23:59:21 +0000

Generating a PDF invoice or report in .NET usually means a heavy dependency. Here's
how to do it with Matios.Pdf — a PDF engine that writes
the format (ISO 32000) itself, on the BCL alone. Zero dependencies, MIT.

Install

dotnet add package Matios.Pdf

A report with a header, footer and a paginating table

The high-level PdfFlow stacks blocks and paginates on its own — repeating the
header/footer and the table's header row across pages:

using Matios.Pdf;

using var doc = new PdfDocument();
var flow = new PdfFlow(doc, PdfPageSize.A4, margin: 56);

flow.Header(40, a => a.Graphics.DrawString("Report", PdfFont.HelveticaBold, 13, a.X, a.Y + 14));
flow.Footer(28, a => a.Graphics.DrawString(
    $"Page {a.PageNumber} of {a.TotalPages}", PdfFont.Helvetica, 9, a.X + a.Width, a.Y + 14, PdfTextAlign.Right));

flow.Paragraph("A justified paragraph that wraps to the column width and paginates "
    + "on its own.", PdfFont.Helvetica, 12, leading: 16, align: PdfTextAlign.Justify, spacingAfter: 10);

flow.Table(t =>
{
    t.ProportionalColumns(6, 1, 2, 2);
    t.Align(PdfTextAlign.Left, PdfTextAlign.Right, PdfTextAlign.Right, PdfTextAlign.Right);
    t.HeaderRow("Description", "Qty", "Unit", "Total");
    for (int i = 1; i <= 40; i++)                       // enough rows to span pages
        t.Row($"Line item {i}", "1", "12.50", (i * 12.5).ToString("F2"));
});

flow.Save("report.pdf");

Need pixel control instead? Drop to doc.Pages.Add(size).Graphics and draw text,
lines, rectangles, curves and images directly.

Full Unicode, embedded and subsetted

Embed a TrueType font and it's subsetted to just the glyphs you used — a ~1 MB
Arial becomes ~17 KB in the file, self-contained:

var font = PdfFont.FromFile(@"C:\Windows\Fonts\arial.ttf");
g.DrawString("Canción · €50 · ñandú · Ελληνικά · Русский", font, 14, 72, 160);

Read and encrypt too

using var doc = PdfDocument.Load("in.pdf");        // parse an existing PDF
int pages = doc.Pages.Count;

using var secured = new PdfDocument();
secured.Encrypt("pass");                           // AES-256
secured.Pages.Add(PdfPageSize.A4).Graphics
    .DrawString("Confidential", PdfFont.HelveticaBold, 18, 72, 100);
secured.Save("secured.pdf");

Every feature is verified by opening the output in real readers (pypdf, PIL,
FreeType), not just unit tests.

Docs, examples and benchmarks → pdf.matios.cl. Part of
a family of zero-dependency, MIT packages for .NET — matios.cl.

If you try it, I'd love your feedback — issues and stars welcome. 🙌

How to generate an Excel report in .NET with zero dependencies

Guillermo Contreras — Sat, 11 Jul 2026 13:53:20 +0000

You need to hand a user a real .xlsx file — styled, with a total that's actually
computed. Here's how, in .NET, with Matios.Spreadsheet —
an Office Open XML engine built only on the BCL. Zero dependencies, MIT.

Install

dotnet add package Matios.Spreadsheet

A styled report with a computed total

using Matios.Spreadsheet;
using Matios.Spreadsheet.Styling;

using var pkg = new SpreadsheetPackage();
var s = pkg.Workbook.Worksheets.Add("Sales");

// header row
s["A1"].Value = "Product";
s["B1"].Value = "Revenue";
foreach (var c in new[] { "A1", "B1" })
{
    s[c].Style.Font.Bold = true;
    s[c].Style.Font.Color = Colors.White;
    s[c].Style.Fill.BackgroundColor = Colors.Navy;
}

// data
s["A2"].Value = "Coffee"; s["B2"].Value = 1240;
s["A3"].Value = "Tea";    s["B3"].Value = 980;

// total — the formula is computed in memory, no Excel involved
s["A4"].Value = "Total";
s["B4"].Formula = "SUM(B2:B3)";
pkg.Calculate();
Console.WriteLine(s["B4"].Value);   // 2220

pkg.SaveAs("report.xlsx");

That's a valid .xlsx that opens clean in Excel — no "we found a problem /
repair" prompt. The built-in evaluator handles SUM, AVERAGE, IF, ROUND
and friends, so you get results without opening a spreadsheet app.

Big exports? Stream it

For hundreds of thousands of rows, the streaming path writes each row straight to
the archive and keeps memory flat:

using var wb = StreamingWorkbook.Create("big.xlsx");
var s = wb.AddSheet("Transactions");

for (int i = 1; i <= 1_000_000; i++)
    s.AddRow($"Product {i}", DateTime.Today.AddDays(i % 30), i * 100.0);

On a 1,000,000-cell workbook this is ~3.2× faster and uses ~3.2× less memory than
building the whole model in memory (~1.58M cells/s on my machine — relative,
hardware-dependent).

Read one back

using var loaded = SpreadsheetPackage.Load("report.xlsx");
var sheet = loaded.Workbook.Worksheets[0];

Console.WriteLine(sheet["A2"].Value);    // Coffee
Console.WriteLine(sheet["B4"].Formula);  // SUM(B2:B3)

There's more

Number formats, borders, charts, pivots, conditional formatting, data validation,
images, merged cells and round-trip (parts you didn't touch are preserved).

Docs, examples and benchmarks → spreadsheet.matios.cl.
It's one of a small family of zero-dependency, MIT packages for .NET — the rest at
matios.cl.

If you try it, I'd love your feedback — issues and stars welcome. 🙌

Encrypt your JWTs in .NET, not just sign them

Guillermo Contreras — Fri, 10 Jul 2026 01:51:52 +0000

A signed JWT (JWS) is tamper-proof, but it's not private — paste one into
jwt.io and you'll read every claim. If your token carries an email, a role or any
PII, you want it encrypted (JWE). Here's how, with
Matios.Security — dependency-free JOSE/JWT for
.NET, MIT.

Install

dotnet add package Matios.Security

First, a normal signed token (JWS)

using Matios.Security.Jose;
using Matios.Security.Jwt;

var signingKey = SymmetricJoseKey.FromBase64Url(signingKeyB64, "sig-2026");

string token = new JwtBuilder()
    .Issuer("my-platform")
    .Subject(userId)
    .Lifetime(TimeSpan.FromMinutes(30))
    .Claim("role", "admin")
    .SignWith(signingKey)
    .Create();

Integrity: ✅. Confidentiality: ❌ — the payload is just base64, readable by anyone
who intercepts it.

Now encrypt it — one extra line

Add .EncryptWith(...) and the same builder produces a Nested JWT (signed
inside, encrypted outside). The token becomes opaque — dir + A256GCM:

string token = new JwtBuilder()
    .Subject(userId)
    .Lifetime(TimeSpan.FromMinutes(30))
    .Claim("role", "admin")
    .Claim("email", "ana@acme.cl")
    .SignWith(signingKey)
    .EncryptWith(encryptionKey)      // ← now the claims are hidden
    .Create();

(Fun fact: Microsoft's own stack can't even issue a JWE with A256GCM — this
library does, cross-platform.)

Validate — strict by design

JwtClaims claims = JwtValidator.Validate(token, new JwtValidationParameters
{
    SigningKey    = signingKey,
    DecryptionKey = encryptionKey,   // set ⇒ a plain JWS is rejected (no downgrade)
    ValidIssuer   = "my-platform"
});

string role = claims.GetClaim<string>("role");

You declare the accepted alg/enc — no alg:"none", no algorithm confusion,
crit/zip rejected. Validation failures raise one generic error; the real reason
stays in a log-only failure code (anti-oracle).

Docs and examples → https://security.matios.cl. Part of a
family of zero-dependency, MIT packages for .NET — matios.cl.

If you try it, I'd love your feedback — issues and stars welcome. 🙌

I built five zero-dependency packages for .NET

Guillermo Contreras — Fri, 10 Jul 2026 01:42:08 +0000

For the last few months I've been building Matios — a small family of
open-source packages for .NET (and the web) that all share one rule:
zero dependencies.

Not "few dependencies." Zero. Each one is built only on the BCL — no third-party
packages, no transitive tree to audit, nothing that can change its license out
from under you. MIT, and small enough to read end to end.

Here's why, and what's in the family.

Why zero dependencies?

Every dependency you add is something you don't fully control: a supply-chain
surface, a transitive tree, a maintenance and licensing risk. For a lot of
everyday tasks — writing an Excel file, generating a PDF, dispatching a request —
I wanted a library I could drop in and forget, and read if I ever needed to.

So instead of wrapping an existing engine, each package writes the format (or
implements the pattern) itself, on the BCL alone. As a bonus, that makes them a
great fit for Native AOT and trimming, where every dependency is friction.

The family

📊 Matios.Spreadsheet — read, write and stream
.xlsx (Office Open XML) with its own engine: styling, formulas computed in
memory, charts, pivots, streaming.

📄 Matios.Pdf — generate, read and encrypt PDFs
(ISO 32000): embedded, subsetted Unicode fonts, vector graphics, images, and a
layout engine with flow and paginating tables.

🧩 Matios.Forge — a mediator for .NET with no
mandatory container (dispatch in ~15 ns, allocation-free), plus a set of building
blocks for Clean Architecture (specification, state machine, strategy, repository…).

🔒 Matios.Security — JOSE/JWT done strictly: it
issues JWE (encrypted tokens) that the official .NET stack can't, plus JWS and
Nested JWT.

🎨 Matios UI Framework — the web sibling:
UI in pure CSS and JavaScript, 85+ components, mode + accent theming, no build step.

Every one is MIT, tested and benchmarked — and, for the .NET ones, validated
against real readers (opening the .xlsx in Excel, the PDF in real viewers, and
so on) rather than just unit tests in isolation.

Try them

Each has its own page with the docs, examples, benchmarks and the install command
(plus NuGet and GitHub links):

Or start from matios.cl.

It's early, and it's open source. If any of these solve a problem for you, I'd
genuinely love your feedback — issues, stars, and "this broke on my file" reports
are all welcome. That's exactly how they get better.

I'll follow up with a short how-to for each one. Thanks for reading. 🙌