LOCAL PROCESSING ACTIVE

Read documents
without the upload.

A clinical, privacy-first document renderer. Drop a PDF, DOCX, or EPUB file, and your browser parses it instantly. Nothing touches a server.

Select or Drop File

Parsing locally...

Demo only on static site

View Supported Formats

RENDER_ENGINE_v2

The Architecture of Privacy

Most online document viewers function as data honeypots. They require a server round-trip, exposing sensitive files to third-party infrastructure.

Read the Security Protocol

Zero Server Uploads

Files never leave your device. The rendering engine is compiled to WebAssembly and runs entirely within your browser's sandboxed environment.

Zero Latency

Without network overhead, large PDFs and complex DOCX files parse in milliseconds. The bottleneck is your CPU, not your connection.

Ephemeral State

When you close the tab, the document ceases to exist. We utilize aggressive garbage collection and eschew local storage for file contents.

Strict Content Security

Scripts embedded within PDFs are neutralized. Our parser extracts layout and text, discarding potential execution vectors.

Supported Formats

PARSER_MATRIX_v4.2

Format	Engine	Fidelity	Action
PDF Portable Document Format .pdf	pdf.js (Mozilla)	Pixel-perfect text & vector	Specs
DOCX Microsoft Word Open XML .docx	mammoth.js (Custom)	High semantic preservation	Specs
EPUB Electronic Publication .epub	epub.js	Native flowable layout	Specs
JSON JavaScript Object Notation .json	V8 Native JSON.parse	Strict structural validation	Specs

View all 12+ supported formats

The True Cost of "Free" Document Viewers

When you upload a sensitive contract or financial record to a cloud-based viewer, you surrender control. Their business model relies on aggregating metadata and, in some cases, scanning text for advertising profiles.

Standard Cloud Viewer Uploads file -> Extracts text -> Stores on S3 -> Serves HTML -> Logs IP/Metadata
uViewDoc Protocol Select file -> Browser WebWorker parses bytes -> Renders directly to Canvas/DOM. No network request made.

NETWORK_MONITOR

Diagnostic Tools

Beyond rendering, uViewDoc provides a suite of clinical tools for document analysis and structural inspection. All run entirely in-browser.

Deep Word Counter

Extracts and counts text accurately from DOCX and PDF, ignoring footnotes or formatting artifacts.

JSON Formatter

Strict validation and formatting. Handles large payloads efficiently without crashing.

Base64 Decoder

Decode base64 strings back to text or binary files instantly on your machine.

Markdown Preview

Live compile Markdown to HTML securely within the browser sandbox.

Explore all 10 diagnostic tools

Engine Benchmarks

~14ms

PDF Initialization

Average time to parse PDF header structure and build page tree references on M1 architecture.

0kb

Network Payload

Bytes sent to our servers when you view a document. The viewer is a static HTML/JS bundle.

60fps

Scroll Performance

Virtual DOM rendering ensures steady framerates even on 500+ page technical manuals.

GARBAGE_COLLECTION_PROTOCOL

> File pointer received via ArrayBuffer.
> PDFDocumentProxy initialized.
> Rendering Page 1 to CanvasContext2D.
> ...
> User closes tab.
> Buffer dereferenced. Memory reclaimed instantly.

Handling Massive Files

Browsers impose strict memory limits (often capping at 2GB). Loading a 500MB architectural PDF directly into memory will crash most tabs.

We utilize lazy-loading streams and progressive canvas recycling to ensure stability. Only visible pages are rendered, meaning a 1,000-page document consumes roughly the same RAM as a 10-page document.

Read the Memory Limits Guide

Defensive DOM Injection

Formats like DOCX and EPUB are essentially zipped XML/HTML. Rendering them means converting that XML to DOM nodes on your screen.

If a malicious actor embeds a <script> tag inside an EPUB chapter, rendering it blindly would trigger a Cross-Site Scripting (XSS) attack locally. We run all parsed flowable text through a strict DOMPurify pipeline before it ever touches the Document Object Model.

Read the XSS Prevention Guide

Sanitization Matrix

<script src="..."> STRIPPED
onclick="eval()" STRIPPED
<iframe> STRIPPED
<strong>, <em> ALLOWED

Zero-Request Font Mapping

If a document requires a font you don't have installed, we refuse to fetch it from Google Fonts or Adobe. Network requests leak metadata. Instead, we use a geometric heuristic to horizontally scale a local system font to perfectly match the original font's bounding box, preserving layout fidelity without compromising privacy.

Explore Font Substitution Logic

Frequently Asked Queries

Yes. Modern browsers implement the File API, allowing JavaScript to read files locally without HTTP requests. We do not integrate tracking scripts like Google Analytics. You can verify this by opening your browser's Network tab—you will see zero outbound requests when rendering a file.

Our engine streams large files into memory in chunks using ArrayBuffers. While your local RAM is the limit, tests show standard hardware easily handles 200MB+ architectural PDFs. We employ progressive rendering, meaning page 1 displays before page 500 is fully parsed.

No. uViewDoc is strictly a reader/viewer. Adding editing capabilities dramatically increases payload size and complexity, compromising the clinical, lightweight nature of the tool. For editing, we recommend native local software.

Browser native viewers vary wildly in capabilities and security postures (e.g., Chrome's PDFium vs Safari's WebKit PDF). By supplying a standardized JavaScript rendering engine (pdf.js), we guarantee consistent layout, disable arbitrary scripts reliably, and maintain an identical diagnostic environment across all platforms.

Embeddable Local API

Need to render documents securely within your own internal tools? We provide a lightweight wrapper around our core rendering loop.

Initialize the viewer by passing a File object directly from an input element. No server backend required.

Read the Architecture Docs

import { DocumentEngine } from '@uviewdoc/core';

const fileInput = document.getElementById('doc');
const canvas = document.getElementById('renderTarget');

fileInput.addEventListener('change', async (e) => {
  const engine = new DocumentEngine({
    sandbox: true,
    disableNetwork: true
  });

  // Renders locally, zero HTTP requests
  await engine.renderPage(e.target.files[0], canvas, 1);
});

Hardware Compatibility Matrix

Desktop Chrome 90+

macOS Safari 14+

iOS WebKit (w/ limits)

Android Chromium

Built for Auditability

Trust in privacy tools requires transparency. The core logic of uViewDoc relies on battle-tested open-source libraries like Mozilla's PDF.js. No obfuscated binaries.

View Source on GitHub

GDPR Exempt

Because we collect zero user data and process files locally, uViewDoc naturally falls outside GDPR scope.

HIPAA Safe

Medical documents parsed locally never traverse a network, ensuring no PHI is accidentally transmitted.

SOC2 Compliant Default

By operating strictly client-side, the tool inherently complies with zero-trust network mandates.

Ready to inspect?

Stop uploading your sensitive files. Scroll back up and drop a document to begin.

Return to Viewer

Terms | Privacy | Security

Read documents without the upload.