DEV Community: Hugh

How to Make a PDF Look Scanned in the Browser

Hugh — Tue, 07 Jul 2026 13:39:37 +0000

Making a PDF look scanned is a surprisingly practical document-processing problem. Users often want a digital PDF to resemble a printed, signed, and rescanned document without using a physical printer or scanner.

This article explains a browser-based technical approach for building a Make PDF Look Scanned component. The component accepts a PDF file, renders each page to Canvas, applies scanner-like visual effects, and exports a new image-based PDF.

Component Goal
The component has one job:

Convert a clean digital PDF into a realistic scanned-looking PDF directly in the browser.

A good implementation should support:

PDF upload
Page-by-page rendering
Adjustable scanner effects
Local-only processing
Preview
Downloadable scanned-looking PDF
The high-level pipeline looks like this:

PDF file
-> render pages with PDF.js
-> draw each page to Canvas
-> apply scanner-style Canvas effects
-> encode pages as JPEG
-> assemble image-based PDF
-> download result
Why Use Browser-Side Processing?
A scanned-looking PDF tool is a good fit for browser-side processing because the input file may contain sensitive content.

Keeping the conversion local has several advantages:

The original PDF does not need to be uploaded.
The server does not pay the cost of PDF rendering or image processing.
The user gets faster feedback.
The component can work as a self-contained frontend tool.
The browser already has most of what is needed: file input, Canvas, Blob URLs, JPEG encoding, and Web Workers through PDF.js.

Rendering PDF Pages
Browsers cannot natively expose PDF pages as pixels, so the component uses PDF.js to render each page into a Canvas.

The component reads the uploaded file as an ArrayBuffer, passes it to PDF.js, then loops through every page:

const source = new Uint8Array(await file.arrayBuffer());
const pdf = await pdfjs.getDocument({ data: source.slice() }).promise;

for (let pageNumber = 1; pageNumber <= pdf.numPages; pageNumber++) {
const page = await pdf.getPage(pageNumber);

const viewport = page.getViewport({
scale: dpi / 72,
});

canvas.width = Math.floor(viewport.width);
canvas.height = Math.floor(viewport.height);

await page.render({
canvasContext: ctx,
viewport,
}).promise;
}
The dpi / 72 scale is important. PDF pages are measured in points, where 72 points equal one inch. By adjusting DPI, the component controls the raster resolution of the final scanned page.

Applying Scanner Effects
Once a PDF page is rendered to Canvas, the component transforms it into a scanned-looking image.

The goal is not to create an obvious filter. Real scanned documents usually contain subtle imperfections:

slight rotation
warm paper tone
grayscale or reduced contrast
small blur
fine grain
edge shadow
JPEG compression
The component applies these effects using standard Canvas APIs.

Slight Page Rotation
A perfectly aligned document looks digital. Real scanned pages are often slightly misaligned.

The component rotates the rendered page around the center:

const angle = ((rng() - 0.5) * 2 * skew * Math.PI) / 180;

ctx.translate(width / 2, height / 2);
ctx.rotate(angle);
ctx.drawImage(sourceCanvas, -width / 2, -height / 2);
The default rotation should be small. A value around 0.5° to 1° is usually enough.

Grayscale, Blur, and Contrast
Canvas supports ctx.filter, which can combine common image effects before drawing:

ctx.filter = [
grayscale ? 'grayscale(1)' : '',
blur > 0 ? blur(${blur}px) : '',
paperTone > 0 ? contrast(${1 - paperTone * 0.08}) : '',
]
.filter(Boolean)
.join(' ');
A realistic scanned look depends on restraint. Too much blur makes text hard to read. Too much contrast reduction makes the output look artificially processed.

Paper Tone
Clean digital PDFs usually have a pure white background. Scanned pages often have a warmer, softer paper color.

The component first fills the output canvas with a light paper-like color:

ctx.fillStyle = paperFill(paperTone);
ctx.fillRect(0, 0, width, height);
Then it overlays a subtle warm tint:

ctx.globalCompositeOperation = 'multiply';
ctx.globalAlpha = Math.min(0.14, paperTone * 0.14);
ctx.fillStyle = 'rgb(255, 248, 226)';
ctx.fillRect(0, 0, width, height);
The opacity must stay low. The goal is to remove the sterile digital-white look, not to turn the page yellow.

Fine Grain
Noise is one of the most important effects, but it is also easy to get wrong.

If noise is applied in large blocks, the page background can look pixelated or mosaic-like. A better approach is fine per-pixel grain with very low intensity.

const image = ctx.getImageData(0, 0, width, height);
const data = image.data;

for (let y = 0; y < height; y++) {
let rowBias = 0;

if (y % 3 === 0) {
rowBias = (rng() - 0.5) * amount * 6;
}

for (let x = 0; x < width; x++) {
const idx = (y * width + x) * 4;

const luminance =
  0.299 * data[idx] +
  0.587 * data[idx + 1] +
  0.114 * data[idx + 2];

const paperBoost = luminance > 210 ? 1.15 : 0.72;
const grain =
  ((rng() + rng() + rng()) / 3 - 0.5) *
    amplitude *
    paperBoost +
  rowBias;

data[idx] = clampByte(data[idx] + grain);
data[idx + 1] = clampByte(data[idx + 1] + grain);
data[idx + 2] = clampByte(data[idx + 2] + grain);

}
}

ctx.putImageData(image, 0, 0);
This creates a finer texture and avoids obvious square artifacts.

The row bias adds a very subtle scanner-line feel without turning the document into a striped image.

Edge Shadow
Real paper is rarely perfectly flat against scanner glass. Slight edge darkening helps sell the illusion.

The component applies edge shadows with linear gradients:

ctx.globalCompositeOperation = 'multiply';

drawEdgeGradient(ctx, 0, 0, band, height, 'left', alpha);
drawEdgeGradient(ctx, width - band, 0, band, height, 'right', alpha);
drawEdgeGradient(ctx, 0, 0, width, band, 'top', alpha);
drawEdgeGradient(ctx, 0, height - band, width, band, 'bottom', alpha);
A directional gradient is better than a heavy vignette because documents are rectangular. The effect should look like paper on glass, not a photo filter.

Encoding Pages as JPEG
After the effects are applied, each processed Canvas is encoded as JPEG:

const blob = await new Promise((resolve, reject) => {
canvas.toBlob(
(nextBlob) =>
nextBlob
? resolve(nextBlob)
: reject(new Error('Failed to encode JPEG.')),
'image/jpeg',
quality
);
});

const jpegBytes = new Uint8Array(await blob.arrayBuffer());
JPEG compression is part of the scanned look. Real scanned PDFs often contain image compression artifacts. However, quality should not be too low, or text readability suffers.

A default quality around 0.7 to 0.8 usually works well.

Rebuilding the PDF
The final output is an image-based PDF. Each processed JPEG page is embedded into a new PDF page with the original page dimensions.

Conceptually:

for each processed page:
create PDF page with original width/height
embed JPEG as full-page image
draw image at 0,0 covering the whole page
This produces a PDF that behaves like a scanned document: each page is an image, not selectable text.

This is useful because scanned documents are usually rasterized. It also helps avoid the result looking like a normal digital PDF with a filter applied on top.

Preview and Download
Once the new PDF bytes are created, the component turns them into a Blob URL:

const blob = new Blob([pdfBuffer], {
type: 'application/pdf',
});

const url = URL.createObjectURL(blob);
The same URL can be used for:

an iframe preview
a download link
a generated filename such as document.scanned.pdf
For performance and memory safety, the component should revoke old Blob URLs when a new file is selected or when the component unmounts.

URL.revokeObjectURL(previousUrl);
Recommended Default Settings
A good scanned effect should be subtle. One practical default set is:

const defaultParams = {
dpi: 144,
skew: 0.8,
grayscale: true,
paperTone: 0.52,
noise: 0.035,
blur: 0.35,
edgeShadow: 0.18,
jpegQuality: 74,
};
These values prioritize readability while still making the document look less digitally perfect.

Common Mistakes
Too Much Noise
Strong noise makes the page dirty and distracting. Block-based noise can create mosaic artifacts. Use fine, low-intensity grain instead.

Too Much Rotation
A scanned page should look slightly imperfect, not broken. Large rotation values quickly look fake.

Excessive Blur
Blur helps simulate scanner optics, but too much blur destroys text clarity.

Overly Yellow Paper
Paper tone should be barely noticeable. A strong yellow overlay makes the document look artificially aged rather than scanned.

Keeping Text as Text
If the goal is to simulate a scanned document, exporting vector text is not ideal. Rasterizing each page into an image-based PDF creates a more convincing result.

Final Architecture
A clean component architecture can be kept simple:

MakeLookScanned component

handles file input
loads PDF.js
renders PDF pages
applies Canvas effects
encodes JPEG pages
assembles final PDF
manages preview/download URLs The component does not require a backend service. It can run entirely in the browser.

Conclusion
A “Make PDF Look Scanned” component can be built with standard browser technologies:

PDF.js for rendering PDF pages
Canvas for visual scanner effects
JPEG encoding for compression artifacts
Blob URLs for preview and download
image-based PDF assembly for the final output
The key to realism is subtlety. Slight rotation, fine grain, soft blur, warm paper tone, and light edge shadows can make a clean digital PDF look like it came from a physical scanner without making the output unreadable or obviously filtered.

Stop Writing Garbage Gemini Omni Prompts (Here's the Formula)

Hugh — Wed, 20 May 2026 07:51:09 +0000

Most of you are treating Gemini Omni like a glorified search engine. You type in a vague sentence, hit enter, and pray for magic. Then you get frustrated when the output is flat, boring, or completely misses the mark.

AI isn't a mind reader. If your outputs look like trash, it's usually your fault.

Here's the ugly truth. Gemini requires strict direction. If you leave things up to interpretation, the model falls back on its baseline training, which is almost always generic. We need to fix how you talk to this machine.

The Real Deal about Gemini Omni

The biggest mistake I see daily? People forgetting to state what they actually want.

Gemini Omni is a multimodal beast, but it has a massive bias. If you don't make your output type explicitly clear—especially for images or video—Gemini tends to default toward text.

Think about that. You want a storyboard, but you just describe a scene. The AI spits out a 500-word essay instead of an image. Frustrating, right? You have to literally spell it out.

Why Most Strategies Fail

Vague requests are the enemy. Prompts that define the task and constraints usually perform better than vague requests.

Most people write prompts like, "Give me a video about a city." That is useless. You are leaving all the creative heavy lifting to a mathematical algorithm. Instead, you need a repeatable framework.

Gemini Omni prompts work best when they clearly specify the subject, context, style, mood, and format.

Here is the exact formula you should be using:

Subject: You must specify who or what is in the output.
Context: You need to explain where, when, and why.
Style: You have to define the visual or writing style.
Mood: You must set the emotional tone.
Format: You need to dictate text length, image, or video details.

The Visual Output Trap

Text is easy. Visuals are hard. If you are trying to generate visual content, you have to hold the AI's hand.

For image prompts, you should start with "Generate an image of" or "Create an image of" so the model knows you want a visual result. Don't assume it knows.

And video? That's a whole different beast. If your goal is to create cinematic videos from prompts, you cannot just describe the subject. For video prompts, describe the camera movement, duration, setting, and motion as clearly as the subject itself.

You are the director. Act like it.

Actionable Steps (That Actually Work)

Stop guessing and start using proven structures. Gemini is especially useful for writing, planning, brainstorming, image generation, and video creation. But you have to feed it right.

Here are ready-to-use examples that actually work:

Nailing the Text Request: Don't just ask for an article. Be militant about the format. Ask it to "Write a 1,200-word article about the future of remote work in 2030.". Tell it to use an authoritative but conversational tone, include three subheadings, and end with a clear CTA.
Directing the Photography: Want a product shot? Detail the lighting and angles. Say, "Generate an image of a premium wireless headphone product shot.". Add constraints like a white background, soft shadows, 45-degree top-down angle, studio lighting, and Apple product photography style.
Controlling the Camera: If you are building [workflows for Shorts and TikTok], dictate the pacing. Try this: "Generate a 10-second cinematic video.". Then build the scene: "A female architect stands at floor-to-ceiling windows overlooking a futuristic city at dusk.". Finally, dictate the shot: "Camera: slow zoom out. Mood: contemplative.".

Advanced Nuance

The magic happens when you blend the mood with the format. Most folks get the subject right but completely ignore the emotional tone.

If you are generating a video of a city, a "contemplative" mood with a "slow zoom out" creates a totally different asset than a "chaotic" mood with a "shaky cam panning" shot. The details are where the money is made.

You control the output by controlling the constraints. If your prompt is two sentences long, you aren't trying hard enough.

Wrapping Up

Stop blaming the AI for bad outputs. Apply the Subject, Context, Style, Mood, Format framework to every single prompt you write today. Lock down your constraints, dictate your camera movements, and force the model to give you exactly what you need.

HeyGen HyperFrames: How Code is Killing Traditional Video Editing

Hugh — Sun, 19 Apr 2026 12:26:01 +0000

Video production is broken. Really broken.

Think about your current workflow. You write a script. You pass it to an editor. They spend hours clicking around a timeline in Adobe Premiere, tweaking keyframes, exporting massive files, and sending them back for revisions. It’s slow. It’s expensive. And it absolutely kills scale.

If you are trying to run a high-volume content strategy, this traditional bottleneck will destroy your margins. You can't scale a human clicking a mouse.

This is exactly why the industry is aggressively pivoting toward programmatic video. We are moving away from graphic user interfaces and moving toward code. Enter HeyGen HyperFrames. This tool isn't just another shiny plugin. It represents a fundamental shift in how we think about rendering media.

HyperFrames is an open-source, HTML-native video framework that turns web code into rendered video. Read that again. Not a timeline. Not a drag-and-drop editor. Web code.

Let's break down exactly what this means, why your current video strategy is probably obsolete, and how to actually use this to dominate your niche.

The Real Deal about HeyGen HyperFrames

Most video frameworks are clunky. They try to emulate a timeline in the browser. HyperFrames completely abandons that concept.

Instead, it’s designed so AI agents can write HTML, CSS, and JavaScript and then produce MP4, MOV, or WebM output, with local rendering and a CLI-based workflow.

This is huge.

HyperFrames lets you build video scenes with familiar web tools instead of traditional video editors. If you know how to build a basic webpage, you now know how to build a video scene. The core philosophy here is terrifyingly simple: anything a browser can animate or display can become part of a video composition.

Think about the implications for your developers and your SEO team. You don't need to hire a motion graphics specialist to create a dynamic graph. You just use standard web animation libraries. If your goal is to turn URLs, data, and articles into video online at absolute scale, relying on HTML-native frameworks is the only logical path forward.

Why Most Strategies Fail

Here's the ugly truth about scaling video marketing. Most people try to throw more humans at the problem. They hire offshore editors. They buy massive server farms to render After Effects templates.

It always fails.

The main appeal of this new framework is agent-friendly video creation: an AI can generate the code, preview it, and render it without needing Premiere or After Effects.

Adobe products are built for humans. They require a user interface. They require manual intervention. You cannot easily ask an LLM to "open Premiere and nudge that clip three frames to the left." But you can ask an LLM to update a CSS margin.

Because AI can handle the code generation and rendering independently, automated, repeatable video pipelines are much easier to build.

Imagine an autonomous agent scraping trending news in your niche, writing a script, generating HTML scenes based on a template, and spitting out pixel-perfect MP4s online while you sleep. That’s not science fiction. That’s the exact workflow this framework enables.

A Specific Example: The Marketing Pipeline

Let's get practical. How are people actually using this in the wild right now?

It’s positioned for motion graphics, titles, animated explainers, website-to-video capture, and agent-generated marketing videos.

Let's say you run a financial blog. You publish weekly market reports. Historically, converting that dense financial data into a YouTube video meant spending days building custom animations. Now? It's incredibly powerful when you need to instantly render animated charts directly from the live data feeding your website. You just point the framework at the DOM elements, set your timing, and render.

HeyGen’s own launch materials also show it being used alongside their avatar pipeline.

This is where the magic happens. You combine an AI-generated script, a photorealistic HeyGen avatar speaking the script, and HyperFrames rendering the dynamic HTML backgrounds and text overlays behind them. All of it triggered by a single API call or CLI command. No human intervention required from start to finish.

Actionable Steps (That Actually Work)

You want to get this running? Good. It's surprisingly straightforward if you are comfortable in a terminal.

Don't expect a slick point-and-click installer. This is a developer tool.

The Infrastructure Check: You can't just run this on a decade-old laptop running legacy software. The framework requires Node.js 22+ plus FFmpeg for local rendering. Make sure your environment is up to date. FFmpeg is the heavy lifter here; it's the engine that actually compiles the browser frames into a video file.
The Installation: The quickstart says you can add it with npx skills add heygen-com/hyperframes. Run that in your project directory.
Structuring the Composition: You aren't building a timeline. You are building a DOM. The docs show a composition structure using HTML elements with timing attributes and animation libraries like GSAP.

GSAP (GreenSock Animation Platform) is the secret weapon here. If you know GSAP, you can animate anything. You use standard CSS for styling, and GSAP handles the timing, easing, and transitions. The HyperFrames CLI simply spins up a headless browser, plays the GSAP animation, captures every single frame, and pipes it into FFmpeg.

Advanced Nuance

Let's talk edge cases.

Rendering HTML to video isn't entirely new. Puppeteer and Playwright have been able to take screenshots for years. But capturing smooth, 60fps video with perfect audio sync from a DOM? That's historically been a nightmare of dropped frames and weird timing artifacts.

The genius of building a dedicated framework for this is synchronization. When you rely on standard browser rendering for video, any CPU spike ruins the video. A dropped frame in a browser is just a micro-stutter. A dropped frame in an MP4 export ruins the entire file.

By strictly controlling the timing attributes and forcing the animation libraries to step through frame-by-frame (rather than relying on real-time wall clocks), the output remains deterministic. Every time you render that code, you get the exact same video.

This predictability is what makes it an "agent-friendly" environment. An AI agent doesn't have eyes. It can't watch the export and say, "Oops, that text faded in too late." It needs absolute mathematical certainty that if it writes a specific block of CSS and GSAP, the resulting video will behave exactly as calculated.

Wrapping Up

Stop paying for bloated software subscriptions if your end goal is scalable content. The future of video generation isn't a better timeline editor. It’s code. By leveraging HTML, CSS, and automated agents, you can build a content machine that outpaces your competitors while they are still waiting for their After Effects projects to render. Learn the CLI, master GSAP, and automate everything.

How to Install Z-Image Turbo Locally

Hugh — Wed, 10 Dec 2025 01:30:04 +0000

This guide explains how to set up Z-Image Turbo on your local machine. This powerful model uses a 6B-parameter architecture to generate high-quality images with exceptional text rendering capabilities.

🚀 No GPU? No Problem.

If you don't have a high-end graphics card or want to skip the installation process, you can use the online version immediately:

Z-Image Online: Free AI Generator with Perfect Text
Generate 4K photorealistic AI art with accurate text in 20+ languages. Fast, free, and no GPU needed. Experience the best multilingual Z-Image tool now.

1. Hardware Requirements

To run this model effectively locally, your system needs to meet specific requirements:

GPU: A graphics card with 16 GB of VRAM is recommended. Recent consumer cards (like the RTX 3090/4090) or data center cards work best. Lower memory devices may work with offloading but will be significantly slower.
Python: Version 3.9 or newer.
CUDA: Ensure you have a working installation of CUDA compatible with your GPU drivers.

2. Create a Virtual Environment

It is best practice to isolate your project dependencies to prevent conflicts with other Python projects.

Open your terminal application.
Run the command below to create a new environment named zimage-env:

python -m venv zimage-env

Activate the environment:

# On Linux or macOS
source zimage-env/bin/activate

# On Windows
zimage-env\Scripts\activate

3. Install PyTorch and Libraries

You must install a version of PyTorch that supports your GPU. The commands below target CUDA 12.4.

Note: Adjust the index URL if you require a different CUDA version.
We install diffusers directly from the source to ensure compatibility with the latest Z-Image features.

pip install torch --index-url [https://download.pytorch.org/whl/cu124](https://download.pytorch.org/whl/cu124)
pip install git+[https://github.com/huggingface/diffusers](https://github.com/huggingface/diffusers)
pip install transformers accelerate safetensors

4. Load the Z-Image Turbo Pipeline

Create a Python script (e.g., generate.py) to load the model. We use the ZImagePipeline class wrapper and bfloat16 precision to save memory without sacrificing quality.

import torch
from diffusers import ZImagePipeline

# Load model from Hugging Face
pipe = ZImagePipeline.from_pretrained(
    "Tongyi-MAI/Z-Image-Turbo",
    torch_dtype=torch.bfloat16,
    low_cpu_mem_usage=False,
)

# Move pipeline to GPU
pipe.to("cuda")

5. Generate an Image

You can now generate an image. This model is optimized for speed and works well with just 9 inference steps and a guidance scale of 0.0.

Copy the following code into your script:

prompt = "City street at night with clear bilingual store signs, warm lighting, and detailed reflections on wet pavement."

image = pipe(
    prompt=prompt,
    height=1024,
    width=1024,
    num_inference_steps=9,
    guidance_scale=0.0,
    generator=torch.Generator("cuda").manual_seed(123),
).images[0]

image.save("z_image_turbo_city.png")
print("Image saved successfully!")

6. Optimization Options

Performance Tuning

If you have supported hardware, you can enable Flash Attention 2 or compile the transformer to speed up generation:

# Switch attention backend to Flash Attention 2
pipe.transformer.set_attention_backend("flash")

# Optional: Compile the transformer (requires PyTorch 2.0+)
# pipe.transformer.compile()

Low Memory Mode (CPU Offload)

If your computer has limited VRAM (less than 16GB), you can use CPU offloading. This moves parts of the model to system RAM when they are not in use.

Note: This allows the model to run on smaller GPUs, but generation will take longer.

pipe.enable_model_cpu_offload()