# PaperKnife: Local PDF Editing for Web and Android

> PaperKnife is an offline-first PDF utility for merging, splitting, compressing, editing, signing, and protecting documents. Its web build and PWA require no application server, while the Android app adds Capacitor integration and optional on-device OCR.

**potatameister/PaperKnife** — Privacy-first PDF utility (Zero-Server Architecture). Merge, split, compress, and edit PDFs 100% locally on your device. No uploads, no servers, no tracking.

- Repository: https://github.com/potatameister/PaperKnife
- Website: https://potatameister.github.io/PaperKnife/
- Stars: 1,514 · Forks: 106
- Language: TypeScript
- License: AGPL-3.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/potatameister-paperknife

## PaperKnife's device-local PDF workflow

PaperKnife addresses a specific privacy problem: common PDF operations usually send documents to an upload endpoint or third-party service. Its stated model is zero-server architecture, with merge, split, compression, signing, protection, image conversion, watermarking, metadata cleaning, and text extraction performed on the device. The intended users are people handling contracts, forms, scans, personal records, or work documents that should not be uploaded merely to combine pages or apply an edit.

The repository supports two delivery paths. The web application is a React and TypeScript project built with Vite. Its `dist/` directory contains static files and does not require an application server. The same site can be installed as a Progressive Web App for offline access. A Capacitor Android project is also included, while release pages distribute an APK and IzzyOnDroid provides a Lite package.

This architecture is more specific than merely calling an application "private." A hosted website still serves the application files through its host, but the documentation states that document processing happens locally and that files do not leave the phone. PaperKnife is therefore suited to workflows where a user can open the app, select local files, process them, and save the result without relying on a remote PDF API. The security boundary remains the user's device, browser, installed application, and operating system, rather than an application-owned processing server.

## PDF libraries behind PaperKnife's editing features

The dependency list shows how PaperKnife assembles document operations. `pdf-lib` provides PDF creation and modification capabilities, while `pdfjs-dist` supplies PDF parsing and rendering support. `JSZip` handles ZIP-based package operations, `@pdfsmaller/pdf-encrypt-lite` supplies the encryption dependency, and `tesseract.js` supports OCR workflows. These packages sit inside a TypeScript application built with React, Vite, and Capacitor.

The visible feature set maps those components to user tasks. Page merging and splitting require reading document structure and producing a revised PDF. Quality-based compression needs a compression implementation, although the README does not document the exact algorithm or its limits. PDF password protection and unlocking use the dedicated encryption dependency. Converting pages to JPG or PNG at 72 through 300 DPI requires PDF rendering and image export rather than simple text editing.

Editing is not limited to page ordering. PaperKnife documents drawing, uploaded and reusable signatures, watermarks, page numbers, and metadata cleaning. OCR text extraction is marked as available only in the full version. The repository layout and package manifest do not by themselves explain every implementation detail, such as how malformed PDFs are recovered or whether digital signature validation is performed. It would be incorrect to treat "sign" as a claim of cryptographic PDF certification. The documented signature feature should be understood as adding a visual signature unless the application documentation establishes otherwise.

## Running the web version and enabling Deep OCR

The web build can be run locally with Node.js 22 or later and `git`. A fresh clone uses the lockfile through `npm ci`. Deep OCR is optional and requires a separate vendoring command because its engine files are not committed to the repository.

```bash
git clone https://github.com/potatameister/PaperKnife.git
cd PaperKnife
npm ci
npm run dev
```

These commands clone the project, install the locked dependencies, and start Vite. The development server is available at `http://localhost:3000`. For local development, run the OCR vendoring script before expecting the Deep OCR feature:

```bash
npm run vendor:ocr
```

This command invokes `node scripts/vendor-tesseract.mjs` and retrieves the approximately 30 MB of engine files needed for Deep OCR. Re-running it is documented as safe because files already present are skipped. Without that command, the rest of the application works, but Deep OCR is unavailable.

For a deployment build, compile TypeScript and create the static bundle with:

```bash
npm run build
```

The output is written to `dist/`, which can be served by any static host. A local production preview is available through `npm run preview`. This is a meaningful deployment advantage: there is no server component that processes uploaded PDFs. It does not eliminate every hosting concern, since users still need a trustworthy source for the application files, and it does not prove that a particular browser has sufficient memory or storage for large documents.

## Building PaperKnife's Android package

PaperKnife also targets Android through Capacitor. The README identifies JDK 21 and the Android SDK as additional requirements for building an APK. The web build must be created before synchronizing its contents into the native project.

```bash
npm run build
npx cap sync android
```

The first command produces `dist/`. The second runs the Capacitor synchronization command and prepares the Android project from that build. If the OCR files were vendored, the README states that they are bundled into the full APK automatically.

Users do not have to perform this sequence to try the project. The README links to the latest GitHub release APK, an IzzyOnDroid package, and the live PWA. The full GitHub release includes the offline OCR engine. The Lite IzzyOnDroid build contains the same application without OCR and is described as having a smaller download. That distinction matters when selecting a distribution: installing Lite does not make OCR temporarily unavailable through a setting, because the documentation presents OCR as absent from that edition.

The repository contains Android, F-Droid, and fastlane-related entries, but the README does not document the complete signing, release-channel, or store-submission process. It therefore supports a conclusion about the build prerequisites and packaging choices, but not a detailed account of how maintainers produce every published artifact.

## Where local PDF editing becomes difficult

The largest practical limitation is that a privacy-first offline tool must operate within browser and device constraints. Large scanned documents can consume substantial memory during rendering, compression, image conversion, or OCR. The README does not publish file-size limits, page limits, browser support guarantees, or expected processing times. A feature being available offline does not mean that every document will complete quickly or fit comfortably in available memory.

The split between Full and Lite is another concrete boundary. Deep OCR is not included in the Lite build, and a fresh source checkout also lacks OCR engine files until `npm run vendor:ocr` has been run. Users who need text extraction should confirm their edition before installation.

PDF encryption also deserves careful evaluation. PaperKnife documents password protection and unlocking, and the dependency list includes `@pdfsmaller/pdf-encrypt-lite`, but it does not state the supported PDF encryption revisions, permission policies, key strength, or compatibility with every protected input. Encrypted or digitally signed documents may behave differently from ordinary PDFs. Likewise, visual signatures should not be confused with validation of cryptographic signatures.

Compression is another area where the documentation is too brief for firm expectations. Quality presets are listed, but there are no documented ratios or fidelity guarantees. Users should inspect pages containing scanned images, fine text, annotations, forms, or embedded fonts after compression rather than assuming that a smaller file preserves the original layout.

## PaperKnife compared with server-backed PDF services

The main alternative is a hosted PDF service that receives uploaded documents and performs operations on remote infrastructure. The difference is architectural. PaperKnife uses a static web application or installed mobile package, and its documented operations remain on the user's device. A conventional web PDF utility depends on a backend for at least part of the processing path.

That difference can matter for confidential documents because there is no application-owned upload described in PaperKnife's workflow. It also removes backend operating costs from the processing layer, although hosting and distributing the static files still require decisions by the project or deployer. A service-side approach may offer centralized processing, managed capacity, browser-to-browser sharing, and easier access from unmanaged devices, but those capabilities are not documented as PaperKnife features.

PaperKnife is therefore the wrong choice when document processing must be shared across multiple users through a central service. It is also unsuitable when an organization requires managed audit logs, centrally enforced processing policies, or an always-current server environment. For single-user editing with sensitive files, the absence of an upload path is the defining difference rather than a claim that local PDF processing eliminates every security concern.

Maintenance activity is recent enough to note, but activity alone does not establish long-term support. The repository is not archived, its last push was on 2026-10-01, and version `1.1.0` was released on 2026-10-01. The license is `AGPL-3.0-or-later`, which means redistribution and network use must be reviewed against the AGPL obligations. This is a project-specific compliance consideration, not legal advice.

## Conclusion

PaperKnife suits users who want routine PDF operations to remain on their own web, desktop, or Android device, provided that offline execution is more important than a server-backed workflow. It is less suitable for users who require cloud collaboration, unattended batch processing, or a bundled OCR engine in the Lite edition. Verify the intended build first, run `npm ci`, and test PDF encryption and editing against documents that contain signatures, fonts, forms, or other complex structures before relying on it for production documents.

## FAQ

### Does PaperKnife upload PDF files to a server?

The documentation states that all processing happens on the device and that files do not leave the phone. The web build is distributed as static files and has no server component.

### How do I enable Deep OCR in PaperKnife?

For a source checkout, run `npm run vendor:ocr` before starting or building the application. The script adds the approximately 30 MB engine files that are not committed to the repository.

### What is the difference between the PaperKnife Full and Lite builds?

The Full GitHub release includes the offline OCR engine. The Lite IzzyOnDroid build offers the application without OCR and is described as having a smaller download.

### Can I use PaperKnife without a backend server?

Yes. `npm run build` creates a static `dist/` directory that can be placed on any static host. The README explicitly states that no server component exists.

### What do I need to build the PaperKnife Android APK?

The documented prerequisites are Node.js 22 or later, JDK 21, the Android SDK, and `git`. After `npm run build`, the README specifies running `npx cap sync android`.

## Sources

- [License: AGPL-3.0](https://github.com/potatameister/PaperKnife/blob/main/LICENSE)
- [potatameister/PaperKnife on GitHub](https://github.com/potatameister/PaperKnife)
- [Project website](https://potatameister.github.io/PaperKnife/)
- [README](https://github.com/potatameister/PaperKnife/blob/main/README.md)
- [Releases](https://github.com/potatameister/PaperKnife/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/potatameister-paperknife