40px to REM

40px = 2.5rem at the default 16px root font size. Change the root size below if your project uses a different base.

By Mohamed Farhan · Updated Oct 19, 2026

Root font size

40px = 2.5rem at a 16px root font size

40px at other root font sizes

10px root4rem
12px root3.3333rem
14px root2.8571rem
16px root2.5rem
18px root2.2222rem
20px root2rem

The formula

rem stands for "root em": a size relative to the font size of the html element. To convert, divide pixels by the root font size.

Formula
rem = px / root font size
40 / 16 = 2.5rem
CSS
.title {
  font-size: 2.5rem; /* 40px */
}

Nearby conversions

PixelsREM (16px root)Tailwind
24px1.5remtext-2xl
26px1.625remp-6.5
28px1.75remp-7
30px1.875remtext-3xl
32px2remp-8
36px2.25remtext-4xl
40px2.5remp-10
44px2.75remp-11
48px3remtext-5xl
56px3.5remp-14

Where 40px is used

40px is a popular height for standard buttons and text inputs, a size that is comfortable to click and tap. As a heading size, it suits hero headlines on mobile and section titles on desktop. On an 8px grid it is five units, often used for spacing between larger blocks.

40px in type and spacing scales

  • On an 8px grid, 40px is exactly 5 units.
  • On a 4px grid, 40px is 10 units.
  • In Tailwind, there is no default font-size class for 40px, so use text-[2.5rem], and the spacing scale covers it as step 10 (p-10, gap-10).
  • As em, 40px is 2.857em inside 14px text, 2.5em inside 16px text and 2.222em inside 18px text.
  • As a percentage of the default 16px font size, 40px is 250%.

Line height and spacing for 40px text

If you use 40px (2.5rem) for display headlines, a line-height of about 1.1 works well, which gives 44px between baselines. Larger type needs proportionally less line-height, because the gaps between lines are already big. At display sizes, also tighten letter-spacing slightly (around -0.01em to -0.02em) and test the headline on a narrow phone screen, where long words may need to wrap or the size may need the fluid clamp() version below.

For spacing below a block of 40px text, a margin of 0.75em to 1em (30px to 40px) keeps the rhythm consistent with the text size. Writing these values in em ties them to the font size, so they adjust automatically if the text size changes.

A fluid 40px with clamp()

Instead of a fixed 2.5rem, you can let the size scale smoothly between a smaller value on phones and 40px on desktops. The CSS clamp() function takes a minimum, a preferred value and a maximum. The example below grows from 32px on a 375px-wide screen to 40px on a 1280px-wide screen, and never goes outside that range. Because the minimum and maximum are in rem, the size still respects the user's font settings.

CSS
.title {
  font-size: clamp(2rem, 1.793rem + 0.884vw, 2.5rem);
}

Why rem instead of px

A rem is relative to the root font size, so 2.5rem stays equal to 40px only while the root is 16px. When someone raises the default font size in their browser, say to 20px, the same 2.5rem becomes 50px, and your layout scales with it. A hard-coded 40px stays at 40px and ignores that preference.

That matters for accessibility. Many people with low vision rely on larger default text, and the WCAG resize text guideline expects content to remain usable when text is scaled up to 200 percent. Using rem for type and spacing is the simplest way to support that without extra work.

Common conversion mistakes

  • Assuming the root is always 16px. If your CSS sets html { font-size: 62.5% }, 40px is 4rem, not 2.5rem. Check the root before converting.
  • Converting borders. Keep 1px borders and hairlines in px; converting them to tiny rem values can make them render inconsistently.
  • Rounding too aggressively. Values like 0.8125rem look odd but are exact. If you round them, round to your spacing grid rather than to one decimal place.
  • Mixing units for the same role. If font sizes are in rem but margins are in px, spacing will not scale with text.

A worked example with 40px

Here is how 40px might appear in real CSS. The hero headline uses 2.5rem, spacing uses rem values from the same 16px base, and the border stays in px so it remains a crisp hairline. If a visitor's default font size is 20px, the headline grows to 50px and the spacing grows with it, while the border stays 1px.

CSS
.hero-title {
  font-size: 2.5rem;      /* 40px */
  line-height: 1.1;
  letter-spacing: -0.01em;
  margin-bottom: 1.5rem;   /* 24px */
}

Converting in Sass, CSS variables and JavaScript

If you convert values often, let your tools do it. In Sass, a small function such as rem($px) that returns math.div($px, 16px) * 1rem turns rem(40px) into 2.5rem at compile time. In plain CSS, you can keep the pixel value readable with calc(40 / 16 * 1rem), which modern browsers resolve to 2.5rem.

In JavaScript, for example when generating inline styles or design tokens, divide by the root font size: 40 / 16 = 2.5. If you need the live root size (for users who changed their default), read parseFloat(getComputedStyle(document.documentElement).fontSize) instead of assuming 16.

Naming 40px as a design token

Design systems rarely use raw numbers in components. Instead, 40px would live in a token such as --font-size-display-40 for type or --space-10 for spacing, defined once as 2.5rem. Components then reference the token, so a later change to the scale updates every use at once.

If your team uses Figma variables or a tokens file (for example in the W3C design tokens format), store the value in px for designers and generate the rem version in the build step. That keeps both sides speaking the same language while the shipped CSS stays accessible.

How browsers resolve rem

When the browser computes a rem value, it multiplies it by the computed font size of the html element. That font size starts from the user's default (16px unless they changed it), then applies whatever your CSS sets on html. So 2.5rem means "2.5 times the root size", and it is resolved once per page, unlike em, which is recalculated at every level of nesting.

Because the root is shared, rem values are predictable across the whole document: a 2.5rem gap in a sidebar is exactly the same size as a 2.5rem gap in a modal, regardless of the text size inside each.

Sass, CSS and JavaScript
// Sass
@use "sass:math";
@function rem($px, $base: 16px) {
  @return math.div($px, $base) * 1rem;
}
.card { padding: rem(40px); } // 2.5rem

/* CSS */
.card { padding: calc(40 / 16 * 1rem); }

// JavaScript
const root = parseFloat(getComputedStyle(document.documentElement).fontSize);
const rem = 40 / root; // 2.5 at a 16px root

Sources and further reading

Skip the unit math

Inspo AI generates responsive React + Tailwind screens with a consistent rem-based type and spacing scale built in.

Generate a screen

More conversions

Questions people ask

How many rem is 40px?

40px is 2.5rem when the root font size is 16px, which is the default in every major browser.

How do I convert 40px to rem?

Divide the pixel value by the root font size: 40 / 16 = 2.5rem. If your root font size is different, divide by that number instead.

What is 40px in Tailwind?

In Tailwind's spacing scale 40px is step 10, so p-10, m-10 or gap-10. For font size use text-[2.5rem].

Why use rem instead of 40px?

rem scales with the user's browser font size setting, so layouts stay accessible for people who need larger text. px stays fixed regardless of that setting.

Is 40px a good font size?

40px is a display size for large headlines. See the line-height guidance above for pairing it with spacing.

What is 40px in em?

Inside text with a 16px font size, 40px is 2.5em. em is relative to the element's own font size, so the value changes if the parent text size changes.

Mohamed Farhan
Mohamed Farhan•Author & CEO•LinkedIn

↘ Building Inspo AI | AI-Powered Design Research & Builder Platform | Design Engineer.