Swift

The RustPdf package wraps the rust-pdf core with idiomatic, handle-owning classes. It covers the whole product surface: vector graphics, embedded/subset fonts & Unicode text, paragraphs, images, PDF/A (1b–3a + A-4/4e/4f), tagged/accessible output, attachments, AcroForm fields, manipulation, text extraction, encryption and digital signatures. It ships as a SwiftPM package with a static xcframework, so it links into macOS and iOS apps with nothing to bundle alongside.

Download

The binding ships as a SwiftPM package with a prebuilt, static RustPdfFFI.xcframework (macOS universal + iOS device + iOS simulator slices). Two artifacts are published per release: the self-contained package (sources + xcframework, consumed via a local path) and the standalone xcframework (consumed by URL). Basic PDF generation works immediately as a free trial; the corporate features unlock with a license token.

Prefer the URL route? The standalone RustPdfFFI-0.4.2.xcframework.zip (.sha256) is referenced directly from a .binaryTarget(url:checksum:) (see Installation). Building from source? make swift-dist assembles the same artifacts.

Installation

The native library is linked statically inside the xcframework, so it works inside an iOS app bundle with no sidecar library and nothing to dlopen. Add the binding to your Package.swift one of two ways.

A. Local package. Unzip rustpdf-swift-0.4.2.zip and depend on it by path:

// Package.swift
dependencies: [
    .package(path: "path/to/RustPdf")
],
targets: [
    .executableTarget(name: "MyApp", dependencies: [
        .product(name: "RustPdf", package: "RustPdf")
    ])
]

B. URL-hosted xcframework. Reference the published xcframework directly; SwiftPM downloads and verifies it:

// In your Package.swift targets:
.binaryTarget(
    name: "CRustPdf",
    url: "https://rustpdf.dev/downloads/RustPdfFFI-0.4.2.xcframework.zip",
    checksum: "c9521f119a14e0ee3c60241b8cdfe691fddb7a68556c6aa9e78cbd3cc4a31108"
),
.target(
    name: "RustPdf",
    dependencies: ["CRustPdf"],
    // the static Rust library links libiconv (its only non-system dependency)
    linkerSettings: [.linkedLibrary("iconv")]
)

Import it and verify the version:

import RustPdf

print(Pdf.version)   // native library version, e.g. "0.4.0"

Quick start

A one-page document with a filled rectangle, saved to disk:

import RustPdf

let doc = try Document()            // A4 by default
try doc.addPage()
try doc.setFillRGB(0.86, 0.20, 0.18)
try doc.rect(x: 72, y: 640, width: 200, height: 120)   // points
try doc.fill()
try doc.save(to: "out.pdf")

Most mutators return self, so calls chain:

let doc = try Document()
let font = try doc.addFont(path: "Roboto-Regular.ttf")
try doc.addPage()
    .setFillRGB(0.1, 0.1, 0.12).rect(x: 0, y: 800, width: 595, height: 42).fill()
    .showText(font: font, size: 24, x: 72, y: 740, "Olá, açúcar — café")
let data: [UInt8] = try doc.toBytes()   // in-memory bytes instead of a file

Licensing & activation

Basic generation (everything above) is always free. The corporate features (PDF/A, digital signatures/PAdES, encryption, accessibility) require an active license token. Without one, those calls throw PdfError with status .license and produce no output.

Activation needs no rebuild. Easiest is an environment variable, auto-activated the first time a corporate feature is used:

export RUSTPDF_LICENSE="010f0000…"           # the token we email you
# or point at a file:
export RUSTPDF_LICENSE_FILE=/etc/rustpdf/license.txt

Or activate explicitly in code:

try Pdf.activateLicense(token)   // throws PdfError(.license) if forged / expired / malformed

Coordinate system

• Units are points (1 pt = 1/72 inch). A4 is 595 × 842, US Letter 612 × 792.
• The origin (0, 0) is the bottom-left corner; y grows upward.
• For text, (x, y) is the baseline of the first glyph.
• Drawing/text always targets the most recently added page.

Threading & concurrency

The core is Send but not Sync: you can build many documents in parallel, but a single handle must never be touched by two threads at once.

• Generate in parallel. Give each task its own Document/EditableDoc; independent documents share no state and run truly concurrently.
• Move between threads. A handle may be created on one thread and used on another.
• Never share a live handle. Two threads calling into the same Document at the same time is unsupported; serialize access if you really must.
• Errors are per-thread. The native last-error is thread-local, so a failure on one thread never clobbers another's, and PdfError is always thrown on the calling thread.
• License is process-global. Pdf.activateLicense (or the env var) applies to every thread; activate once at startup.

DispatchQueue.concurrentPerform(iterations: 8) { i in
    do {
        let doc = try Document()            // one document per task
        try doc.addPage()
            .setFillRGB(0.1, 0.1, 0.12).rect(x: 72, y: 700, width: 200, height: 80).fill()
        try doc.save(to: "out-\(i).pdf")
    } catch { print("render \(i) failed:", error) }
}

Authoring: create & save

Creates an empty document (A4 default page size). The native handle is released automatically when the Document is deallocated.

Pages & vector graphics

Graphics state and path operators mirror PDF's content-stream model. Colors are RGB in 0.0–1.0.

try doc.addPage()
try doc.setStrokeRGB(0.10, 0.45, 0.90).setLineWidth(3)
try doc.rect(x: 72, y: 600, width: 300, height: 160).stroke()
try doc.setFillRGB(0.95, 0.77, 0.06)
try doc.rect(x: 120, y: 640, width: 120, height: 80).fill()
try doc.save(to: "shapes.pdf")

Fonts & text

Fonts are embedded and subsetted, with HarfBuzz-quality shaping, kerning and full Unicode (Type0/CIDFontType2 with ToUnicode, so text extracts and copies correctly, provided the embedded font covers those characters). Register a font once, then reference it by its integer id.

headingLevel (1–6) tags the run as H1–H6 in an accessible document (see Accessibility); leave 0 for ordinary text.

let regular = try doc.addFont(path: "Roboto-Regular.ttf")
try doc.addPage()
try doc.showText(font: regular, size: 28, x: 72, y: 760, "Invoice #1024")
try doc.showText(font: regular, size: 12, x: 72, y: 720, "日本語 · Ελληνικά · العربية")
try doc.save(to: "text.pdf")

Paragraphs

The paragraph layer wraps, aligns and justifies text inside a fixed width (greedy line breaking using shaped glyph widths).

let intro = "A long paragraph that wraps to the given width and is justified " +
            "automatically; extra space is distributed between words."
let f = try doc.addFont(path: "Roboto-Regular.ttf")
try doc.addPage()
try doc.paragraph(font: f, size: 12, x: 72, y: 700, width: 451, text: intro, align: .justify)
try doc.save(to: "paragraph.pdf")

See the Align enum for the alignment options.

Images

JPEGs are embedded verbatim (DCTDecode, no re-encode). PNGs are decoded and re-encoded (FlateDecode); alpha becomes an /SMask, palette becomes an Indexed color space. Register an image once, draw it many times.

let logo = try doc.addImage(path: "logo.png")
try doc.addPage()
try doc.drawImage(logo, x: 72, y: 680, width: 160, height: 90)
try doc.save(to: "with_image.pdf")

PDF/A licensed

Produce archival-grade output. pdfa() defaults to A-2b; pass a PdfaLevel for a specific level. An embedded sRGB ICC profile, output intent, XMP metadata and document /ID are added automatically; A-1b also forces PDF 1.4 and emits a /CIDSet, and A-4 (ISO 19005-4) is based on PDF 2.0.

try doc.pdfa(.a2b).setInfo(DocumentInfo(title: "Q3 Report", author: "Acme Inc."))
let f = try doc.addFont(path: "Roboto-Regular.ttf")
try doc.addPage()
try doc.showText(font: f, size: 20, x: 72, y: 760, "Archival report")
try doc.save(to: "report_pdfa.pdf")   // throws without a license granting PDF/A

Accessibility (Tagged PDF / PDF/UA) licensed

tagged() builds a logical structure tree (PDF/UA-1). Combine with pdfa(.a2a) for archival and accessible output. Use headingLevel on showText for H1–H6, and figure(…, alt:) for described images.

try doc.pdfa(.a2a).tagged().setInfo(DocumentInfo(title: "Accessible report"))
let f = try doc.addFont(path: "Roboto-Regular.ttf")
try doc.addPage()
try doc.showText(font: f, size: 26, x: 72, y: 760, "Annual report", headingLevel: 1)   // H1
try doc.showText(font: f, size: 14, x: 72, y: 720, "Overview", headingLevel: 2)         // H2
try doc.showText(font: f, size: 11, x: 72, y: 690, "Body paragraph of the section…")
let chart = try doc.addImage(path: "chart.png")
try doc.figure(chart, x: 72, y: 520, width: 300, height: 150, alt: "Revenue grew 18% year over year")
try doc.save(to: "accessible.pdf")

Attachments (PDF/A-3) licensed

PDF/A-3 allows embedding arbitrary source files (e.g. the XML behind an e-invoice). Each attachment carries a MIME type and an AFRelationship.

let xml: [UInt8] = Array(invoiceXmlData)
try doc.pdfa(.a3b).setInfo(DocumentInfo(title: "E-invoice 1024"))
let f = try doc.addFont(path: "Roboto-Regular.ttf")
try doc.addPage()
try doc.showText(font: f, size: 18, x: 72, y: 760, "Invoice 1024")
try doc.attachFile(name: "invoice.xml", mime: "text/xml", data: xml,
                   relationship: .source, description: "Structured invoice data")
try doc.save(to: "einvoice.pdf")

ZUGFeRD / Factur-X e-invoices licensed

Turn the document into a ZUGFeRD / Factur-X electronic invoice: the embedded XML (the Cross-Industry Invoice) is attached as factur-x.xml, the file is marked PDF/A-3, and the Factur-X identification is written into the XMP metadata. The visible PDF is the human-readable invoice; the embedded XML is its machine-readable twin. Validates as PDF/A-3 + Factur-X under veraPDF.

let xml: [UInt8] = Array(crossIndustryInvoiceData)   // your Factur-X XML
try doc.setInfo(DocumentInfo(title: "Invoice INV-2026-001"))
let f = try doc.addFont(path: "Roboto-Regular.ttf")
try doc.addPage()
try doc.showText(font: f, size: 18, x: 72, y: 760, "Invoice INV-2026-001")
try doc.facturx(xml, profile: .en16931)
try doc.save(to: "einvoice.pdf")     // PDF/A-3 + Factur-X; needs a PDF/A license

See the FacturxProfile enum for the conformance levels (.minimum through .extended).

AcroForm fields

Build interactive forms with generated appearance streams (no NeedAppearances). Rectangles are tuples (x0, y0, x1, y1); page is a 0-based page index. Dotted names ("a.b.c") create hierarchical fields.

try doc.addPage()
try doc.textField(name: "applicant.name", page: 0, rect: (72, 700, 320, 720))
try doc.checkbox(name: "agree", page: 0, rect: (72, 660, 88, 676), checked: false)
try doc.dropdown(name: "plan", page: 0, rect: (72, 620, 240, 640),
                 options: ["Starter", "Pro", "Enterprise"], selected: 1)
try doc.radioGroup(name: "billing", page: 0, buttons: [
    RadioButton(rect: (72, 580, 88, 596),  export: "monthly"),
    RadioButton(rect: (140, 580, 156, 596), export: "annual"),
], selected: 1)
try doc.save(to: "form.pdf")

Fill and flatten fields later with EditableDoc.

Hyperlinks free

Add clickable link rectangles to the current page: a web link opens a URL; an internal link jumps to another page (optionally scrolling so a given top y-coordinate sits at the top of the view).

let f = try doc.addFont(path: "Roboto-Regular.ttf")
try doc.addPage()
try doc.showText(font: f, size: 14, x: 72, y: 760, "Visit rustpdf.dev (see page 2)")
try doc.linkURI(rect: (72, 756, 320, 776), uri: "https://rustpdf.dev/")   // web link
try doc.linkToPage(rect: (330, 756, 430, 776), pageIndex: 1, top: 800)    // jump to page 2
try doc.addPage()
try doc.save(to: "links.pdf")

Rectangles are tuples (x0, y0, x1, y1) in points; pageIndex is 0-based.

Bookmarks / outline free

Build a navigable document outline. A Bookmark has a title, a target page and an optional top; nest children with .child(_:). A document with bookmarks opens with the outline pane shown.

let f = try doc.addFont(path: "Roboto-Regular.ttf")
for _ in 0..<3 { try doc.addPage() }
try doc.addBookmark(
    Bookmark(title: "Chapter 1", page: 0, top: 820)
        .child(Bookmark(title: "Section 1.1", page: 1))
        .child(Bookmark(title: "Section 1.2", page: 2)))
try doc.addBookmark(Bookmark(title: "Chapter 2", page: 2))
try doc.save(to: "outline.pdf")

Metadata

Sets the document information dictionary (and, for PDF/A, the matching XMP). Every field of DocumentInfo is optional.

try doc.setInfo(DocumentInfo(
    title: "Q3 Report", author: "Acme Inc.",
    subject: "Quarterly results", keywords: "finance, q3"))

Manipulation: load an existing PDF

EditableDoc parses an existing document (classic & xref streams, object streams, all standard filters, RC4/AES decryption) into an editable model. Pages are a flat list; the page tree is rebuilt on output.

let bytes = [UInt8](try Data(contentsOf: URL(fileURLWithPath: "in.pdf")))
let ed = try EditableDoc(loading: bytes)
print(ed.pageCount)

// encrypted input:
let secured = try EditableDoc(loading: encryptedBytes, password: "user-or-owner-pw")
try secured.save(to: "plain.pdf")

Pages: merge, split, reorder, rotate

let a = try EditableDoc(loading: try read("a.pdf"))
let b = try EditableDoc(loading: try read("b.pdf"))
try a.merge(b)                  // a now has a's pages followed by b's
try a.rotatePage(0, degrees: 90)
try a.reorderPages([2, 1, 0])
try a.save(to: "merged.pdf")

Metadata, overlay & form fill

let ed = try EditableDoc(loading: try read("form.pdf"))
try ed.setInfo(key: "Title", value: "Filled form")
let found = try ed.fillTextField(name: "applicant.name", value: "Jane Doe")
print("filled:", found, "| title:", try ed.getInfo(key: "Title"))
try ed.save(to: "filled.pdf")

Form fill & flatten free

Fill the fields of an existing AcroForm and (optionally) flatten them: filling generates a fresh appearance stream (no NeedAppearances), and flattening bakes every widget's appearance into the page content and removes the interactive form entirely.

let ed = try EditableDoc(loading: try read("form.pdf"))
print(try ed.fieldNames())              // ["applicant.name", "agree", "plan", ...]
_ = try ed.fillTextField(name: "applicant.name", value: "Jane Doe")
_ = try ed.setCheckbox(name: "agree", checked: true)
_ = try ed.setRadio(name: "billing", exportValue: "annual")
_ = try ed.setChoice(name: "plan", value: "Pro")
try ed.flattenForms()                   // optional: make it non-editable
try ed.save(to: "filled.pdf")

Watermarks free

Stamp a diagonal text watermark or a centered image watermark across every page, drawn semi-transparently over the existing content. Text uses the standard Helvetica font, so keep it to WinAnsi (Latin-1) for stamps like "CONFIDENTIAL".

let ed = try EditableDoc(loading: try read("report.pdf"))
try ed.watermarkText("CONFIDENTIAL", opacity: 0.25, rotationDeg: 45)
try ed.save(to: "stamped.pdf")

Redaction licensed

True redaction: the text and graphics whose origin falls inside a rectangle are removed from the content stream (not just covered), so the data is gone from the file and is no longer extractable. Opaque black boxes are then painted over the regions.

let ed = try EditableDoc(loading: try read("statement.pdf"))
// rects = array of (x0, y0, x1, y1) tuples on that page
let ok = try ed.redact(0, rects: [(60, 590, 400, 620), (60, 540, 400, 570)])
try ed.save(to: "redacted.pdf")     // throws without a license granting redaction

Convert to PDF/A licensed

Convert an existing PDF to archival PDF/A (a basic profile: A-1b, A-2b or A-3b). An sRGB output intent, PDF/A XMP metadata (synced with /Info) and a document /ID are added. Fails if any font is not embedded (PDF/A requires every font embedded) or a level-A profile is requested.

let ed = try EditableDoc(loading: try read("in.pdf"))
try ed.convertToPdfa(.a2b)          // throws if fonts aren't embedded
try ed.save(to: "archival.pdf")     // veraPDF: PDF/A-2b compliant

Optimize & compact

let ed = try EditableDoc(loading: try read("big.pdf"))
try ed.optimize().compact(true)
try ed.save(to: "small.pdf")

Encryption licensed

Apply standard-handler encryption at output. AES-256 (V5/R6) uses OS-CSPRNG keys/IVs.

let ed = try EditableDoc(loading: try read("in.pdf"))
try ed.encrypt(method: .aes256, user: "", owner: "owner-secret", readOnly: true)
try ed.save(to: "secured.pdf")     // throws without an Encryption license

See the Encryption enum for RC4 / AES-128 / AES-256.

Output & incremental update

let original = try read("in.pdf")
let ed = try EditableDoc(loading: original)
try ed.setInfo(key: "Subject", value: "reviewed")
let incremental = try ed.toBytesIncremental(over: original)   // original bytes preserved verbatim

Digital signatures licensed

Sign a PDF with a PKCS#7 detached signature via an incremental update (the original bytes are preserved). Keys and certificates are passed as DER [UInt8]. pades: true switches to PAdES-B-B.

let pdf  = try read("contract.pdf")
let key  = try read("signer.pk8")    // PKCS#8 private key (DER)
let cert = try read("signer.der")    // X.509 certificate (DER)

let signed = try Pdf.sign(pdf: pdf, keyDER: key, certDER: cert,
    options: SignOptions(reason: "Approved", location: "New York",
                         name: "Jane Doe", pades: true))
// Verify in a shell: pdfsig contract.signed.pdf  →  "Signature is Valid."

Timestamp & DSS (PAdES LTV) licensed

Build long-term-validation signatures offline. addDss appends a Document Security Store (/DSS with certs/CRLs, PAdES-B-LT); timestamp appends an RFC 3161 document timestamp (/DocTimeStamp, PAdES-B-LTA).

// B-LT: embed validation material (caller supplies DER certs/CRLs)
let lt = try Pdf.addDss(pdf: signed, certs: [cert], crls: [crl])

// B-LTA: add a document timestamp signed by a TSA key/cert
let lta = try Pdf.timestamp(pdf: lt, tsaKeyDER: tsaKey, tsaCertDER: tsaCert)

Validate signatures licensed

Validate every signature in a PDF: each report recomputes the /ByteRange digest, parses the CMS, and checks that the cryptographic signature is valid, that the messageDigest matches the covered bytes, and whether the signature covers the whole document.

Each SignatureReport has fieldName, subFilter, signer, coversWholeDocument, digestValid, signatureValid, isValid and byteRange. Note that fieldName and signer are optional (String?) and nil when absent. An empty array means the document is unsigned. Signature validation is a licensed feature: this call requires an active license (signatures) even when the document is unsigned — it is not available on the free tier.

let data = try read("contract.signed.pdf")
for sig in try Pdf.verifySignatures(data) {
    print(sig.signer ?? "?", "valid:", sig.isValid,
          "covers whole doc:", sig.coversWholeDocument)
}

Text & image extraction

Extract a document's text, mapping shown glyph codes back to Unicode through each font's ToUnicode map, with space/line inference. Raster images can be pulled out too: JPEGs are written verbatim as .jpg, everything else as .png. The output directory is created automatically if it does not already exist.

let data = try read("report.pdf")
print(try Pdf.extractText(data))

let n = try Pdf.extractImagesToDir(data, "out_images/")   // returns how many were written
print("wrote \(n) image(s)")

Render a page to an image licensed

Rasterize a page to a PNG image. A native Rust renderer (built on tiny-skia, with no headless browser) interprets the page content stream, painting real glyph outlines, vector graphics, images, color and transparency. Page rendering is a Pro feature; page_count is free.

let data = [UInt8](try Data(contentsOf: URL(fileURLWithPath: "report.pdf")))
print("\(try Pdf.pageCount(data)) page(s)")
let png = try Pdf.renderPageToPng(data, page: 0, dpi: 150.0)
try Data(png).write(to: URL(fileURLWithPath: "page1.png"))

Enums

PdfaLevel

Align

AFRelationship

Encryption

FacturxProfile

Error handling

Every failing native call throws PdfError, carrying the status (a PdfStatus) and the library's last-error message. License failures (missing/expired/forged token, or a feature the token doesn't grant) surface here too. Token activation failures carry the dedicated license status code (12); a gated build, sign or encrypt call instead reports that operation’s own status (for example Serialize = 4 or Sign = 10) with the same “requires a valid license” message.

do {
    try doc.pdfa().setInfo(DocumentInfo(title: "x"))
    try doc.addPage()
    try doc.save(to: "out.pdf")
} catch let e as PdfError {
    print("failed:", e.message, "(status \(e.status))")   // e.g. .license
}

Utilities