LayerPort

Guide · Deep dive

Framer assets, fonts, and breakpoints, explained.

Three things make a Framer site look like a Framer site: its images, its type, and the fact that it is really three layouts. Each one is served in a way a copy has to understand. This is what each one is, with numbers, and what happens to it on the way to a folder you own.

In brief

  1. Images come in sizes

    Framer serves each image from framerusercontent.com in several widths via srcset and a scale-down-to parameter. A capture has to take every referenced variant, not one.

  2. Then they get lighter

    JPEG and PNG re-encode to WebP, and to AVIF where it wins, at quality 82 -- kept only when at least 10% smaller. Below-the-fold images become lazy.

  3. Fonts are CSS, not HTML

    Framer's fonts arrive through @font-face rules pointing at its CDN. Localizing them means downloading the woff2 and rewriting the url().

  4. Breakpoints are three layouts

    Desktop, tablet and phone are separate layouts toggled by media queries. The capture reviews all three and uses Framer's own breakpoint list to batch its screenshots.

  5. Interactions: what carries

    CSS-driven and recorded appear effects carry; anything that needs Framer's servers does not, and the manifest names it.

Images: one picture, five files

Framer does not serve *the* hero image; it serves a srcset of the hero at several widths from framerusercontent.com, each with a ?scale-down-to= parameter, and lets the browser choose by viewport and pixel density. A copy that keeps only the variant your laptop picked will 404 on a phone and on a Retina display. The capture takes every referenced variant and rewrites the srcset so the browser keeps choosing -- the responsive behaviour survives because the mechanism survives.

Then the optimizer runs over the tree. JPEG and PNG files over 12 KB are re-encoded to WebP, and to AVIF when the local encoder is available and WebP left enough on the table to beat; the smallest result is kept only if it is at least 10% smaller than the original, at quality 82, and images wider than 4,000 px are downscaled first. Every reference is then rewritten across HTML, CSS, JS, JSON and SVG so nothing relies on the browser guessing, and images past the first few on each page get loading="lazy" and decoding="async". Originals are kept -- they stop being referenced, but an image a script builds a path to at runtime still resolves.

Source: MDN — <img>: srcset and sizes · MDN — Lazy loading

How big an image is, by format (90th percentile, KB)

ItemValue
JPEG278 KB
PNG278 KB
WebP97 KB
AVIF37 KB
The heaviest tenth of images on the web, per format, July 2025. Same scenes, different encoders: WebP lands at about a third of JPEG, AVIF at about an eighth.

Source: HTTP Archive — Web Almanac 2025, Page Weight

The optimizer's thresholds, and the support that justifies them

  • 82 encode quality for both WebP and AVIF
  • 10% minimum saving before a conversion is kept
  • 96% of global browser traffic renders WebP; AVIF is close behind at about 95%

Source: Can I use — WebP · Can I use — AVIF · Google — WebP compression study · web.dev — Learn Images: AVIF

Fonts: they live in the CSS

Framer sites use Google Fonts, Fontshare, or fonts you uploaded, and in every case the published page gets them the same way: an @font-face rule whose src: url(…) points at framerusercontent.com (or fonts.gstatic.com), serving woff2. A copy that keeps the HTML and misses the CSS -- or keeps the CSS and misses the url() inside it -- falls back to Georgia or Arial, and the page is instantly recognizable as a copy.

Localizing a font is two steps: download the woff2 the rule points at and rewrite the url() to the local path -- under assets/fonts in the export. Because the @font-face rule itself is preserved, font-display, unicode ranges and variable-font axes survive unchanged. One thing to check yourself: a font you licensed for use on Framer may or may not be licensed for self-hosting. Google Fonts and Fontshare are open; a purchased family usually has a webfont licence with a domain or pageview clause. Read it before the site goes live elsewhere.

Source: MDN — @font-face · Framer Help — Custom fonts

The same rule, before and after

/* captured from the live site */
@font-face {
  font-family: "Satoshi";
  src: url(https://framerusercontent.com/assets/8b0c…/Satoshi-Variable.woff2) format("woff2");
  font-weight: 300 900;
  font-display: swap;
}

/* in the export */
@font-face {
  font-family: "Satoshi";
  src: url(/assets/fonts/Satoshi-Variable.woff2) format("woff2");
  font-weight: 300 900;
  font-display: swap;
}
Only the URL changes. Weight range, display strategy and the family name stay exactly as Framer wrote them, so the typography is byte-for-byte the same design.

Breakpoints: three layouts, not one that reflows

Framer ships three default breakpoints -- desktop from about 1200 px up, tablet roughly 810–1199 px, phone below about 810 px -- and you can add or move them per page. The published site does not reflow one layout; it renders the layout you designed for each breakpoint into the DOM and toggles them with min-width / max-width media queries. The list of those queries is in a <script id="__framer__breakpoints"> tag on every page.

That has two consequences for a copy. First, the tablet layout exists in the markup whether or not you ever looked at it, so a copy can be broken at 1024 px and look perfect at 1280. Second, it means a capture can be smart: LayerPort reads the breakpoint script and batches its viewport review by which media queries each width matches, so desktop, tablet and phone are each rendered and checked at least once, and a page with custom breakpoints gets its own set.

Source: Framer Academy — Creating breakpoints · Framer — Breakpoints in responsive web design · MDN — Using media queries

The default breakpoints, and what the capture does with each

Framer's defaults; a project can change the widths. The capture reads the page's own list rather than assuming these.
BreakpointDefault rangeFramer servesCapture does
Desktop≥ 1200 pxThe desktop layout, everything else hiddenRenders and reviews at 1280
Tablet810 – 1199 pxThe tablet layout, often the least-designedRenders and reviews at 1024
Phone< 810 pxThe phone layout and its menuRenders and reviews at 390, opens the menu

Source: Framer Academy — Creating breakpoints

Interactions and motion: what carries

Hover states, CSS transitions and the appear effects Framer records into the page carry, because they are in the markup and the localized modules. Scroll-triggered whileInView reveals of plain sections are the notable exception: when they are not part of the recorded appear payload, a section can arrive with opacity: 0 and never light. The capture runtime watches for exactly that -- an on-screen node stuck at zero opacity whose animation is not progressing -- and reveals it statically rather than leaving a blank band. You get the content; you do not get that one entrance.

Anything that needs Framer's servers to decide something -- a form submission, a CMS query, site search -- does not carry, and the capture manifest lists it. Advanced behaviour recording is not part of the public product today. Test the critical interactions on the deployed preview before you hand off; the export guide has the checklist.

Assets, fonts and breakpoints: the handoff check

  • Every image loads at 390 px on a Retina display (that is the srcset test).
  • Fonts match the live site at all three widths; no Georgia or Arial where a Framer font belongs.
  • The optimization report lists which images converted and how many bytes it saved -- and which it left alone.
  • The tablet layout at 1024 px is the one you looked at hardest.
  • Purchased fonts: the licence permits self-hosting on the new domain.

Sources

  1. MDN — <img>: srcset and sizes — Why a page can reference five files for one picture.
  2. MDN — Lazy loading — loading="lazy" and why the first images stay eager.
  3. HTTP Archive — Web Almanac 2025, Page Weight — Median bytes per resource type across ~16M pages, July 2025 crawl.
  4. Can I use — WebP — Live browser support table.
  5. Can I use — AVIF — Live browser support table.
  6. Google — WebP compression study — WebP lossless/lossy versus PNG and JPEG at equal quality.
  7. web.dev — Learn Images: AVIF — What AVIF does better than WebP and where it costs.
  8. MDN — @font-face — Where a font URL actually lives.
  9. Framer Help — Custom fonts — How uploaded fonts reach a published site.
  10. Framer Academy — Creating breakpoints — The three default breakpoints and how a change cascades down.
  11. Framer — Breakpoints in responsive web design — Framer's own explanation of the desktop / tablet / phone ranges.
  12. MDN — Using media queries — The min-width / max-width ranges a breakpoint compiles to.

FAQ

Will my Framer fonts survive the export?

Yes. The woff2 files are downloaded and the @font-face url() rewritten to assets/fonts; weight ranges and font-display stay as Framer wrote them. Check the licence of any purchased family before self-hosting.

Are mobile and tablet layouts captured?

Yes. Framer serves all three layouts in the markup; the capture reads the page's breakpoint list and renders and reviews each width, including the phone menu.

Why not convert every image to AVIF?

AVIF encodes far slower than WebP for a saving that is often marginal once WebP has already halved the file, and a conversion that saves less than 10% is churn. The optimizer keeps the smallest result only when it earns its place.

What about animations and scroll effects?

CSS transitions, hover states and recorded appear effects carry. Un-recorded scroll reveals are revealed statically so no section stays blank. Anything that needs Framer's servers is listed in the manifest rather than left half-working.

Features · Workflow · Pricing · FAQ