android in studio - What is the difference between “px”, “dip”, “dp” and “sp”?

15 Answers

Pretty much everything about this and how to achieve the best support for multiple screens with different sizes and densities is very well documented here:

Screen size
Actual physical size, measured as the screen's diagonal. For simplicity, Android groups all actual screen sizes into four generalized sizes: small, normal, large, and extra-large.

Screen density
The quantity of pixels within a physical area of the screen; usually referred to as dpi (dots per inch). For example, a "low" density screen has fewer pixels within a given physical area, compared to a "normal" or "high" density screen. For simplicity, Android groups all actual screen densities into six generalized densities: low, medium, high, extra-high, extra-extra-high, and extra-extra-extra-high.

The orientation of the screen from the user's point of view. This is either landscape or portrait, meaning that the screen's aspect ratio is either wide or tall, respectively. Be aware that not only do different devices operate in different orientations by default, but the orientation can change at runtime when the user rotates the device.

The total number of physical pixels on a screen. When adding support for multiple screens, applications do not work directly with resolution; applications should be concerned only with screen size and density, as specified by the generalized size and density groups.

Density-independent pixel (dp)
A virtual pixel unit that you should use when defining UI layout, to express layout dimensions or position in a density-independent way. The density-independent pixel is equivalent to one physical pixel on a 160 dpi screen, which is the baseline density assumed by the system for a "medium" density screen. At runtime, the system transparently handles any scaling of the dp units, as necessary, based on the actual density of the screen in use. The conversion of dp units to screen pixels is simple: px = dp * (dpi / 160). For example, on a 240 dpi screen, 1 dp equals 1.5 physical pixels. You should always use dp units when defining your application's UI, to ensure proper display of your UI on screens with different densities.

If you are any serious about developing an Android app for more than one type of device, you should have read the screens support development document at least once. In addition to that it is always a good thing to know the actual number of active devices that have a particular screen configuration.

stands for convert

What is the difference between android units of measure?

  • px
  • dip
  • dp
  • sp

px Pixels - point per scale corresponds to actual pixels on the screen.

in Inches - based on the physical size of the screen.

mm Millimeters - based on the physical size of the screen.

pt Points - 1/72 of an inch based on the physical size of the screen.

dp Density - independent Pixels - an abstract unit that is based on the physical density of the screen. These units are relative to a 160 dpi screen, so one dp is one pixel on a 160 dpi screen. The ratio of dp-to-pixel will change with the screen density, but not necessarily in direct proportion. Note: The compiler accepts both dip and dp, though dp is more consistent with sp.

sp -Scale-independent Pixels - this is like the dp unit, but it is also scaled by the user's font size preference. It is recommend you use this unit when specifying font sizes, so they will be adjusted for both the screen density and user's preference.

Take the example of two screens that are the same size but one has a screen density of 160 dpi (dots per inch, i.e. pixels per inch) and the other is 240 dpi.

                          Lower resolution   screen          Higher resolution, same size
Physical Width                      1.5 inches                        1.5 inches
Dots Per Inch (“dpi”)               160                               240
Pixels (=width*dpi)                 240                               360
Density (factor of baseline 160)    1.0                               1.5

Density-independent Pixels          240                               240
(“dip” or “dp” or “dps”)

Scale-independent pixels 
 (“sip” or “sp”)                  Depends on user font size settings    same

dp is dip. Use it for everything (margin, padding, etc.).

Use sp for {text-size} only.

To get the same size on different screen densities, Android translates these units into pixels at runtime, so there is no tricky math for you to do.

See the difference between px, dp and sp on different screen sizes.

Source: Android Programming: The Big Nerd Ranch Guide


px or dot is a pixel on the physical screen.

dpi are pixels per inch on the physical screen and represent the density of the display.

Android gives alias names to several densities

  • ldpi (low) ~120dpi
  • mdpi (medium) ~160dpi
  • hdpi (high) ~240dpi
    • most devices in 2015 are here
  • xhdpi (extra-high) ~320dpi
    • Apple iPhone 4/5/6, Nexus 4
  • xxhdpi (extra-extra-high) ~480dpi
    • Nexus 5
  • xxxhdpi (extra-extra-extra-high) ~640dpi

dip or dp are density-indenpendant pixels, i.e. they correspond to more or less pixels depending on the physical density.

  • 1dp = 1px on mdpi

sp or sip is a scale-independant pixel. They are scaled when the Large Text option is turned on in Settings > Accessibility

  • 1sp = 1dp
  • 1sp = 1.2dp with accessibility Large Text

What to use?

Use sp for Text size.

Use dp for everything else.

Basically the only time where px applies is one px, and that's if you want exactly one pixel on the screen like in the case of a divider:

On >160 dpi, you may get 2-3 pixels,

On >120 dpi, it rounds to 0.

Where to use what & relationship between px & dp?

Density-independent pixel (dp)

A virtual pixel unit that you should use when defining UI layout, to express layout dimensions or position in a density-independent way. As described above, the density-independent pixel is equivalent to one physical pixel on a 160 dpi screen, which is the baseline density assumed by the system for a "medium" density screen. At runtime, the system transparently handles any scaling of the dp units, as necessary, based on the actual density of the screen in use. The conversion of dp units to screen pixels is simple:

px = dp * (dpi / 160).

For example, on a 240 dpi screen, 1 dp equals 1.5 physical pixels. You should always use dp units when defining your application's UI, to ensure proper display of your UI on screens with different densities.

Understanding pixel to dp and vice versa is very essential (especially for giving exact dp values to creative team)

dp = px * 160 / dpi

MDPI = 160 dpi || Therefore, on MDPI 1 px = 1 dp
For example, if you want to convert 20 pixel to dp, use the above formula,
dp = 20 * 160 / 160 = 20.
So, 20 pixel = 20 dp.

HDPI = 240 dpi - So, on HDPI 1.5 px = 1 dp
XHDPI = 320 dpi - So, on XHDPI 2 px = 1 dp
XXHDPI = 480 dpi - So, on XXHDPI 3 px = 1 dp

For example, let us consider Nexus 4.
If 24 pixels to be converted to dp and if it is a Nexus 4 screen, developers can
convert it to dp easily by the following calculation :
dp = 24 * 160 / 320 = 12 dp
Screen dimension:
768 x 1280 pixel resolution (320 ppi or 320dpi)
Optional (screen size):
 4.7" diagonal
  • Try to get all pixel values in even numbers from the creative team. Otherwise precision lose will happen while multiplying with 0.5.


It is explained above. Try to avoid in layout files. But there are some cases, where px is required. for example, ListView divider line. px is better here for giving a one-pixel line as a divider for all across screen resolutions.


Use sp for font sizes. Then only the font inside the application will change while device fonts size changes (that is, Display -> Fonts on Device). If you want to keep a static sized font inside the app, you can give the font dimension in dp. In such a case, it will never change. Developers may get such a requirement for some specific screens, for that, developers can use dp instead of sp. In all other cases, sp is recommended.

Anything related with the size of text and appearance must use sp or pt. Whereas, anything related to the size of the controls, the layouts, etc. must be used with dp.

You can use both dp and dip at its places.

sp = scale independent pixel

dp = dip = density independent pixels

dpi = dots per inch

We should avoid to use sp.

We should use dp to support multiple screens.

Android supports different screen resolutions

  • ldpi (low) ~120 dpi
  • mdpi (medium) ~160 dpi
  • hdpi (high) ~240 dpi
  • xhdpi (extra-high) ~320 dpi
  • xxhdpi (extra-extra-high) ~480 dpi
  • xxxhdpi (extra-extra-extra-high) ~640 dpi

An 120 dp ldpi device has 120 pixels in 1 inch size.

The same for other densities...

We as software engineers should use this conversion formula:

pixel = dp * (density / 160)

So 240 dpi device's 1 dp will have = 1 * (240/160) = 3/2 = 1.5 pixels.

And 480 dpi device's 1 dp will have = 1 * (480/160) = 3 pixels.

Using this 1.5 and 3 pixels knowledge, a software engineer can design layouts for different densities.

To check screen parameters of any device:

DisplayMetrics metrics = new DisplayMetrics();

    "4:" + metrics.heightPixels + "," + metrics.density + ","
    + metrics.densityDpi, Toast.LENGTH_LONG).show();

dpi -

  • Dots per inches
  • Measuring the pixel density of the screen.

px - pixel

  • For mapping screen pixels

pt - points

  • About 1/72 of an inch, with respect to physical screen size.

in - inch - with respect to physical screen size(1 inch = 2.54 cm).

mm- milimeter - with respect to physical screen size.

sp - scale-independent pixel.

  • Based on user`s font size preference.
  • Font should be in 'sp'.

dip -

  • dip == dp
  • Density independent pixel.
  • It varies based on Screen Density.
  • In 160 dpi screen, 1 dp = 1 pixel.
  • Use dp except the text font size.

In standard, dp and sp are used. sp for font size and dp for everything else.

Formula for conversion of units:

px = dp * ( dpi / 160 );

Density Bucket -> Screen Display => Physical Size        => Pixel Size                   

ldpi         -> 120 dpi          => 0.5 x 0.5 in         => 0.5 in * 120 dpi = 60x60 px   

mdpi         -> 160 dpi          => 0.5 x 0.5 in         => 0.5 in * 160 dpi = 80x80 px   

hdpi         -> 240 dpi          => 0.5 x 0.5 in         => 0.5 in * 240 dpi = 120x120 px  

xhdpi        -> 320 dpi          => 0.5 x 0.5 in         => 0.5 in * 320 dpi = 160x160 px  

xxhdpi       -> 480 dpi          => 0.5 x 0.5 in         => 0.5 in * 480 dpi = 240x240 px 

xxxhdpi      -> 640 dpi          => 0.5 x 0.5 in         => 0.5 in * 640 dpi = 320x320 px  

Here's the formula used by Android:

px = dp * (dpi / 160)

Where dpi is one of the following screen densities. For a list of all possible densities go here

It defines the "DENSITY_*" constants.

  • ldpi (low) ~120dpi
  • mdpi (medium) ~160dpi
  • hdpi (high) ~240dpi
  • xhdpi (extra-high) ~320dpi
  • xxhdpi (extra-extra-high) ~480dpi
  • xxxhdpi (extra-extra-extra-high) ~640dpi

Taken from here.

This will sort out a lot of the confusion when translating between px and dp, if you know your screen dpi.

So, let's say you want an image of 60 dp for an hdpi screen then the physical pixel size of 60 dp is:

px = 60 * (240 / 160)

Please read the answer from community wiki. Below mentioned are some information to be considered in addition to the above answers.

sp = scale independent pixel

dp = density independent pixels

dpi = density pixels

I have gone through the above answers...not finding them exactly correct. sp for text size, dp for layout bounds - standard. But sp for text size will break the layout if used carelessly in most of the devices.

sp take the textsize of the device, whereas dp take that of device density standard( never change in a device) Say 100sp text can occupies 80% of screen or 100% of screen depending on the font size set in device

You can use sp for layout bounds also, it will work :) No standard app use sp for whole text

Use sp and dp for text size considering UX.

  • Dont use sp for text in toolbar( can use android dimens available or dp)
  • Dont use sp for text in small bounded buttons, very smaller text, etc

Some people use huge FONT in their phone for more readability, giving them small hardcoded sized text will be an UX issue. Put sp for text where necessary, but make sure it won't break the layout.

Similarly if you have a single app supporting all dimensions, adding xxxhdpi assets increases the app size a lot. But now xxxhdpi phones are common so we have to include xxxhdpi assets atleast for icons in side bar, toolbar and bottom bar. Its better to move to vector images to have a uniform and better quality images for all screen sizes.

Screen size in Android is grouped into categories ldpi, mdpi, hdpi, xhdpi, xxhdpi and xxxhdpi. Screen density is the amount of pixels within an area (like inch) of the screen. Generally it is measured in dots-per-inch (dpi).


  • our usual standard pixel which maps to the screen pixel. px is meant for absolute pixels. This is used if you want to give in terms of absolute pixels for width or height. Not recommended.

DP/DIP(Density pixels / Density independent pixels):

  • dip == dp. In earlier Android versions dip was used and later changed to dp. This is alternative of px.

  • Generally we never use px because it is absolute value. If you use px to set width or height, and if that application is being downloaded into different screen sized devices, then that view will not stretch as per the screen original size.

  • dp is highly recommended to use in place of px. Use dp if you want to mention width and height to grow & shrink dynamically based on screen sizes.

  • if we give dp/dip, android will automatically calculate the pixel size on the basis of 160 pixel sized screen.

SP(Scale independent pixels):

  • scaled based on user’s font size preference. Fonts should use sp.

  • when mentioning the font sizes to fit for various screen sizes, use sp. This is similar to dp.Use sp especially for font sizes to grow & shrink dynamically based on screen sizes

Android Documentation says:

when specifying dimensions, always use either dp or sp units. A dp is a density-independent pixel that corresponds to the physical size of a pixel at 160 dpi. An sp is the same base unit, but is scaled by the user's preferred text size (it’s a scale-independent pixel), so you should use this measurement unit when defining text size

The screen of a mobile phone is made up of thousands of tiny dots known as pixels (px). A pixel is the smallest element which goes to make the picture. The more the number of pixels to make a picture or wording, the sharper it becomes and makes the smartphone screen more easily readable.

Screen resolution is measured in terms of number of pixels on the screen. Screen resolution is a commonly-used specification when buying a device, but it's actually not that useful when designing for Android because thinking of screens in terms of pixels ignores the notion of physical size, which for a touch device is really really important.

Density independent pixel (dp or dip) allow the designer to create assets that appear in a expected way, no matter the resolution or density of target device.

A density independent pixel (dp or dip) is equal to one pixel at the baseline density or 160 dpi (dots per inch).

1 px/1dp = 160 dpi/160 dpi

2 px/1dp = 320 dpi(2x)/160 dpi


dpi is dots per inch

So, at 320 dpi, 1 dp is equal to 2 px.


px/dp = dpi/160dpi

Dots per inch (dpi) is a measure of the sharpness (that is, the density of illuminated points) on a display screen. The dots per inch for a given picture resolution will differ based on the overall screen size since the same number of pixels are being spread out over a different space.

Working with density independent pixels help us to deal with a situation like where you have two devices with same pixel resolution, but differing amount of space. Suppose in a case, a tablet and phone has the same pixel resolution 1280 by 800 pixels (160 dpi) and 800 by 1280 pixels (320 dpi) respectively.

Now because a tablet is at baseline density (160 dpi) its physical and density independent pixels sizes are the same, 1280 by 800. The phone on the other hand has a higher pixel density, so it has half as many density independent pixels as physical pixels. So a phone has 400 by 640 density independent pixels. So using a density-independent pixel makes it easier to mentally picture that tablet has much more space than the phone.

Similarly, if you have two devices with similar screen size, but different pixel density, say one is 800 by 1280 pixels (320 dpi), and the other is 400 by 640 pixels (160 dpi), we don't need to define totally different layouts for these two devices as we can measure assets in terms of density independent pixel which is same for both devices.

800 by 1280 pixels (320dpi)=400 by 640 density independent pixel (dp)

400 by 640 pixels (160 dpi)=400 by 640 density independent pixel (dp)

Scale independent pixels(sp) is the preferred unit for font size. For accessibility purposes, Android allows users to customize their device's font size. Users that have trouble reading text can increase their device's font size. You can normally find this option in the display setting on your phone or tablet under font size. It's often also available through the accessibility settings.

With scale independent pixels, 16 sp is exactly the same as 16 dp when the device's font size is normal or 100%. But when device's font size is large, for example 125%, 16 sp will translate to 20 dp or 1.25 times 16.

If you use dp as the unit for font size, then that piece of text has a specific physical size no matter if the user has customize device's font size. Using sp units will make a better experience for people with impaired eyesight.

Reference: Udacity, Google

SDP - a scalable size unit - basically it is not a unit, but dimension resources for different screen size.

Try the sdp library from Intuit. It's very handy to solve unit problems, and you can quickly support multiple screens.


android:paddingBottom="@dimen/_15sdp" for positive and android:layout_marginTop="@dimen/_minus10sdp" for negative sdp sdp

It has equivalent value in dp for each size in values-sw<N>dp folders (sw = smallestWidth).


Use it carefully! In most cases you still need to design a different layout for tablets.


          android:orientation="horizontal" >

                    android:textStyle="bold" />

                    android:textSize="@dimen/_70sdp" />

You can use db for text size, but I prefer ssp for text size.

For more details, check the library GitHub page.

I want to provide an easy way to understand dp. In fact, I think dp is the easiest one to understand. dp is just a physical length unit. It's of the same dimension as mm or inch. It's just convenient for us to write 50dp, 60dp rather than 50/160 inch or 60/160 inch, because one dp is just 1/160 inch whatever the screen size or resolution is.

The only problem is that, the android dpi of some screens are not accurate. For example, a screen classified to 160dpi may have 170dpi indeed. So the computation result of dp is fuzzy. It should be approximately the same as 1/160 inch.