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:
-
Browserconsole. Open DevTools (F12 op een computer, of remote debugging voor telefoons) en typ:
window.devicePixelRatio -
CSS-mediaqueries. Richt je in een stylesheet op schermen met hoge dichtheid:
@media (min-resolution: 2dppx) { /* stijlen voor DPR 2 en hoger */ }dppxbetekent “dots per CSS-pixel”, hetzelfde als de DPR. Oudere Safari-versies hebben-webkit-min-device-pixel-ratio: 2nodig. -
Schermgrootte controleren.
screen.widthis in CSS-pixels. Vermenigvuldig metdevicePixelRatioom de hardwarebreedte te schatten: 393 × 3 = 1179 op een iPhone 15. Sommige Android-browsers ronden af, dus reken op kleine verschillen. -
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:
- Zet de browserzoom op 100% (Ctrl/Cmd + 0 op een computer). Gebruik op een telefoon geen knijpzoom.
- Open de kalibratiepagina en houd een standaard bankpas (85,60 mm, ISO/IEC 7810 ID-1) tegen het scherm.
- Sleep de omtrek tot hij precies op de rand van de pas past. De liniaal weet nu hoeveel CSS-pixels 85,60 mm beslaan.
- Lees de schaal af. CSS-px per inch = pixels over de pas ÷ 3,370 (85,60 ÷ 25,4).
- 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
- Maak een schermafbeelding van het scherm dat je wilt bekijken.
- Zoek je DPR op met
window.devicePixelRatio, of in de tabellen hierboven. - Meet het element op de schermafbeelding in afbeeldingspixels, met een fotobewerker of een pixelliniaal.
- 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.
- 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.roundom 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.
dpiin CSS behandelen als fysieke PPI. Een CSS-dpiis 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
srcsetmet breedtebeschrijvingen ensizes, 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-
cmofingebruiken 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 (
resolutionendppx). - 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).