You’re sitting in front of your restored Commodore 64 or vintage game console, connected to a modern flat-panel TV via HDMI. The image looks… flat. Soft. The scan lines you remember from childhood arcade cabinets are gone. Pixels that were once sharp and defined now blur into each other, and the whole thing feels divorced from what you know it should be.
So you start researching upscalers. You see names like the Framemeister, the OSSC (Open Source Scan Converter), the Retrotink, marketing language about “line doubling” and “zero-lag processing.” Some cost $150. Some cost $500. All claim to restore what your retro hardware is supposed to look like.
Here’s the problem: most of what you’ll read online is either marketing copy or nostalgic mythology dressed up as technical fact. Upscalers do genuinely improve retro gaming on modern displays—but not magically, and not all equally. The difference between a good one and a mediocre one isn’t always visible in YouTube videos, and the difference between what an upscaler can do and what you’ll actually see depends on specific, measurable factors that almost nobody explains clearly.
This article explains the actual physics of why retro games look wrong on modern TVs, what upscalers actually do to fix it, and how to honestly evaluate whether one is right for your setup. No mysticism. No vague claims about “accuracy.” Just the engineering.
## Why retro games look wrong on modern displays
The mismatch between your vintage game hardware and a modern flat-panel TV isn’t a simple problem with a simple cause. It’s the collision of two completely different video architectures, each optimized for the hardware of its era.
Your NES, Sega Genesis, Atari 2600, or Commodore 64 outputs video at a very low resolution—typically 256×224 to 320×240 pixels. It also outputs that video at 60 Hz interlaced on NTSC systems (or 50 Hz PAL). The signal is analog. It doesn’t have a fixed native resolution the way modern digital displays do.
A modern 1080p or 4K TV is built around a digital grid of fixed pixels—usually 1920×1080 or 3840×2160. It expects a digital signal that matches those dimensions. When you feed it a 256-pixel-wide image, the TV’s scaler circuitry has to make a decision: how do I expand this to fill the screen?
The TV’s built-in scaler does something mathematically simple but visually jarring. It stretches the image using bilinear interpolation or basic nearest-neighbor scaling. For a 256-pixel image on a 1920-pixel display, that means each original pixel becomes roughly 7–8 modern pixels wide. But here’s the catch: the scaling isn’t perfectly uniform. The TV doesn’t know that those pixels were meant to be perfect squares. It just sees numbers and stretches them.
The result: blurry edges, uneven pixels, and lost detail. The scan lines—those horizontal black lines between rows of pixels that were a natural artifact of CRT display technology—disappear entirely because the TV is trying to make a “clean” picture.
This is where upscaling comes in. An upscaler sits between your retro console and your TV. It takes that low-resolution analog video signal, converts it to digital, applies intelligent scaling algorithms, and outputs a signal your TV recognizes—usually at a standard resolution like 1080p or 1440p.
The key word is intelligent. A good upscaler doesn’t just stretch pixels. It attempts to preserve the original intent of the image while making it large enough for a modern screen. It can add scan lines back in if you want them. It can ensure that pixel edges stay sharp. It can handle the timing and synchronization challenges that most consumer TVs ignore.
## The core engineering problem: analog-to-digital conversion and timing
Here’s where things get technically precise, and why not all upscalers are created equal.
When a Commodore 64 or NES outputs video, it’s sending an analog signal—usually composite, S-video, or RGB. That signal contains color information and brightness information mixed together in a waveform. The console doesn’t “know” about pixels in the way modern digital systems do. Instead, it sends a continuous signal timed to specific hardware clock cycles.
Converting that analog signal to digital requires precise timing and sampling. The upscaler’s analog-to-digital converter (ADC) has to sample the voltage of that waveform at exactly the right moments to capture the intended pixel data. Sample too early or too late, and you get artifacts—slight color shifts, jitter, or horizontal ghosting.
This is why the quality of the input connection matters enormously. An S-video cable preserves luminance and chrominance (brightness and color) separately, which is cleaner than composite video, which mixes them together. RGB input (either through SCART or component cables) is even better because it separates the three color channels completely and avoids the composite signal’s inherent bandwidth limitations.
The upscaler also has to handle de-interlacing. Those old consoles output interlaced video: odd-numbered scan lines in one frame, even-numbered lines in the next. Your TV’s built-in scaler tries to handle this, but it does so without knowing anything about the original image content. A dedicated upscaler can use temporal information—data from multiple frames—to reconstruct the full resolution more intelligently.
Then there’s the timing and synchronization problem. Your console outputs video at 60 Hz (or 50 Hz), with specific timing for horizontal and vertical sync pulses. Your modern TV expects data in digital form at its native refresh rate. The upscaler has to bridge that gap—capture the analog signal at the console’s timing, buffer it, and output it at the TV’s timing without introducing lag.
This is critical for gaming, where input lag is noticeable. A cheap or poorly-designed upscaler might introduce 2–4 frames of delay. A good one keeps it under a frame, which is usually imperceptible (under 16 milliseconds at 60 Hz).
## What makes upscalers different: algorithms and video processing
Several companies make HDMI upscalers for retro gaming. The major ones include:
**The Retrotink** (various models—the Retrotink 2x, 5x, and newer Pro variants) uses advanced motion-adaptive deinterlacing, sharp scaling algorithms, and allows user adjustments for different console outputs. The 5x model added HDR support and higher-quality ADC circuitry. The newer Pro model targets even lower latency.
**The OSSC (Open Source Scan Converter)** takes a different approach: line-doubling and line-quadrupling using integer-ratio scaling. This preserves pixel-perfect aspect ratios for lower resolutions but requires your TV to support non-standard input formats like 1440p or 2880×240.
**The Framemeister** is an older device (now out of production) that was the original dedicated upscaler for retro gaming. It pioneered many of the techniques now used in modern upscalers.
**The Xcalibur** and other emerging products focus on reducing input lag and improving HDR handling.
The real differences come down to a few key parameters:
ADC quality and input impedance matching: The analog-to-digital converter’s sampling rate and bit depth. Lower-quality ADCs introduce subtle noise or color inaccuracy. The input circuit also needs to be impedance-matched to the cable to avoid reflections that cause jitter.
Deinterlacing algorithm: Does it use motion detection? Field blending? Temporal interpolation from previous frames? Better algorithms produce smoother results when handling interlaced content but may introduce slight blur.
Scaling algorithm: Does it use nearest-neighbor (pixel-perfect but blocky for non-integer scaling), bilinear interpolation (smooth but blurry), or more sophisticated methods like Lanczos filtering (sharp with minimal artifacts)? Different upscalers choose different trade-offs.
Output format flexibility: Can it output at 1080p, 1440p, 2160p, or multiple formats? Can it add scan lines? Can it adjust aspect ratio? The more flexibility, the better it can match your specific setup.
Frame buffering and latency: How much internal buffering does the device use? More buffering allows for better processing but introduces lag. The best upscalers minimize this by using smart architecture.
The honest truth: none of these differences are invisible. A skilled eye watching a side-by-side comparison can see them. But for most people, most of the time, a decent $150–250 upscaler looks noticeably better than a TV’s built-in scaler, and the difference between a $250 upscaler and a $500 upscaler is smaller than marketing language would suggest.
## Practical factors that matter more than you think
Here’s what nobody tells you: the upscaler isn’t the whole equation. Several other factors can be just as important.
Your input source quality: If you’re feeding the upscaler a composite signal from a console that hasn’t been cleaned, that has a damaged video buffer chip, or that’s outputting through a crappy aftermarket cable, the upscaler has garbage to work with. You can’t polish mud. This is why maintaining your console’s hardware integrity matters—a degraded video output chip will affect what the upscaler can recover.
Your TV’s input lag and response time: The upscaler outputs a clean signal, but your TV then has to process it again. Some TVs have “game mode” settings that reduce input lag. Some are just naturally fast. If your TV adds 3–4 frames of lag, and your upscaler adds 1–2 frames, you’ve got a total of 4–6 frames—noticeable for any fast-action game.
Cable quality: Not magical, but real. A shielded RGB cable or S-video cable with proper grounding will have less noise and jitter than a cheap composite cable. The upscaler’s ADC will capture a cleaner signal.
Your display’s native resolution and panel type: A 1440p monitor or projector naturally handles OSSC output (which is 1440p-native) without additional scaling. A 1080p TV will then need to scale that 1440p image down or up, which introduces another layer of processing. For gaming, a fast 1440p display (IPS or TN panel, not VA) is actually better than a 4K TV with slow response times.
Firmware updates: Modern upscalers receive firmware updates that improve algorithms. A Retrotink from 2022 is noticeably better than one from 2020, even with the same hardware, because the software has improved.
## Evaluating upscalers: what to actually measure and test
If you’re considering an upscaler, here’s what to objectively evaluate rather than relying on online hype.
Test your console’s output first. Take a photo of your console’s output on a CRT monitor or arcade-style display (if you have access). This is the visual truth—what the original designers saw. This becomes your reference.
Measure input lag. Use a tool like Leo Bodnar’s input lag tester or a simple stopwatch-and-camera method: display an on-screen timer on your console through the upscaler, film it on your phone’s slow-motion camera, and measure the delay between when the console’s internal counter changes and when it appears on your TV. Anything under 1 frame (16 milliseconds at 60 Hz) is imperceptible for most games. Anything over 3 frames is noticeable.
Check for jitter and artifacts. Display a static image—a solid color or a test pattern—through the upscaler. Look at the edges of sprites and text. Are they smooth or do they shimmer slightly? Jitter indicates timing synchronization issues.
Test motion quality. Play a game with horizontal scrolling (like Sonic or Mario) and watch how smoothly it moves. Poor deinterlacing will produce combing artifacts or flicker.
Verify color accuracy. Many upscalers allow you to adjust color settings. Use a test image with known colors—the Genesis boot screen is good—and see if the upscaler’s output matches the console’s original color palette.
Check audio pass-through quality. If the upscaler has audio inputs, make sure it’s not introducing noise or distortion. Listen for hum (50/60 Hz), hiss (broadband noise), or crackling.
## Real-world performance: what you actually get at different price points
**Under $100**: You’re looking at older used Framemeisters, second-hand Retrotinks, or newer budget options from smaller manufacturers. Expect decent upscaling, but possibly older ADC technology, limited output formats, or minimal user control. Input lag is usually acceptable (under 2 frames). Good for budget setups, acceptable quality.
**$150–250**: The Retrotink 2x sits here. You get solid ADC quality, reasonable deinterlacing, support for multiple input types, and good output flexibility. This is the sweet spot for most people. Input lag is typically under 1.5 frames. Noticeably better than TV scalers.
**$300–400**: The Retrotink 5x and higher-end options. You’re paying for better ADC circuitry, more advanced deinterlacing, HDR support, and more user adjustments. The difference is measurable but not always dramatically visible. Good if you’re a perfectionist or plan to use this upscaler for 10+ years.
**$500+**: Cutting-edge options or specialized equipment. You’re paying for research and development, small production runs, and extreme feature sets. For most hobbyists, the marginal improvement doesn’t justify the cost.
For vintage gaming specifically, a $150–250 upscaler will solve 85–90% of the visual problems you have. The remaining 10–15% requires either more expensive equipment or tweaking multiple parts of your setup simultaneously.
## The OSSC path: a different philosophy
The OSSC (Open Source Scan Converter) deserves its own discussion because it works differently than other upscalers.
Instead of attempting intelligent scaling, the OSSC uses integer-ratio line doubling and line quadrupling. For a 256-pixel-wide console output, it scales by exactly 2x or 4x, creating 512 or 1024-pixel output. For the vertical axis, it doubles or quadruples scan lines, creating perfect pixel squares.
This is mathematically simpler but requires your display to accept non-standard resolutions like 1440p or 2880×240 (quad-width, single-height). Many modern displays support this, but not all.
The advantage: pixel-perfect scaling with zero interpolation artifacts. The disadvantage: it doesn’t smooth image quality or add anti-aliasing, so interlaced content looks more jagged, and you need a display that supports those specific resolutions.
The OSSC also uses passthrough mode for certain functions, meaning it doesn’t add processing—just conversion. This keeps latency extremely low (under 1 frame).
For a retro purist with the right display setup, the OSSC is excellent. For someone with a standard 1080p TV, a Retrotink is more practical.
## Hidden complexity: what happens with different consoles
Different consoles output video differently, and upscalers handle them with varying degrees of success.
**NES and SNES**: Output 256-wide video (NES) or 256–320 (SNES depending on the game). Most upscalers handle these extremely well. Integer scaling works great here.
**Genesis**: Outputs 320 pixels wide. When scaled to 1080p, this doesn’t fit perfectly (1920 / 320 = 6x). Upscalers have to choose between non-integer scaling (slight blurring) or outputting at a non-standard resolution. This is one reason the OSSC’s flexibility is valuable—it can output at 1440p (1440 / 320 = 4.5x, closer), or 1920×1440 mode on supporting displays.
**Commodore 64**: Outputs 320 pixels but at a different aspect ratio and with unique timing. Some upscalers have specific firmware modes for this.
**Arcade hardware**: Varies wildly. Some arcade boards output 224-line video, some 240-line. The OSSC has multiple profiles for different arcade boards. Standard upscalers are more generic.
This is why testing with your specific console matters. An upscaler might be rated excellent for Genesis but just okay for Commodore 64 if you own an unusual revision.
## When not to buy an upscaler (and what to do instead)
Upscalers aren’t always the right solution.
If you have access to a quality CRT display—a vintage arcade cabinet, a decent-quality CRT TV, or a CRT monitor—upscalers are largely unnecessary. The original hardware was designed for CRT displays, which handle analog signals natively and naturally display scan lines. A CRT will make your retro hardware look correct with no extra equipment.
If your console’s video output is degraded or failing, an upscaler won’t fix it. You’ll be upscaling garbage. In this case, repairing or replacing problematic video output chips comes first.
If you care more about playing games comfortably than having period-correct visuals, your money might be better spent on a high-quality emulator setup with a modern gaming PC and nice controller. Emulation offers far more features, no hardware degradation, and lower latency on some games.
If your TV has terrible input lag (common on budget models), an upscaler won’t help. A TV upgrade (or adding a low-lag display) is the better move.
## The practical checklist: is an upscaler right for you?
Ask yourself these questions:
1. Do you own physical retro hardware you want to play on a modern TV? (If no, stop here—upscalers are for this scenario.)
2. Does your console have a quality output (RGB, S-video, or composite from a well-maintained unit)? (If no, repair first.)
3. Is your TV’s input lag under 50 milliseconds? (Check the TV’s specs or test it. If worse than 50ms, upgrade the display first.)
4. Do you have access to the right input cables (RGB SCART, S-video, or at least quality composite)? (If not, buying those cables first is cheaper and nearly as important as the upscaler.)
5. Are you willing to spend $150+ and accept that the upscaler won’t be magic—it’ll be a noticeable but not revolutionary improvement? (If you expect perfect 4K restoration of NES graphics, you’ll be disappointed.)
If you answered yes to most of these, an upscaler is a good investment. Budget $150–250 for something like a Retrotink 2x, or explore the OSSC if you have a compatible display.
If you answered no to most of these, invest in cables, display quality, and console maintenance first. The upscaler’s improvement will be meaningless if the foundation is weak.
## Final perspective: what upscalers actually are
An HDMI upscaler for retro gaming is an intelligent analog-to-digital converter with specialized scaling algorithms. It solves a specific, real problem: the mismatch between low-resolution analog video hardware and high-resolution digital displays.
It’s not magic. It can’t make an NES game look like a modern remaster. What it does—well—is make your retro hardware look like it was intended to look when viewed on period-accurate CRT hardware, but scaled to fit a modern screen without blurring or distortion.
That’s actually quite valuable. It’s the difference between your childhood game console looking muddy and soft on your new TV, or looking sharp and defined with clean pixels and readable text.
The honest test: if you spend 20 minutes playing a game through a decent upscaler, then switch to your TV’s built-in scaler, you’ll immediately see the difference. Your eyes will tell you it’s worth the money. Whether it’s a $150 upscaler or a $500 one depends on whether you’re a perfectionist, how long you plan to use it, and whether you enjoy tweaking settings.
For most people, $150–250 solves the problem completely.