stirling.com

Stirling PDF is a free, private PDF editor that you can run on your own infrastructure. According to the project's site, it has passed 31 million downloads and is used by 75% of the Fortune 500. The core distinction from most PDF tools is where the work happens: Stirling runs on your machine or your servers, and its source code is public, so files don't have to be uploaded to a third-party website to be edited.

That makes it most relevant if you handle sensitive documents, need to process PDFs in bulk, or want PDF operations callable from your own systems. If you only occasionally edit a PDF and don't care where it's processed, a browser-based tool may be simpler.

What Stirling PDF does

The site groups its capabilities into three levels:

So the same product spans a single person annotating one file and a pipeline that ingests hundreds of documents unattended.

Why "private" and "open-source" matter here

The site's argument is direct: protect sensitive files from landing on websites you can't trust. Because Stirling's editor runs on your machine and the source is public, you can verify what the software does rather than taking a vendor's word for it. The page describes it as "private, open-source, and audit-ready," and notes it is validated by security experts.

If your constraint is a policy that documents cannot leave your network, self-hosting is the feature that decides the choice — not the tool count.

Automation and scale

For batch work, Stirling offers:

• Pipelines — chain operations into a single run, and process file batches programmatically.
• APIs & MCP — every PDF operation callable from your own systems; one request in, processed files out, with webhooks when it's done.
• Policies — your rules applied the moment a file arrives.
• Connectors — integration with tools your team already uses.

The example on the site shows a POST to /api/v1/pipelines/intake processing a zip of 412 PDFs. Typical pipeline steps listed include OCR on scanned pages, classification by type and sensitivity, signature validation, redaction, compression, and routing to a destination like SharePoint.

Two governance details are worth noting for regulated work: rule changes need approval, and every action is logged. The processor also reads scans, not just digital files.

The built-in assistant

For an open file, you can ask the assistant to make an edit in place — redact, translate, summarize, convert — while you watch. The site's example: a request to redact all account numbers returns "I made 14 redactions across 9 pages. Please review them in the canvas." The review step matters; the assistant proposes, you confirm.

Deployment and getting started

Stirling can run on any infrastructure, which is the point of the self-hosted model. The site offers a free trial and documentation, with pricing listed separately. Whether a paid tier is required for your use case depends on the plan details on the pricing page — the free editor and the scale-out processing features are presented as part of the same product, so check the pricing page before assuming a specific feature is included at no cost.

Choose Stirling PDF if you need PDF editing that stays on your own infrastructure, want to audit the code, or need to process PDFs in bulk through APIs and pipelines. Look elsewhere if you want a zero-setup web tool and have no requirements about where files are processed.

A PDF invoice in legal billing is a fixed-format document that presents the fees and costs owed on a matter in a layout that looks the same on every device. It is the digital equivalent of a printed bill: readable, portable, and easy to attach to an email or upload to a client portal. Its main limitation is that it is not machine-readable in the way a LEDES file is, so a client's e-billing system cannot automatically ingest it. PDF works best for flat-fee matters, small or one-off engagements, and clients who do not run an automated billing platform.

What "PDF" means in a legal billing context

When a billing tool offers to send an invoice "in PDF," it is generating a rendered document rather than a structured data file. The distinction matters:

• PDF is a presentation format. A human reads it. Line items, totals, and matter details appear as text and tables on a page.
• LEDES (Legal Electronic Data Exchange Standard) is a structured, delimited text format. An e-billing system parses it, validates it against outside counsel guidelines, and routes it for review.
• Email delivery is a transport method, not a format. You can email a PDF, email a LEDES file, or email a link to an online invoice.

These three are often confused because a single invoice can combine them: a LEDES file delivered by email, or a PDF attached to an email. The format is what the client's systems can read; the delivery method is how it arrives.

When a PDF invoice is the right choice

PDF is usually appropriate when the client does not require electronic submission through a billing platform. Common scenarios:

• Flat-fee and fixed-price matters. When the invoice is one or two lines, a structured file adds no value.
• Small businesses and individuals. Clients without an accounts payable system can open a PDF and pay from it.
• Retainers and replenishment requests. A simple statement of the retainer balance is easy to read as a PDF.
• Pro bono or courtesy bills. Where no formal e-billing review applies.
• Backup documentation. Even when a LEDES file is submitted, a PDF is often attached for the reviewer's convenience.

If the client has outside counsel guidelines requiring LEDES submission, a PDF alone will typically be rejected or returned for manual entry. Check the client's billing requirements before choosing the format.

PDF versus LEDES versus emailed invoice: a quick comparison

Core elements of a compliant legal PDF invoice

A PDF invoice should stand on its own. If a client's AP department picks it up with no context, it should still answer who, what, when, and how much.

Firm and client identification

• Firm name, address, and contact details
• Tax or VAT identification number where applicable
• Client name and billing contact
• Invoice number and invoice date
• Client matter number or reference

Matter and timekeeper detail

• Matter name and description
• For each timekeeper: name, initials, and billing rate
• Time entries with date, narrative description, and time recorded in tenths of an hour
• Clear separation of fee earners if rates differ

Fees, expenses, and totals

• Fees subtotal
• Disbursements and expenses, itemized with dates
• Taxes applied
• Prior payments, credits, or trust retainer applied
• Total amount due and currency

Payment terms

• Due date and payment window
• Accepted payment methods
• Remittance details or a payment link
• Late-payment terms if the engagement letter specifies them

A useful test: hand the PDF to someone who has never seen the matter and ask them to confirm the amount due and the period covered. If they hesitate, the invoice is missing something.

Practical limitations to plan around

PDF invoices shift work to the recipient. Someone at the client has to read the document and key the data into their system, which introduces delay and transcription errors. PDFs also cannot be validated against billing guidelines automatically, so a reviewer may reject a line item that a LEDES rule would have caught before submission.

Two habits reduce the friction:

1. Send a consistent template. Clients learn where to find the total, the matter number, and the payment terms.
2. Keep a LEDES version in reserve. If a client later adopts an e-billing platform, you can convert rather than rebuild.

Choosing between PDF, LEDES, and email delivery

Work from the client's requirements backward:

• Does the client mandate LEDES submission? If yes, PDF is a supplement, not a substitute.
• Is the matter flat-fee or very small? PDF is usually sufficient.
• Does the client have no billing system? PDF delivered by email or portal is the simplest path.
• Is the invoice complex with many timekeepers and expenses? A structured format reduces disputes, even if the client accepts PDF.

When in doubt, ask the client's billing contact which format they prefer and whether a PDF attachment is acceptable alongside any required file. That one question prevents most rejected invoices.

Easy Legal Billing supports sending or scheduling invoices in LEDES, email, or PDF formats, which lets you match the format to each client's requirements rather than forcing one approach across every matter.

An open-source UI element library is a collection of individual, ready-made interface pieces—buttons, cards, inputs, toggles, loaders—that you copy into your own project and adapt. A UI framework, by contrast, is a structured system of components, conventions, and often a theming layer that governs how your whole interface is built. The practical difference: an element library gives you a snippet; a framework gives you a way of working. If you need a polished button in ten minutes, reach for the element library. If you're building a 40-screen product with a team, you probably want the framework.

What "open-source UI element library" actually means

The term gets used loosely, so it helps to separate the parts:

• Open-source: the code is publicly available, and the license tells you what you may do with it—copy, modify, redistribute, or use commercially.
• UI element: a single, self-contained piece of interface, usually small enough to read in one sitting. A button with hover states, a pricing card, a search field.
• Library: a browsable, searchable collection of those elements, typically contributed by many different people.

On a site like Uiverse, elements are shared by a community and written in plain CSS or Tailwind. You find one you like, copy the markup and styles, paste them into your project, and adjust colors, spacing, and text to fit. There's no package to install and no build step required—which is exactly the appeal, and also the source of most of the confusion.

Element library vs. UI framework: the core differences

The table isn't a verdict. It's a map of trade-offs. Element libraries win on speed and freedom; frameworks win on consistency and maintenance.

Licensing and attribution: what to check before you paste

This is where people get into trouble, and it's worth slowing down for.

1. Find the license. Every element or collection should state one. Common open-source licenses include MIT, Apache-2.0, and BSD. Some projects use copyleft licenses like GPL, which can impose obligations if you redistribute your code.
2. Understand what the license permits. MIT and Apache-2.0 are permissive: you can typically use the code in commercial and closed-source projects. Copyleft licenses may require you to release derivative source under the same terms.
3. Check attribution requirements. Permissive licenses usually require you to keep the copyright notice and license text somewhere in your project. That's a real obligation, not a formality.
4. Look for per-element terms. On community sites, the site's overall terms and the individual contributor's stated wishes may differ. If a contributor asks for credit, honor it.
5. When in doubt, ask or avoid. If a snippet has no license at all, you don't have clear permission to reuse it. Treat "no license" as "not open source," even if the code is publicly visible.

This article is general information, not legal advice. For commercial products with real exposure, have someone qualified review the licenses you're relying on.

How to use a community element in your project: a practical workflow

Here's a repeatable process that avoids most of the usual mess.

1. Start from a real need, not a browsing session

Decide what you need first—"a compact primary button with a loading state"—then search. Browsing aimlessly produces a pile of pretty snippets that don't fit together.

2. Copy the smallest version that works

Take the markup and the styles. Strip anything you don't need: demo wrappers, extra animations, decorative layers. Less code means fewer surprises.

3. Convert it to your conventions

If your project uses design tokens or CSS variables, replace hard-coded values:

/* Before: hard-coded */
.button { background: #4f46e5; border-radius: 8px; }

/* After: token-based */
.button { background: var(--color-primary); border-radius: var(--radius-md); }

This one step is what keeps a copied element from looking like a foreign object in your UI.

4. Check accessibility before you ship

Community elements vary widely here. Verify at minimum:

• Keyboard focus is visible and the element is reachable by Tab.
• Color contrast meets WCAG AA (4.5:1 for normal text).
• Interactive elements use semantic HTML (<button>, not a clickable <div>).
• Form inputs have associated labels.
• Motion respects prefers-reduced-motion.

5. Test in context

Paste it into a real page with real content. Long labels, small screens, and dark mode break more copied elements than anything else.

6. Note where it came from

Keep a short comment or an internal credits file: source, license, date. Future you—and your legal reviewer—will be grateful.

Where element libraries genuinely shine

• Prototypes and demos: you need something clickable today, not a design system.
• Landing pages and marketing sites: a handful of distinctive elements, each custom.
• Filling gaps: your framework lacks one specific component, and you don't want to build it from scratch.
• Learning: reading well-made CSS is one of the fastest ways to improve.
• Small projects: a personal site doesn't need a theming architecture.

Where they fall short

• Consistency at scale: ten elements from ten contributors rarely look like one product.
• Maintenance: you own every copy. When your design changes, you edit each one.
• Accessibility debt: you inherit whatever the contributor did or didn't do.
• No upstream fixes: a bug fixed in the original won't reach your copy.
• Integration friction: different naming conventions, different units, different assumptions about resets.

When to choose which

Choose an element library when the scope is small, the timeline is short, or you need a few distinctive pieces rather than a whole system.

Choose a framework or design system when multiple people build multiple screens over months, when consistency is a product requirement, or when accessibility and theming need to be guaranteed rather than checked.

A hybrid works well for many teams: adopt a framework for the structural components—forms, navigation, layout—and borrow individual elements for the places where you want personality. Just route every borrowed element through the same token and accessibility checks, so it lands as part of your system rather than beside it.

The short version: open-source UI element libraries are a fast, flexible way to get good-looking interface pieces into a project. They are not a substitute for a design system, and the license and accessibility details are the part worth reading carefully.

The Stirling PDF AI assistant works on the file you currently have open: you ask for a change in plain language, and it makes the edit in place while you watch. According to Stirling's own product page, the assistant can "redact, translate, summarize, convert" the open document, and it shows its work in a review canvas rather than applying changes silently. That makes it a fit for quick, one-file tasks where you want to see each change before trusting it — not for unattended bulk processing, which is handled by a separate pipelines feature.

What the assistant can do on the open file

Stirling's page describes the assistant as operating on "the file you have open" and lists four example actions:

• Redact — hide sensitive details. The page's example shows a request to redact all account numbers, with the assistant reporting "14 redactions across 9 pages" and asking the user to review them in the canvas.
• Translate — convert the document's language.
• Summarize — produce a condensed version.
• Convert — change the file into another format.

The key mechanic is that the edit happens in place: the assistant modifies the open document rather than producing a separate output you have to reconcile. You stay in the same working context.

How the review step works

The account-number example is the clearest illustration of the intended workflow. The assistant doesn't just report success — it states how many changes it made and where, then directs you to the canvas to review them. So the practical loop is:

1. Open the PDF you want to work on.
2. Ask for the change in natural language (for example, "redact all of the account numbers").
3. The assistant performs the edit in place and reports what it changed.
4. You review the marked changes in the canvas before accepting them.

This matters for redaction in particular: because the assistant surfaces each redaction for review, you can catch a missed instance or an over-broad match before the file leaves your hands.

Where it fits, and where it doesn't

The assistant is a per-file, interactive tool. Stirling separates that from its batch capabilities:

If your goal is "classify, standardize and route thousands at once," the assistant isn't the mechanism — pipelines are. The assistant is for the document in front of you.

Why the privacy framing matters here

Stirling describes itself as "a free, private PDF editor you can run on any infrastructure," and states that the editor "runs on your machine, and the source is public so you can verify that instead of trusting it." For assistant-driven redaction, that's the relevant point: sensitive content is being identified and hidden, and Stirling's positioning is that this happens on infrastructure you control rather than on a third-party website. The page also notes that for the processor, "every action [is] logged" and "rule changes need approval" — governance features aimed at auditability.

Practical conditions to check before relying on it

• Confirm what "in place" means for your copy. The assistant edits the open file; make sure you're working on a copy if you need the original preserved.
• Review redactions, don't assume completeness. The example itself routes you to the canvas for review — treat that step as required, especially for account numbers, IDs, or names.
• Don't expect it to be the batch tool. For volume work, look at pipelines and the API instead.
• Check deployment fit. Stirling says it runs on any infrastructure; whether the assistant is available in your specific setup is worth verifying against your deployment and the docs.

For a single document where you want a visible, reviewable edit, the assistant is the direct path. For anything measured in hundreds or thousands of files, use the processing pipeline and reserve the assistant for spot checks.

Stirling PDF keeps files private by running the editor on your own machine or server instead of sending documents to a third-party website. The source code is public, so you can verify what the software does rather than trust a vendor's claim, and the product is described as audit-ready with every action logged. That combination makes it a reasonable fit when documents are sensitive or subject to compliance review — provided you are willing to host and maintain it yourself.

Where your files actually go

The core privacy claim is about location, not encryption features. Stirling's editor "runs on your machine," and the site frames this as protection from "sensitive files landing in websites you can't trust." In practice that means:

• Self-hosted or local execution. You run Stirling on your own infrastructure, so the PDF never leaves your environment as part of normal editing.
• No upload step to a vendor. The workflow is not "send us your file, we process it, you download the result."
• The same model scales. The site describes running it on any infrastructure, from one PDF on a laptop to batch processing on a server.

The trade-off is explicit: you take on deployment and upkeep. If your team has no server or container experience, that is the real cost of this privacy model.

Why open source matters here

Privacy claims are hard to check when the code is closed. Stirling's answer is that "the source is public so you can verify that instead of trusting it." For a compliance or security review, that changes the conversation:

• Your reviewers can inspect how files are handled rather than accept a policy document.
• Independent parties can flag issues, and fixes are visible.
• You are not locked into a vendor's account system to keep access to your own documents.

This is a meaningful difference from hosted PDF tools, where verification stops at the vendor's word. It does not automatically make the software secure — it makes the security checkable, which is what audit processes usually need.

Audit-ready: what gets recorded

The site lists several controls aimed at regulated workflows:

For teams handling contracts, invoices, or records with retention requirements, the logging and approval steps are the parts that matter most — they produce the trail an auditor asks for.

When this is the right choice

Stirling fits well when:

• Documents are sensitive enough that uploading them to an unknown site is unacceptable.
• You have infrastructure (a server, container platform, or internal environment) to run it on.
• A reviewer needs to inspect the code, not just read a privacy policy.
• You process PDFs at volume and want automation — OCR, classification, redaction, routing — inside your own environment.

It fits less well when:

• You have no way to host software and need a browser-only tool today.
• You want a vendor to handle uptime, updates, and support entirely.
• Your compliance team requires a signed vendor agreement rather than self-hosted software.

Practical checks before you commit

1. Confirm your deployment target. Decide whether Stirling runs on a laptop, an internal server, or your cloud environment — the privacy benefit depends on the file never leaving that boundary.
2. Review the source or have someone review it. The verification claim only pays off if you actually use it.
3. Test the audit trail. Run a small batch and confirm the logs and approval steps produce records your compliance team accepts.
4. Check the pricing page at stirling.com/pricing for the current terms of any paid tier, since hosting and support options affect total cost.

The short version: Stirling PDF's privacy model is architectural — files stay where you run the software — and verifiable, because the code is open. If those two properties match your requirements and you can host it, it addresses the core concern of keeping sensitive PDFs off untrusted websites.