AI upscaler without a GPU

You do not need a graphics card. Someone else can run the model. Here is how that works, what it costs you in limits, and when a local GPU is still the right answer.

How it works

A cloud upscaler uploads the file, runs it on a remote GPU, and returns the result. Your machine only handles the browser. A four year old laptop, a phone, a tablet — all behave the same, because none of them touch the model.

The hardware on the other end matters more than yours. On a rented RTX 5090 or 3090 a single photo finishes in under a minute, which is faster than most people's home cards would manage even if they had one.

What it costs you

ConstraintTypical cloud limitLocal GPU alternative
Photo size4 MPNo cap
Video length30 secondsNo cap
SetupNoneVulkan runtime, model download, build
PrivacyFile leaves your deviceStays local
Offline useNoYes
CostFree during launchFree, open source
The honest tradeoff: cloud wins on setup and hardware, loses on length and size. If your file is a 20 second clip from a messaging app, cloud is strictly better. If it is a 40 minute interview, no cloud cap will hold it and you need a local GPU or a paid desktop suite.

Splitting a file to fit a cap

Cut at keyframes so nothing is re-encoded:

ffmpeg -ss 00:01:12 -to 00:01:38 -i input.mp4 -c copy segment.mp4

Batch split a long file:

ffmpeg -i input.mp4 -c copy -f segment -segment_time 30 -reset_timestamps 1 seg-%03d.mp4

Rejoin without a second encode:

printf "file '%s'\n" seg-*.mp4 > list.txt
ffmpeg -f concat -safe 0 -i list.txt -c output.mp4
Correction, measured below. The claim that "the seam is invisible because no frame is regenerated" is only true for the segment-muxer path. A single hand-placed -ss/-to cut is not frame-exact: it overshoots the tail by 2–3 frames, and in 2 of 5 tested cut points it duplicated one frame and dropped another. It also produced larger files per frame than a CRF 18 re-encode. Numbers in the next section.

Measured: what a stream copy actually does to your frames

Stream copy is the standard advice for splitting a file under an upload cap, and nobody usually checks whether the frames that come out are the frames that went in. So I built a fixture where frame identity is readable after compression: 300 frames at 25 fps, 320×180, each carrying its own index as a 9-bit black/white patch in the top-left corner. The patch survives H.264 because its blocks are flat, so after decoding I can read back exactly which source frame each output frame came from — not estimate it, read it.

The source was encoded with libx264 at CRF 18, -g 60, which in practice produced 23 I-frames over 300 frames (one every ~13 frames). Reading all 300 frames back gave 300 unique, strictly increasing indices — the fixture is self-consistent, so any anomaly afterwards belongs to the cut, not to the measurement.

The cut is not frame-exact, in both directions

Five cut points, each run twice: -ss before -i (input seeking) and -ss after -i (output seeking). A 1.00 s window at 25 fps should yield 25 frames. Head and tail error are in frames.

CutWantBefore -ihead / tailAfter -ihead / tail
0.5 – 1.5 s25270 / +224+3 / +2
1.0 – 2.0 s25270 / +220+7 / +2
2.0 – 3.0 s25270 / +225+2 / +2
2.4 – 3.4 s25280 / +322+6 / +3
5.0 – 6.0 s25280 / +325+3 / +3

Input seeking never lost the head — it starts on the nearest keyframe at or before the requested time — but it overshot the tail by 2–3 frames on all five cuts, which is 8–12% more frames than asked for. Output seeking did the opposite: it dropped 2–7 frames off the front, and in the worst case (1.0 s in, 1.0 s window) delivered 20 frames instead of 25 — a 20% shortfall with no error message and exit code 0.

Worse than a length error: in 2 of 5 cuts in each mode, the output contained one duplicated frame and one missing frame. At the 2.4 s cut the last two frames decode to identical indices. The bit-flags in that frame were unambiguous (block means 234.0 vs 12.0, no value anywhere near the 128 threshold), and the two decoded frames are byte-identical — so this is a real repeated frame, not a misread patch. If you are cutting a clip to a musical beat or a specific cue, that is the frame that slips.

Stream copy cost more bytes per frame than re-encoding

The reason given for copying is always "no generation loss". Noise-free, yes. Cheaper, no. Measured on this fixture:

PathFramesBytesBytes / frame
Source (CRF 18, 300 frames)3003,842,29712,808
Stream copy, 1.0–2.0 s27465,35217,235
Re-encode, CRF 18, 1.0–2.0 s25302,10712,084

The copy cut costs 43% more per frame than re-encoding at CRF 18 — because it carries an extra frame, and because the segment it copies still contains the keyframe it started on plus the dependent frames that follow. The re-encode was also exact: 25 frames, indices 25 through 49, no gaps, no duplicates, 41.51 dB PSNR against the source. At CRF 18 on real footage that quality loss is not visible; on a 30 second clip it is also not slow.

Which is the point: when the cap is a hard upload limit, the thing you want to minimise is bytes that fit, not "encodes performed". A re-encode at a sane CRF wins on size, on frame accuracy, and on length predictability at the same time.

The segment muxer is the exception — that path really is lossless

The batch-split-then-concat recipe does hold up, and I want to be precise about why, since the section above sounds like it contradicts it. Splitting into 2-second chunks and rejoining gave back exactly 300 frames with 0 missing, 0 duplicated, and PSNR 99.0 (i.e. bit-identical) against the source for all 300 frames. Total size grew 0.1%.

SegmentFramesFirst idxLast idx
seg_00052051
seg_0015252103
seg_00252104155
seg_00371156226
seg_00459227285
seg_00514286299

Note the chunk sizes: a nominal 2-second segment holds 52, 52, 52, 71, 59 and 14 frames, not 50 each. The muxer snaps chunk boundaries to keyframes, so segment length is "at least segment_time", never exactly it. If a platform counts frames or enforces a hard per-file length, budget for that overshoot instead of trusting the number you passed in.

Rule of thumb from the measurements. Splitting a long file at keyframes and rejoining: safe, bit-identical. Placing a single cut with -ss/-to -c copy to hit an exact time: not safe, expect 2–3 extra frames at the tail, up to 7 missing at the head, and an occasional duplicated frame. If the cut has to be exact, re-encode it.

And a trap: measuring re-encode loss against the previous generation

While checking how much a re-encode costs, I chained five CRF 23 re-encodes of the same file and measured PSNR after each. Measured against the immediately previous generation, quality improved every round — 32.23 → 40.32 → 41.36 → 42.19 → 43.50 dB. That reads like "re-encoding makes it better", which is nonsense. Measured against the original source, the same five files fall monotonically: 32.23 → 31.75 → 31.38 → 31.11 → 30.91 dB.

GenerationPSNR vs previousPSNR vs sourceHF energyBytes
132.2332.2362.41 dB1,357,687
240.3231.7561.54 dB1,232,486
341.3631.3861.07 dB1,108,860
442.1931.1160.70 dB999,604
543.5030.9160.42 dB918,020

Both series are correct; they answer different questions. Each encode converges toward the "easy to encode" version of the input, so the step size shrinks — that is what PSNR-vs-previous measures. What the viewer sees is distance from the original, which grows. Two baselines are worth keeping apart, because I conflated them myself on the first pass:

If you evaluate denoise or upscale settings by comparing to the previous step, you will systematically pick the setting that destroys the most detail — because destruction is what makes the next step cheap. Always keep an untouched copy as the reference.

Reproduce it

Self-contained: builds the fixture, makes both cuts, then prints which source frames survived. On ffmpeg 6.1.1 this prints n=27 first=25 last=51 and n=20 first=32 last=51 for the two modes.

import numpy as np, subprocess

W, H, N, BLK = 320, 180, 300, 20          # 300 frames, 9-bit index patch

def frame(i):
    yy, xx = np.mgrid[0:H, 0:W].astype(np.float32)
    cx = W * (0.3 + 0.4 * i / N)                       # slow pan
    r = np.sqrt((xx - cx) ** 2 + (yy - H * 0.5) ** 2)
    g = np.clip(90 + 90 * np.exp(-(r / 90) ** 2)
                + np.random.default_rng(i).normal(0, 9, (H, W)), 0, 255)
    img = np.stack([g.astype(np.uint8)] * 3, -1)
    for b in range(9):                                  # index as black/white bits
        x0 = 2 + b * (BLK + 1)
        img[2:2 + BLK, x0:x0 + BLK] = 235 if (i >> b) & 1 else 12
    return img

enc = subprocess.Popen(["ffmpeg", "-y", "-v", "error", "-f", "rawvideo",
                        "-pix_fmt", "rgb24", "-s", f"{W}x{H}", "-r", "25", "-i", "-",
                        "-c:v", "libx264", "-crf", "18", "-g", "60", "src.mp4"],
                       stdin=subprocess.PIPE)
for i in range(N):
    enc.stdin.write(frame(i).tobytes())
enc.stdin.close(); enc.wait()

for tag, args in {"before-i": ["-ss", "1.0", "-to", "2.0", "-i", "src.mp4"],
                  "after-i":  ["-i", "src.mp4", "-ss", "1.0", "-to", "2.0"]}.items():
    subprocess.run(["ffmpeg", "-y", "-v", "error"] + args + ["-c", "copy", f"{tag}.mp4"],
                   check=True)

def read(p):                                            # which source frames survived
    raw = subprocess.run(["ffmpeg", "-v", "error", "-i", p, "-f", "rawvideo",
                          "-pix_fmt", "gray", "-"], capture_output=True).stdout
    out = []
    for f in np.frombuffer(raw, np.uint8).reshape(-1, H, W):
        bits = 0
        for b in range(9):
            x0 = 2 + b * (BLK + 1)
            if f[6:18, x0 + 4:x0 + 16].mean() > 128:
                bits |= 1 << b
        out.append(bits)
    return out

for tag in ("before-i", "after-i"):                     # want 25 frames, 25..49
    ids = read(f"{tag}.mp4")
    print(f"{tag:9s} n={len(ids):2d} first={ids[0]:2d} last={ids[-1]:2d}")

Order still beats hardware

A better GPU does not fix wrong ordering. Enlarging first teaches the model the compression blocks and enlarges them too. Do it this way instead:

  1. Denoise, targeting compression artifacts not sensor grain
  2. Enlarge at most 2x per axis
  3. Inspect at 100% on a hard edge
  4. Grade last

Past roughly 2x the model starts inventing instead of reconstructing. Faces go waxy, small text becomes letter-shaped strokes. A 540p source at 2x reaches 1080p, which is enough for anything watched on a screen.

Compression noise is not grain. The block grid is structure, grain is random. A generic denoiser leaves the grid and the upscaler amplifies it.

What the presets are for

Social Denoise preset result, block grid removed before enlarging
Social Denoise — the compressed-clip case.
Portrait Studio preset result, hair edge intact at 100 percent
Portrait Studio — hair edge at 100%.
Natural preset result, balanced detail with texture kept
Natural — general photos, no visible processing.
Anime 2D preset result, line art kept clean
Anime 2D — flat fills, hard edges, no invented texture.
True Texture preset result, fabric grain retained
True Texture — damage in the surface rather than the subject.

Frequently asked

Can you upscale images without a GPU?

Yes, by processing on someone else's hardware. A cloud upscaler runs the model remotely and returns the result to your browser. The tradeoff is upload limits.

Is a cloud upscaler as good as a local one?

For short files the model quality can be identical — same class of model, better hardware. Cloud is limited by size and time caps, not by quality.

What upload limits should you expect?

Expect tight ones. UpgoLAB takes photos to 4 MP and clips to 30 seconds, then deletes files after an hour.

How long does a cloud upscale take?

A photo is usually under a minute. A 30 second clip takes longer because every frame is processed.

Does upscaling on a phone damage the file?

No. The phone only uploads and downloads; processing happens at full resolution on the server.

Where to run it

UpgoLAB is the cloud option described here — eight presets by damage type, free during launch, no card, no watermark. Drop a file and it runs on a remote GPU, so the hardware section above is somebody else's problem.

If you do own a GPU and need longer files: comparison with Video2X, Upscayl and Topaz. What is actually fixable in a blurry clip: blurry video guide.