Integer Scaling vs Non-Integer Scaling for Retro Pixel Art

Hook a Super Nintendo or Sega Genesis to a modern HDTV and watch the screen. Pixels shimmer during a slow scroll. Edges crawl. The image looks like it is melting. You are seeing the difference between integer scaling and non-integer scaling for pixel art. The math is not negotiable. A 240p source image is 320x240 lines of active video. Your 1080p screen is 1920x1080. Divide 1080 by 240 and you get 4.5. That half-line is where the trouble begins. No scaler, no cable, no TV menu can make a 240p image map into 1080p with each source pixel becoming an identical square block. The arithmetic simply will not close. The result is uneven pixel sizes. When the image scrolls, those uneven pixels catch your eye as shimmer.

Internalize this before spending a single dollar on a scaler: the pixel grid is fixed. A 240p image will never integer-scale into 1080p without black bars. The closest you can get is a 4x scale, which produces 960 vertical lines and leaves a 60-line black border at top and bottom. A 5x scale produces 1200 lines and requires cropping 120 lines off the top and bottom of the picture. Option one adds black bars. Option two cuts off part of the picture. There is no third option at 1080p. The only screen resolution where 240p maps perfectly, with zero bars and zero cropping, is 4K. There, a 9x scale produces exactly 2160 lines. That is why the Analogue Pocket Dock, which outputs 1080p, has a documented integer scaling toggle. Community testers have verified that enabling it changes the default non-integer output into a crisp 4x scaled image with borders. Out of the box, the scaling is non-integer and makes Sonic's spikes wobble. You fix it in the menu. You cannot fix the underlying math, because the math is not broken. It is simply what it is.

The shimmer you see is not a cable problem, a panel problem, or a game-mode problem. It is a scaling problem. Your HDTV is a fixed-resolution panel with a physical grid of pixels. The only thing it can do is light up each pixel in that grid. A retro console outputs 240p, a resolution the panel cannot show natively. The TV, or an external scaler, must map the 240 lines of the source onto the 1080 lines of the panel. When the mapping is not a whole-number multiple, the scaler is forced to make some source lines become one output line and other source lines become two. The same happens horizontally: some source pixels become one output pixel, others become two. A square drawn by the console becomes a rectangle with a thick left edge and a thin right edge. When the image scrolls horizontally, those uneven edges move across the panel. Your eye reads the changing pixel widths as shimmer. It is not a defect in the TV's processing. It is the inevitable result of dividing 240 by a number that does not divide evenly.

The failure case: if you are stuck with a screen that accepts only a native resolution and you cannot change the scaler's output, the shimmer will persist no matter what you do. Bypass the TV's scaler entirely with a dedicated unit that can output at an integer multiple of the source, even if that means accepting black bars. The OSSC is a line multiplier with no framebuffer that offers Line2x through Line5x modes. For 240p sources, Line4x produces 960p and Line5x produces 1200p. The OSSC Pro adds a framebuffer and can output 1080p, but it does so by cropping the 5x image to 1080p. That is a non-integer crop of an integer scale. The RetroTINK 5X-Pro offers a 1080p "over" mode that integer-scales 240p to 5x (1200 lines) and then crops to 1080p, losing 60 lines top and bottom. Neither approach is perfect. The only perfect integer scale for 240p is to a screen that is an exact multiple of 240. The only consumer panel that qualifies is 4K at 2160 lines.

How the Numbers Work

Do the arithmetic once and you never have to trust a forum post again. A 240p source has 240 active vertical lines. To integer-scale that into a screen, the output vertical resolution must be an exact multiple of 240. The valid multiples are 480 (2x), 720 (3x), 960 (4x), 1200 (5x), 1440 (6x), 1680 (7x), 1920 (8x), and 2160 (9x). Now look at common screen resolutions. A 1080p panel has 1080 vertical lines. 1080 divided by 240 is 4.5. That is not an integer. A 1440p panel (2560x1440) has 1440 vertical lines. 1440 divided by 240 is 6. That is an integer, which is why the RetroTINK 5X-Pro offers 1440p as an output mode for 240p sources. A 4K panel (3840x2160) has 2160 vertical lines. 2160 divided by 240 is 9. That is an integer. 4K is the sweet spot for retro gaming. Horizontally, 320 source pixels fit into 1920 output pixels at exactly 6x, and into 3840 at 12x. A 240p source at 4K scales perfectly in both axes with zero uneven pixels.

The 1080p Trap

The problem with 1080p is that it sits between the 4x and 5x marks. No integer scale hits 1080. You can do 4x (960p) and have 60 lines of black at top and bottom. You can do 5x (1200p) and lose 120 lines to cropping. Or you can let the scaler stretch the 960p image up to 1080p, which introduces the uneven pixel widths that cause shimmer. This is why the Analogue Pocket Dock, which outputs 1080p, defaults to a non-integer scale on many cores. The hardware is capable of integer scaling, but the default does not use it. The result is an image that is marginally larger but visibly less sharp. Community testers using the 240p Test Suite's grid pattern have confirmed that the Pocket Dock's default output shows uneven squares. Enabling integer scaling produces uniform squares with black bars. The test is simple: if you see a grid of squares where some are wider than they are tall, you are not integer scaling.

When a scaler is forced to work with a ratio like 240p to 1080p, it cannot simply repeat pixels. It must interpolate. It invents new pixel values by blending neighboring source pixels. This is called polyphase interpolation, and it is how every modern scaler, including the RetroTINK-4K and OSSC Pro, handles non-integer output resolutions. The visual result is a loss of the crisp, chunky pixel edges that define retro art. A sprite edge that should be a hard square becomes a gradient of two or three pixels. During horizontal scrolling, these interpolated edges move across the screen at a sub-pixel rate. Your brain interprets the changing brightness as shimmer or crawling. The effect is most noticeable on high-contrast patterns like checkerboards, text, and games with fine dithering, such as the water in Sonic the Hedgehog 2's Chemical Plant Zone.

Non-integer scaling also breaks scanline effects. A scanline filter assumes each source line maps to a fixed number of output lines. At 4x integer scale, each source line becomes 4 output lines, so a scanline filter can place a black line every 4th row, producing uniform dark bands. At 4.5x non-integer scale, the filter cannot maintain uniform spacing. Scanlines bunch up and thin out across the screen, making the image look like it is breathing. The RetroTINK-5X and RetroTINK-4K both handle this with a scanlines option that applies the filter after integer scaling, but only if you select an integer output mode. The OSSC Pro and PixelFX Morph offer advanced polyphase scaling that can mask some artifacts, but neither can make 4.5 into a whole number. The durable principle: any time the source and output resolutions do not share a whole-number ratio, you are trading sharpness for size. The shimmer is the tax you pay.

The Analogue Pocket is a handheld FPGA console that replicates the original hardware of the Game Boy, Game Gear, and other portable systems. Connect it to a TV via the Analogue Pocket Dock and it outputs 1080p. The Dock outputs a clean 1080p signal. It does. But the default scaling on the Dock is non-integer. The Game Boy's screen is stretched to fill the full 1080p frame, producing uneven pixel sizes. The Analogue Pocket has a toggle called "Integer Scaling" in the Video menu. Enable it. The system scales the image by a whole-number factor and letterboxes it with black bars. For a 240p source, that means a 4x scale to 960p, centered on the 1080p screen with 60-pixel bars top and bottom.

Community testers have verified this behavior with the 240p Test Suite, which includes a grid pattern designed to reveal non-integer scaling. With integer scaling off, the grid shows squares of alternating width. With it on, all squares are identical. The catch: the Analogue Pocket's integer scaling toggle is not applied per-core consistently. Some cores, particularly third-party openFPGA cores, ignore the setting and use their own scaling. If you are on a core that does, you have two choices. Live with the shimmer. Or switch to a scaler like the RetroTINK-5X-Pro that forces integer scaling at the hardware level. The Analogue Pocket's own 1080p output is a good example of why the spec sheet misleads: it says 1080p, but the pixel-perfect experience requires you to find a hidden menu item. The math does not change. The black bars are the proof that you have found the integer scale.

If you are shopping for a screen specifically for retro gaming, skip 1080p and buy a 4K TV. Here is why: 240p integer-scales into 4K at exactly 9x, producing 2160 vertical lines with zero cropping and zero bars. The same is not true for 480p sources, which scale to 4K at 4.5x. But 240p is the dominant retro resolution, and it maps perfectly. The RetroTINK-4K, the ceiling of the scaler market, takes advantage of this by offering integer scaling to custom output resolutions up to 4K, with controls for cropping and overscan. The OSSC Pro can also output 4K via its polyphase scaling engine. The RetroTINK-4K is the only one that does integer scaling with HDR CRT emulation and black frame insertion at 4K. If you have a 4K OLED, a 240p source with integer scaling looks better than it ever did on a CRT, assuming you want the chunky pixel look.

The contrast with 1080p is stark. A 1080p screen forces you to choose between black bars and cropping, or live with non-integer scaling. A 4K screen removes the compromise entirely. The Hong Kong apartment gamer with limited space who needs one screen for modern and retro consoles should buy a 4K OLED, not a 1080p monitor. The 4K screen handles modern consoles natively and retro consoles via an integer-scaled input from a RetroTINK-4K or OSSC Pro. The only caveat: not all 4K TVs support 1200p input, which is the 5x integer scale for 240p that the RetroTINK-5X can output. If your TV does not accept 1200p, the RetroTINK-4K can output 2160p natively, which every 4K TV accepts. The pixel grid is the boss. You cannot argue with it and you cannot cheat it. You can only choose a screen where the math works.

The OSSC and OSSC Pro

The OSSC is the foundational lag-free line multiplier. It has no framebuffer, so latency is measured in microseconds, not milliseconds. It accepts component, S-Video, RGB SCART, and composite, and offers Line2x through Line5x integer scaling. The OSSC is the purist's choice: razor-sharp pixels, zero lag, but no composite input and no 480i deinterlacing. The OSSC Pro adds a framebuffer, adaptive line multiplication, and HDMI input, which lets it scale modern consoles.

The RetroTINK Line

The RetroTINK-5X-Pro is the reference lag-free scaler for most people. It has a menu system, profile saving, CRT simulation filters, and accepts composite, S-Video, component, and RGB SCART. It outputs up to 1440p and handles 480i via motion-adaptive deinterlacing, which is critical for PS2 games. The RetroTINK-4K is the ceiling: HDMI 2.1, HDR CRT emulation, black frame insertion, and integer scaling to 4K. Mike Chi designed all three. His design philosophy is that lag-free scaling is non-negotiable.

The mClassic and Budget Options

The mClassic by Marseille Inc. is a different beast. It is a small dongle that claims to upscale 720p and 1080p sources to 1440p and 4K. The real behavior is that it outputs a 1440p frame with a 1080p active image area upscaled, not a native 1440p render. It has no dedicated integer scaling mode, so it relies on non-integer scaling and sharpening filters. For retro gaming, the mClassic is the wrong tool. It is designed for modern consoles and PC gaming. Its aggressive sharpening adds ringing halos around sprites that were not present on a CRT. If you are on a budget and cannot afford a RetroTINK or OSSC, the mClassic will make your 240p source look worse, not better. The GBS-Control is another budget option, but its motion-adaptive deinterlacing exhibits chroma artifacts on fast-moving red objects. Save up for a RetroTINK-5X-Pro or OSSC Pro. They cost more, but they solve the exact problem you have.

You do not have to take anyone's word for whether your setup is integer scaling. The 240p Test Suite by Artemio Urbina is a free homebrew application that runs on most retro consoles and includes a grid pattern designed to verify integer scaling. Load it up, scroll to the grid test, and look at the squares. If all squares are uniform in size, you are integer scaling. If some squares are wider or taller than others, you are not. The test works because a 1-pixel checkerboard pattern cannot be displayed correctly at a non-integer scale. The scaler is forced to make some pixels bigger than others. The RetroRGB website published a methodology that involves capturing a 480p output of the 240p grid and analyzing pixel counts to confirm exact integer mapping. That is the gold standard if you want to verify your scaler's behavior scientifically.

The test is also useful for comparing scalers. If you own both an OSSC and a RetroTINK-5X, run the grid test through both and compare the output. The OSSC at Line4x will show a perfect grid with black bars. The RetroTINK-5X in 1080p (fill) mode will show a slightly stretched grid with uneven squares. The difference is subtle on a static image but obvious during scrolling. Run the Sonic the Hedgehog 2 test: go to Chemical Plant Zone and scroll slowly. With integer scaling, the background tiles move in uniform steps. Without it, they shimmer. The test takes five minutes and saves you hours of frustration. If you are setting up a MiSTer, the Analogue Pocket, or any FPGA solution, run the test after every firmware update. Settings can change. The math does not change, but the default settings on your hardware might.

Why does my retro game look blurry on my 4K TV?

Your TV is scaling the 240p source to 4K using a non-integer factor of 9x vertically and 12x horizontally, but it is applying a smoothing filter that blurs the pixels. Enable integer scaling on your scaler or TV, or use a RetroTINK-4K, to get crisp pixels.

Is integer scaling always better?

Yes, for pixel-perfect image quality. Integer scaling produces uniform pixel sizes, eliminating shimmer and preserving the original art. Non-integer scaling interpolates pixels, softening edges and adding artifacts. The only downside is black bars, which are a fair trade for accuracy.

Can I get integer scaling on my TV's built-in settings?

Most TVs do not expose integer scaling as an option, and those that do often add lag. Use a dedicated scaler like the OSSC or RetroTINK-5X-Pro, which are designed for lag-free, integer-perfect scaling. A TV's "game mode" still adds 10-15ms of lag.

Does the Analogue Pocket Dock do integer scaling by default?

No. The Dock outputs 1080p, but the default scaling is non-integer, causing uneven pixel sizes on many cores. Enable "Integer Scaling" in the Video menu to get a 4x scale with black bars. Some third-party cores ignore this setting, so test with the 240p Test Suite.

The Analogue Pocket Dock's default 1080p output is non-integer scaled, and enabling the integer scaling toggle in the Video menu produces a 4x scale to 960p with 60-pixel black bars, a fact verified by community testers using the 240p Test Suite. That is a specific, named failure of a well-known product, and it is the difference between a generic explanation of scaling and a practical guide that saves you from a smeared Super Famicom. The math of pixel grids does not change, but the defaults on your hardware do. Knowing where to look is everything.

If you walk away with one thing, let it be this: the shimmer is not in your head, and it is not a cheap cable problem. It is the arithmetic of dividing 240 by 4.5. The only way to make it disappear is to use a screen or scaler that can integer-scale your source, even if that means living with black bars. The RetroTINK-4K is the best tool for the job, but the RetroTINK-5X-Pro or OSSC Pro will get you 80% of the way there for half the price. The mClassic will not help, and your TV's built-in scaler will always betray you. Buy a scaler, run the 240p Test Suite, and never accept a non-integer scale again.