Table of Contents
Have you ever connected a 4K and a 1080p monitor to your Linux system and noticed apps look… weird? Maybe one window is way too tiny, while another looks blurry or stretched out of proportion?
If that sounds familiar, you’re not alone—and Wayland has a solution. Let’s explore how Wayland handles multi-monitor setups with different resolutions, and why it does a much better job than X11 in this area.
The Problem: Mixed Monitor Setups
High-resolution monitors like 4K are becoming common, but they can create headaches when paired with older or lower-resolution screens like 1080p. You might run into strange scaling issues, where apps don’t look right depending on which monitor you move them to.
To understand why this happens, we first need to talk about how content is rendered on your screen.
Logical vs Physical Pixels
When developers design apps, they use logical pixels. These are like “virtual” units that define the size and layout of buttons, text, and images—without knowing what kind of screen the app will run on.
But your screen works in physical pixels—tiny dots of light that actually display the image. So, there’s a translation process from logical pixels (design) to physical pixels (display), and that’s where scaling comes in.
What Is Scaling?
Scaling is the process of converting logical pixels into physical ones, so things look the right size across different monitors. For example:
- On a 1080p monitor (100% scaling), 1 logical pixel = 1 physical pixel.
- On a 4K monitor (200% scaling), 1 logical pixel = 4 physical pixels (in a 2×2 grid).
Without scaling, text and UI elements on a 4K screen would be tiny and hard to read.
Resampling: The Hidden Culprit
Now here’s a twist—besides scaling, there’s resampling.
Resampling happens when an image is already rendered and then resized. That’s when things can get blurry.
- Upsampling adds pixels by guessing what they should look like (often results in blur).
- Downsampling removes pixels and averages nearby ones (can lose detail).
Resampling is not ideal. It changes the rendered image after it’s been created, and that’s often where things go wrong.
Scaling vs Resampling (Quick Recap)
| Process | When It Happens | Quality Outcome |
|---|---|---|
| Scaling | During rendering | Sharp visuals |
| Resampling | After rendering | Often blurry or distorted |
How X11 Handles It
In the X11 world, there’s one global DPI (dots per inch) setting—usually 96 DPI. This global setting is used to render the app’s content once, regardless of how many monitors you have or what their resolution is.
If your monitors differ in resolution, X11 ends up resampling that single image buffer to make it “fit.” That’s why things look blurry or oddly sized—it’s trying to stretch or shrink a one-size-fits-all image.
How Wayland Does It Better
Wayland flips the model.
Instead of rendering content once and stretching it across all displays, Wayland tells the application about each monitor’s scaling factor, and the app renders a separate image buffer for each one. So, every monitor gets content that’s natively scaled and sharp.
No stretching, no guessing, no blur.
Why This Works: App Awareness
Under Wayland:
- The compositor tells the app: “Hey, this monitor needs 200% scaling.”
- The app renders the content specifically for that monitor.
- Each monitor gets its own pre-scaled image buffer.
Under X11:
- The server handles rendering using one DPI setting.
- Scaling happens after the fact through resampling.
- Monitors share the same buffer, even if they shouldn’t.
Why You Still Might See Issues on Wayland
Even though Wayland handles scaling better, it’s not perfect. You might still run into a few common problems:
1. 🧩 Application Support
Some older or less-maintained apps may not fully support Wayland’s per-monitor scaling.
Issue: The app may ignore scaling instructions and render everything too small or too large.
Solution: Use Wayland-native or updated applications whenever possible.
2. 🧮 Fractional Scaling (e.g. 125%, 150%)
Wayland handles whole-number scaling (like 100%, 200%) well. But fractional scaling is still inconsistent across different desktops.
Example:
- You set 150% scaling.
- The app renders at 200% (a safe integer).
- The compositor downscales the image to 150%, causing minor blurriness.
Solution: Test your setup with fractional scaling on and off to see what looks better.
3. 🖥️ Compositor Limitations
Not all Wayland compositors behave the same. Some (like KDE) have more mature scaling support than others.
Solution: Try different compositors (e.g., KDE Plasma, GNOME, Sway) to see which one handles your setup best.
4. 🎮 GPU Driver Issues
Your GPU driver must support Wayland features correctly—this can be a problem especially with proprietary drivers like NVIDIA’s.
Solution: Keep your drivers, system packages, and desktop environment up to date.
Final Thoughts
Wayland’s design finally gives us proper scaling on Linux, especially when using mixed-resolution monitor setups. Instead of a one-size-fits-all image that gets stretched or squished, each monitor gets the attention it deserves—with sharp visuals and no weird distortion.
Check out the YouTube version of this explanation for a visual breakdown. Thanks for reading!
Leave a Reply