De device pixel ratio (DPR) is het aantal fysieke schermpixels dat in elke richting wordt gebruikt om één CSS-pixel te tekenen. Op een telefoon met DPR 3 wordt elke CSS-pixel getekend met een blok van 3 × 3 apparaatpixels. Daarom kan een website van 360 px breed een telefoonscherm vullen dat 1080 hardwarepixels breed is. Je kunt de jouwe controleren met window.devicePixelRatio in de browserconsole.

CSS-pixels vs apparaatpixels

CSS-pixel Apparaatpixel
Ook genoemd Logische pixel, point (iOS), dp (Android) Fysieke pixel, hardwarepixel
Gebruikt door CSS, JavaScript, ontwerptools De schermhardware
Grootte Nominaal 1/96 inch; verschilt in de praktijk Vastgelegd door de PPI van het paneel
Verandert met zoom? Ja Nee

Weblay-outs worden in CSS-pixels geschreven, zodat een lettergrootte van 16 px op elk apparaat leesbaar is. De browser vermenigvuldigt met de DPR om te bepalen hoeveel apparaatpixels oplichten.

De formule: apparaatpixels = CSS-pixels × DPR. Een iPhone van 393 CSS-px breed met DPR 3 heeft 393 × 3 = 1179 apparaatpixels in de breedte.

Gebruikelijke device pixel ratio’s

Apparaat DPR CSS-breedte Apparaatpixels in de breedte
iPhone 15 / 15 Pro 3 393 px 1179
iPhone 15 Pro Max 3 430 px 1290
iPhone SE (3e generatie) 2 375 px 750
Pixel 8 2,625 412 px 1080
Galaxy S24 3 360 px (standaard) 1080
iPad (10e generatie) 2 820 px 1640
MacBook Air (Retina) 2 1470 px (standaard) 2940 (geschaald)
Kantoormonitor 1080p 1 1920 px 1920
4K-monitor op 150% Windows-schaal 1,5 2560 px 3840

Waarden verschillen met de instellingen voor weergavegrootte. Op veel Android-telefoons kun je de DPR wijzigen via Instellingen → Weergavegrootte: een grotere weergave betekent een hogere DPR en minder CSS-pixels in de breedte.

Device pixel ratio van de iPhone per model

Apple noemt de DPR de schaalfactor: @2x of @3x. Safari meldt hem als window.devicePixelRatio. De waarden hieronder komen uit de door Apple gepubliceerde resoluties en puntgroottes (staand).

iPhone Schaal (DPR) CSS-viewport (points) Apparaatpixels PPI
iPhone XR, 11 2 414 × 896 828 × 1792 326
iPhone SE (2e en 3e generatie) 2 375 × 667 750 × 1334 326
iPhone 12 mini, 13 mini 3 375 × 812 1080 × 2340 476
iPhone 12, 12 Pro, 13, 13 Pro, 14 3 390 × 844 1170 × 2532 460
iPhone 12 Pro Max, 13 Pro Max, 14 Plus 3 428 × 926 1284 × 2778 458
iPhone 15, 15 Pro 3 393 × 852 1179 × 2556 460
iPhone 15 Pro Max 3 430 × 932 1290 × 2796 460

De iPhone 12 mini laat zien waarom DPR en PPI niet hetzelfde zijn. Hij heeft de hoogste PPI in de lijst, maar dezelfde DPR van 3 als de grotere modellen, dus zijn CSS-pixels zijn fysiek kleiner: 476 ÷ 3 ≈ 159 CSS-px per inch, tegen 153 op een iPhone 15.

Apple noemt CSS-pixels “points”: de afbeeldingen voor @2x en @3x zijn hetzelfde idee als DPR 2 en 3.

Android: dp, dichtheidsklassen en DPR

Android meet lay-outs in density-independent pixels (dp). De Android-documentatie definieert 1 dp als één fysieke pixel op een “basisscherm” van 160 dpi, dus px = dp × (dpi ÷ 160). Die verhouding is hetzelfde getal dat Chrome als devicePixelRatio meldt.

Android-dichtheidsklasse Ca. dpi Schaal (= DPR)
ldpi 120 0,75
mdpi (basis) 160 1
hdpi 240 1,5
xhdpi 320 2
xxhdpi 480 3
xxxhdpi 640 4

Echte telefoons vallen zelden precies in een klasse. De DPR van 2,625 van de Pixel 8 is een logische dichtheid van 420 dpi ÷ 160. De schermbreedte van 1080 px gedeeld door 2,625 is 411,4, wat Chrome afrondt naar een viewport van 412 CSS-px. De dichtheid is een software-instelling, daarom kan “Weergavegrootte” hem veranderen, en zulke gebroken DPR’s zijn de reden dat sommige lay-outs op Android naden van 1 pixel of iets wazige randen krijgen.

Formule: px = dp × (dpi ÷ 160). Een aanraakdoel van 48 dp op een telefoon van 420 dpi is 48 × 2,625 = 126 apparaatpixels.

Device pixel ratio vs PPI

De twee hangen samen, maar zijn niet hetzelfde:

PPI Device pixel ratio
Wat het meet Fysieke pixels in één echte inch Fysieke pixels per CSS-pixel
Bepaald door De schermhardware Het besturingssysteem en de browser
Kan veranderen? Nee Ja: zoom, schaling, weergavegrootte
Eenheid Pixels per inch Een gewone verhouding (dppx)

Twee telefoons kunnen allebei DPR 3 hebben met een heel andere PPI (de iPhone 12 mini met 476 PPI en de Samsung Galaxy S24 met 416 PPI, beide DPR 3 bij standaardinstellingen), dus hun CSS-pixels hebben een verschillende fysieke grootte. Pas beide getallen samen vertellen hoe groot een CSS-pixel echt is. Voor de PPI-kant lees je wat is PPI.

Je device pixel ratio controleren

Vier manieren, van eenvoudig tot flexibel:

  1. Browserconsole. Open DevTools (F12 op een computer, of remote debugging voor telefoons) en typ:

    window.devicePixelRatio
  2. CSS-mediaqueries. Richt je in een stylesheet op schermen met hoge dichtheid:

    @media (min-resolution: 2dppx) {
      /* stijlen voor DPR 2 en hoger */
    }

    dppx betekent “dots per CSS-pixel”, hetzelfde als de DPR. Oudere Safari-versies hebben -webkit-min-device-pixel-ratio: 2 nodig.

  3. Schermgrootte controleren. screen.width is in CSS-pixels. Vermenigvuldig met devicePixelRatio om de hardwarebreedte te schatten: 393 × 3 = 1179 op een iPhone 15. Sommige Android-browsers ronden af, dus reken op kleine verschillen.

  4. Op veranderingen letten. De DPR verandert als de gebruiker zoomt of het venster naar een andere monitor sleept. Luister ernaar met matchMedia:

    function watchDpr(onChange) {
      const mq = matchMedia(`(resolution: ${devicePixelRatio}dppx)`);
      mq.addEventListener('change', () => { onChange(devicePixelRatio); watchDpr(onChange); }, { once: true });
    }

Wat de DPR verandert

Oorzaak Effect op devicePixelRatio
De standaardinstelling van het apparaat Gekozen door de fabrikant (2, 2,625, 3 …)
Instelling “Weergavegrootte” op Android Grotere tekst en interface = hogere DPR
Schermschaal in Windows 100% → 1, 125% → 1,25, 150% → 1,5, 200% → 2
Resolutie “Ziet eruit als” op macOS Gemelde DPR blijft 2; macOS rendert groter en schaalt omlaag
Zoom in een desktopbrowser Vermenigvuldigt de DPR: 110% zoom op DPR 2 geeft 2,2
Knijpzoom op een telefoon Meestal geen verandering (het is een visuele zoom, geen lay-outzoom)
Venster naar een andere monitor slepen DPR wisselt naar de waarde van die monitor

Waarom de regel van 1/96 inch niet opgaat

De CSS-specificatie definieert 1 inch = 96 CSS-pixels. Als apparaten zich daar fysiek aan hielden, zou een iPhone van 393 px 4,1 inch breed zijn. In werkelijkheid is hij ongeveer 2,6 inch (1179 hardwarepixels ÷ 460 PPI). Telefoonmakers kiezen een DPR die tekst op armlengte prettig leesbaar houdt, niet een die CSS-inches nauwkeurig houdt.

De CSS-specificatie staat dit bewust toe. Ze definieert de CSS-pixel als een “referentiepixel” op basis van de kijkhoek, zodat een telefoon die je dichtbij houdt een kleinere fysieke pixel mag gebruiken dan een tv aan de andere kant van de kamer.

1in in CSS is dus zelden een echte inch. Dat is de belangrijkste reden dat een niet-gekalibreerde online liniaal de verkeerde grootte toont. Zie waarom online linialen onnauwkeurig zijn en Wat is PPI?

De echte grootte van een CSS-pixel berekenen

Fysieke PPI ÷ DPR = CSS-pixels per inch

Voorbeeld: iPhone 15 Pro met 460 PPI ÷ 3 ≈ 153 CSS-px per inch. Dat is ongeveer 1,6 keer de 96 px waar een naïeve liniaal van uitgaat. Eén CSS-pixel is 25,4 ÷ 153 ≈ 0,17 mm.

Apparaat Fysieke PPI ÷ DPR CSS-px per inch Eén CSS-pixel is
iPhone 15 460 ÷ 3 ≈ 153 0,17 mm
Pixel 8 428 ÷ 2,625 ≈ 163 0,16 mm
iPad (10e generatie) 264 ÷ 2 132 0,19 mm
24”-monitor 1080p 92 ÷ 1 92 0,28 mm

Kalibreren met een bankpas meet dit getal direct, inclusief eventuele schaling door het besturingssysteem. Zo toont ruleronphone echte millimeters op elk apparaat. Volg de stappen op de kalibratiepagina.

Ontwerpen voor DPR: afbeeldingen, canvas en randen

Scherpe afbeeldingen met srcset

Om scherp te ogen heeft een afbeelding evenveel bronpixels nodig als er apparaatpixels zijn. Een vak van 300 × 200 CSS-px op een scherm met DPR 3 heeft een afbeelding van 900 × 600 nodig. Laat de browser kiezen:

<img src="photo-300.jpg"
     srcset="photo-300.jpg 1x, photo-600.jpg 2x, photo-900.jpg 3x"
     width="300" height="200" alt="…">

Boven 2× is de visuele winst kleiner voor veel meer data, dus veel sites stoppen bij 2×.

Scherp tekenen op canvas

Een <canvas> die in CSS-pixels is gedimensioneerd, ziet er wazig uit op schermen met een hoge DPR. Schaal de achterliggende buffer:

const dpr = window.devicePixelRatio || 1;
canvas.width = cssWidth * dpr;
canvas.height = cssHeight * dpr;
canvas.style.width = cssWidth + 'px';
canvas.style.height = cssHeight + 'px';
ctx.scale(dpr, dpr);

Zo houdt een liniaal of grafiek zijn streepjes scherp.

Haarlijnranden

Op een scherm met DPR 2 of 3 is border: 1px 2–3 apparaatpixels dik. Voor een lijn van één apparaatpixel gebruiken sommige ontwerpen randen van 0.5px op schermen met DPR 2. Browsers ronden gebroken pixels verschillend af, dus test op echte apparaten.

Wat de DPR betekent voor meten

  • Gebruik CSS-pixels voor interfacewerk. Een pixelliniaal die CSS-pixels afleest, komt op elk apparaat overeen met je code.
  • Deel schermafbeeldingen door de DPR. Een schermafbeelding van een 3×-telefoon is in pixels drie keer zo groot als de CSS-lay-out. Een tussenruimte van 48 px op de schermafbeelding is 16 CSS-px.
  • Let op de zoom. Browserzoom verandert de DPR die de pagina ziet. 110% zoom op een scherm met DPR 2 geeft 2,2.
  • Afbeeldingen hebben 2–3× resolutie nodig. Om scherp te zijn op een scherm met DPR 3 heeft een afbeeldingsvak van 100 px een bron van 300 px nodig.
  • Gebruik echte eenheden pas na kalibratie. Om fysieke voorwerpen te meten kalibreer je eerst. Afbeeldingen en lay-outs op het scherm meten wordt behandeld in liniaal op scherm.

Omrekentabel voor schermafbeeldingen

Pixels op schermafbeelding Bij DPR 1 Bij DPR 2 Bij DPR 3
48 px 48 CSS-px 24 CSS-px 16 CSS-px
96 px 96 CSS-px 48 CSS-px 32 CSS-px
1179 px breed 1179 CSS-px 590 CSS-px 393 CSS-px

De fysieke resolutie van je scherm vinden vanuit de browser

JavaScript geeft CSS-maten, dus vermenigvuldig met de DPR om hardwarepixels te krijgen:

const physicalWidth  = Math.round(screen.width  * devicePixelRatio);
const physicalHeight = Math.round(screen.height * devicePixelRatio);
Eigenschap Wat het teruggeeft
screen.width / screen.height Schermgrootte in CSS-pixels
window.innerWidth Breedte van de lay-outviewport in CSS-pixels, inclusief schuifbalk
document.documentElement.clientWidth Viewportbreedte zonder schuifbalk
window.visualViewport.scale Knijpzoomniveau op telefoons
window.devicePixelRatio Apparaatpixels per CSS-pixel

Op een computer verandert browserzoom zowel de DPR als de CSS-maten, zodat het product dicht bij de echte resolutie van de monitor blijft. Op Windows met 150% schaling meldt een 4K-monitor van 3840 px breed screen.width = 2560 en DPR = 1,5.

De viewport-meta-tag en DPR

De DPR levert alleen een leesbare telefoonlay-out op als de pagina zich daarvoor aanmeldt. Zonder deze tag zetten mobiele browsers de pagina op een brede virtuele viewport en verkleinen ze hem tot hij past, waardoor tekst piepklein wordt. Apples Safari Web Content Guide noemt 980 CSS-px als standaardbreedte van Safari. Linialen, pixeltools en alles wat in CSS-eenheden is gedimensioneerd, hebben de tag nodig om voorspelbaar te werken:

<meta name="viewport" content="width=device-width, initial-scale=1">

Met width=device-width komt de lay-outviewport overeen met de CSS-breedte van het apparaat (393 px op een iPhone 15), en tekent de browser elke CSS-pixel met DPR × DPR apparaatpixels. De tag verandert devicePixelRatio zelf niet; hij verandert hoeveel CSS-pixels de lay-out krijgt.

DPR gebruiken in CSS: resolutiequeries en image-set()

Mediaqueries accepteren drie gelijkwaardige eenheden voor dichtheid:

Eenheid Betekenis DPR 2 is gelijk aan
dppx (of x) Dots per CSS-pixel 2dppx, 2x
dpi Dots per CSS-inch (96 CSS-px) 192dpi
dpcm Dots per CSS-centimeter ≈ 75.6dpcm

Let op: 192dpi betekent hier 2 × 96, een CSS-eenheid, niet de fysieke PPI van het scherm. Voor achtergrondafbeeldingen kiest image-set() het juiste bestand op basis van de dichtheid:

.hero {
  background-image: image-set(
    url("hero-1x.jpg") 1x,
    url("hero-2x.jpg") 2x
  );
}

Meten op het scherm met DPR

Je CSS-pixels per inch meten met een pas

Je hoeft je PPI of DPR niet te kennen. Kalibratie meet het resultaat direct:

  1. Zet de browserzoom op 100% (Ctrl/Cmd + 0 op een computer). Gebruik op een telefoon geen knijpzoom.
  2. Open de kalibratiepagina en houd een standaard bankpas (85,60 mm, ISO/IEC 7810 ID-1) tegen het scherm.
  3. Sleep de omtrek tot hij precies op de rand van de pas past. De liniaal weet nu hoeveel CSS-pixels 85,60 mm beslaan.
  4. Lees de schaal af. CSS-px per inch = pixels over de pas ÷ 3,370 (85,60 ÷ 25,4).
  5. Controleer door een tweede bekend voorwerp te meten, zoals een bankbiljet of een A4-vel.

Rekenvoorbeeld (iPhone 15): 460 PPI ÷ DPR 3 ≈ 153,3 CSS-px per inch, dus de pas moet ongeveer 153,3 × 3,370 ≈ 517 CSS-px beslaan. Een naïeve liniaal met 96 px per inch zou de pas maar ongeveer 324 px groot tekenen, 37% te klein.

Een interface-element in CSS-pixels meten op een schermafbeelding

  1. Maak een schermafbeelding van het scherm dat je wilt bekijken.
  2. Zoek je DPR op met window.devicePixelRatio, of in de tabellen hierboven.
  3. Meet het element op de schermafbeelding in afbeeldingspixels, met een fotobewerker of een pixelliniaal.
  4. Deel door de DPR. Een knop van 132 px op een schermafbeelding van een iPhone 15 is 132 ÷ 3 = 44 CSS-px, Apples aanbevolen minimale aanraakdoel in points.
  5. Reken zo nodig om naar de echte grootte: CSS-px ÷ (PPI ÷ DPR) geeft inches. 44 ÷ 153 ≈ 0,29 in ≈ 7,3 mm. Controleer het fysiek met de gekalibreerde liniaal op je telefoon.

Veelgemaakte fouten met de device pixel ratio

  • Aannemen dat de DPR een heel getal is. Android en Windows geven waarden als 1,25, 2,625 en 2,75. Rond canvasmaten af met Math.round om wazigheid te voorkomen.
  • De DPR één keer opslaan bij het laden van de pagina. Hij verandert als het venster naar een andere monitor gaat of de gebruiker zoomt. Lees hem opnieuw uit bij een verandering.
  • dpi in CSS behandelen als fysieke PPI. Een CSS-dpi is per CSS-inch, en dat is zelden een echte inch.
  • 3×-afbeeldingen naar elk apparaat sturen. Die verdrievoudigen breedte en hoogte, dus ongeveer negen keer zoveel pixels als 1×. Gebruik srcset met breedtebeschrijvingen en sizes, zodat de browser kiest.
  • Schermafbeeldingen meten alsof het CSS-pixels zijn. Deel altijd eerst door de DPR.
  • Een canvas één keer dimensioneren. Zoomt de gebruiker of verplaatst hij het venster naar een andere monitor, dan wordt het canvas wazig. Voer de dimensioneringscode opnieuw uit bij een verandering (zie het matchMedia-voorbeeld hierboven).
  • CSS-cm of in gebruiken voor echte maten. Die zijn afgeleid van de referentie van 96 px, niet van jouw scherm. Kalibreer in plaats daarvan.

Problemen oplossen

Probleem Waarschijnlijke oorzaak Oplossing
Tekening op canvas ziet er wazig uit Buffer gedimensioneerd in CSS-pixels Vermenigvuldig canvas.width/height met de DPR en gebruik ctx.scale(dpr, dpr)
DPR geeft 1,1 of 0,9 op een computer Browserzoom staat niet op 100% Druk op Ctrl/Cmd + 0
Dunne lijnen wisselen tussen 1 en 2 apparaatpixels Gebroken DPR en subpixelposities Lijn coördinaten uit op apparaatpixels: Math.round(x * dpr) / dpr
Online liniaal te kort of te lang CSS-inch ≠ echte inch op dit apparaat Kalibreer met een pas op de kalibratiepagina
Afbeeldingen scherp op de computer, zacht op de telefoon Alleen een 1×-bron aangeleverd Voeg 2×- (en eventueel 3×-)bronnen toe in srcset of image-set()
DPR verschilt tussen Chrome en Firefox op dezelfde pc Elke browser houdt zijn eigen zoomniveau bij Controleer of beide op 100% staan

Bronnen

  • W3C, CSS Values and Units Module Level 3 (referentiepixel, 1in = 96px).
  • W3C, Media Queries Level 4 (resolution en dppx).
  • Apple: technische specificaties van de iPhone (resolutie en PPI per model).
  • ISO/IEC 7810: formaat ID-1-kaart, 85,60 × 53,98 mm.
  • MDN Web Docs: Window.devicePixelRatio, responsieve afbeeldingen (srcset).
  • Gepubliceerde schermspecificaties van Apple, Google en Samsung.
  • Apple Safari Web Content Guide: de viewport configureren (standaard 980 px).
  • Apple Human Interface Guidelines (schaalfactoren, minimaal aanraakdoel van 44 pt).
  • Android Developers: “Support different pixel densities” (dp en dichtheidsklassen).