Category: Design Tools

  • Vimeo Thumbnail Downloader: Get Every Size [2026]

    Vimeo Thumbnail Downloader: Get Every Size [2026]

    TL;DR: Vimeo generates several thumbnail sizes for every public video — typically 100×75, 200×150, 295×166, 640×360, 1280×720, and 1920×1080. Unlike YouTube, Vimeo’s URLs aren’t predictable — you have to query Vimeo’s oEmbed API to get the actual filename for a given video. Our free Vimeo thumbnail downloader hits the oEmbed endpoint, lists every available resolution, and lets you download any size with one click. Browser-only — paste a Vimeo URL, get the thumbnails.

    Vimeo creators upload custom thumbnails (or auto-generate them from a video frame). Once published, those thumbnails are accessible via Vimeo’s CDN at predictable filenames per video — but the filename pattern depends on a unique image ID Vimeo assigns at upload, not the video ID. So the path i.vimeocdn.com/video/12345_640.jpg only works if you know the image ID, which you don’t get from the video URL.

    The official path: query the oEmbed endpoint at https://vimeo.com/api/oembed.json?url=. The response includes thumbnail_url (the default size) and other metadata. From the URL you can extract the image ID, then construct URLs for all the standard resolutions. Our Vimeo thumbnail downloader automates this — paste a video URL, get a list of all available sizes with download buttons.

    Standard Vimeo thumbnail sizes

    Size suffix Dimensions Best for
    _100 100×75 Tiny inline previews, RSS feeds
    _200 200×150 Sidebar widgets, list views
    _295 295×166 Vimeo’s default embed grid size
    _640 640×360 Standard preview tile (16:9 SD)
    _1280 1280×720 HD preview, blog hero image
    _1920 1920×1080 Full-HD preview, retina hero

    Not every video has every size. Older uploads (pre-2017) sometimes max out at 1280×720; very old uploads at 640×360. The largest available size is whatever the original upload supports — Vimeo doesn’t upscale.

    How to download a Vimeo thumbnail

    1. Open the Vimeo thumbnail grabber
    2. Paste any Vimeo URL — works with public videos, channels, showcases, on-demand pages
    3. The tool calls Vimeo’s oEmbed endpoint and lists every available resolution
    4. Click any thumbnail to download as JPG
    5. Or right-click → “Copy image address” to grab the direct CDN URL for embedding

    Vimeo’s oEmbed response — what’s actually available

    The oEmbed JSON response includes more than just thumbnails:

    {
      "title": "Video Title",
      "author_name": "Creator",
      "thumbnail_url": "https://i.vimeocdn.com/video/12345_295x166.jpg",
      "thumbnail_url_with_play_button": "https://i.vimeocdn.com/filter/overlay?...",
      "duration": 256,
      "video_id": 1234567,
      "uri": "/videos/1234567"
    }

    The thumbnail_url always points to one specific size (typically 295×166). To get the larger sizes, swap the suffix in the URL — _640.jpg, _1280.jpg, _1920.jpg. Our tool does this automatically and verifies each size returns a 200 response before listing it.

    YouTube vs Vimeo thumbnail patterns

    YouTube thumbnails follow a predictable URL pattern: https://img.youtube.com/vi/<video_id>/maxresdefault.jpg. Construct it from the video ID, no API call needed. Vimeo doesn’t work this way — you must query the oEmbed API to get the image ID before you can construct the thumbnail URL.

    For YouTube, see our YouTube Thumbnail Grabber; for Vimeo, this tool is the right pick.

    Common gotchas

    • Private videos return errors. oEmbed only works for public videos. Private videos (Vimeo Plus / Pro privacy settings: only me / password / domain-restricted) return a 403. There’s no public way to grab a private video’s thumbnail without an authenticated API call.
    • Showcase URLs need careful handling. A URL like vimeo.com/channels/staffpicks/1234567 requires extracting just the video ID. Our tool detects every URL format Vimeo uses.
    • Custom thumbnails take a moment to update. If a creator just uploaded a new custom thumbnail, the CDN may serve the cached old version for up to an hour. Try again later if you see a stale image.
    • Animated thumbnails aren’t available. Vimeo offers a “play button overlay” version (thumbnail_url_with_play_button) but no animated GIF thumbnail like YouTube’s hover preview. The static image is the largest you’ll get.
    • Aspect ratio is fixed at 16:9. All standard sizes are 16:9 — even if the source video is 4:3 or vertical, Vimeo letterboxes to 16:9 for thumbnail purposes. The full-resolution image always has the original aspect ratio though.
    • Rate-limit considerations. Vimeo’s oEmbed endpoint has rate limits (typically 60 requests per minute per IP). Our tool calls it on demand only — so a single user fetching one video at a time never hits the limit.

    When NOT to use this tool

    If you only need thumbnails for one video and you control the page, use Vimeo’s official embed code — the embed includes thumbnail rendering before the player loads, so no separate download is needed. For batch automation across hundreds of videos, use Vimeo’s API directly with an OAuth token (more powerful, no rate-limit concerns). For private videos, this tool can’t help — request access from the creator. For thumbnails of platforms other than Vimeo, see the YouTube Thumbnail Grabber or social media tools category.

    Frequently asked questions

    Does this work for private Vimeo videos?

    No. Vimeo’s oEmbed API only returns data for public videos. Private (Plus/Pro privacy settings) videos return a 403 error. The privacy is intentional — there’s no workaround that doesn’t involve an authenticated API call with the creator’s permission.

    Why doesn’t my Vimeo URL work?

    Three usual causes: (1) the video is private; (2) the URL is from a deleted video; (3) the URL is malformed. Try the canonical share URL from Vimeo’s “Share” button (looks like vimeo.com/1234567). If it still fails, the video is likely private.

    What’s the highest resolution available?

    Up to 1920×1080 for HD-uploaded videos. Older uploads (pre-2017) cap at 1280×720 or 640×360. Vimeo doesn’t upscale, so the highest size matches the original upload’s resolution — you can tell the original quality by what’s available.

    Can I use these thumbnails commercially?

    Thumbnails are part of the original upload, owned by the creator. Using them commercially (in your product, in advertising, in derivative works) requires the creator’s permission. For embedding the video itself with its thumbnail (as Vimeo’s embed code does), Vimeo’s terms allow this for any public video.

    Is my URL uploaded to your servers?

    Yes — to fetch the thumbnail URL we have to call Vimeo’s oEmbed API with the URL you paste. The URL goes from your browser directly to Vimeo (we use a CORS proxy or direct fetch). The thumbnails themselves are downloaded directly from Vimeo’s CDN to your browser.

    Why is Vimeo harder to grab than YouTube?

    YouTube uses predictable URL patterns based on video ID. Vimeo uses image IDs assigned at upload, separate from video IDs — so you must call the oEmbed API to map between the two. The result is the same kind of tool but with one extra API hop.

    Related tools and guides

     

  • Google Fonts Pairing Tool: Find Heading + Body Pairs [2026]

    Google Fonts Pairing Tool: Find Heading + Body Pairs [2026]

    TL;DR: A Google Fonts pairing tool helps you pick a heading font and a body font that work well together — usually one display/serif and one neutral sans-serif. The proven principle: contrast. Pair a high-character heading (Playfair Display, Bebas Neue, Lora) with a clean body (Inter, IBM Plex Sans, Source Sans Pro). Our free Google Fonts pair finder ships 30+ curated pairs, lets you preview any combination, and copies the @import + CSS variables ready to drop in. Browser-only.

    Picking two fonts that work together is the design decision developers most often get wrong. Defaulting to “Roboto for everything” works but reads as utilitarian; picking two display fonts at random produces visual chaos. The principle that designers use: contrast — pair fonts that differ along one axis (serif vs sans-serif, high-contrast vs low-contrast, geometric vs humanist) so headings and body don’t compete for attention.

    Our Google Fonts pair finder ships 30+ tested pairs (Inter + Playfair Display, IBM Plex Sans + IBM Plex Serif, Source Sans Pro + Lora, etc.) plus a free-form mode where you can preview any two of the 1,500+ Google Fonts side-by-side. Outputs a copy-paste <link> tag for the HTML head plus CSS variables. This guide covers what makes a good pair, the four anti-patterns that always fail, and how to verify your pair works at common font sizes.

    The 6 most reliable pairing patterns

    Pattern Heading Body Feel
    Editorial Playfair Display Source Sans Pro Magazine, premium publishing
    SaaS / clean Inter Inter Modern web app — single-family is fine
    Corporate / serious IBM Plex Serif IBM Plex Sans Banking, B2B, healthcare
    Display + neutral Bebas Neue Open Sans Posters, gym, agency
    Soft serif Lora Inter Blogs, literary, gentle
    Geometric duo Poppins DM Sans Startup, tech-forward

    The contrast principle (in one sentence)

    A good pair differs noticeably along one axis but not too many. The common axes:

    • Serif vs sans-serif (Playfair + Source Sans, Lora + Inter)
    • Display vs neutral (Bebas Neue + Open Sans, Lobster + Inter)
    • High-contrast vs low-contrast stroke weight (Cormorant + Work Sans)
    • Geometric vs humanist (Poppins + Lora — geometric heading, organic body)

    Anti-patterns: pairing two display fonts (chaos), pairing two serifs from different historical eras (uncomfortable), or using the same font at the same weight for headings and body (no hierarchy). Pick one axis of contrast; keep everything else aligned.

    How to find a font pair

    1. Open the Google Fonts pair finder
    2. Pick a curated pair from the gallery, or set a heading font and a body font manually
    3. Watch the live preview — heading at H1/H2/H3 sizes, body at 16px
    4. Adjust font weights (400 / 500 / 700) to fine-tune the look
    5. Click Copy <link> + CSS for production-ready code

    The CSS you’ll paste

    <!-- in <head> -->
    <link rel="preconnect" href="https://fonts.googleapis.com">
    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600&family=Playfair+Display:wght@700&display=swap" rel="stylesheet">
    
    /* in CSS */
    :root {
      --font-heading: "Playfair Display", Georgia, serif;
      --font-body: "Inter", system-ui, sans-serif;
    }
    h1, h2, h3 { font-family: var(--font-heading); }
    body { font-family: var(--font-body); }

    The preconnect hints save 100–200ms on first font load. display=swap ensures text renders in a system fallback while the web font loads, then swaps in (rather than showing invisible text during font-load).

    Performance — only load weights you actually use

    Each font weight (400, 500, 600, 700) is a separate download. Loading all eight weights of a font family adds 200+ KB; loading only 400 + 700 is typically 80 KB. Audit your design and request only the weights and styles you actually use:

    • Body: 400 (regular) and 700 (bold) is enough for most projects.
    • Headings: usually one weight — pick 700 for impact, 600 for softer headings, 800–900 for display work.
    • Italic: only request ital if your design uses italics. Many web designs don’t.
    • Variable fonts (Inter, Roboto Flex, Recursive) — load one variable font file that covers all weights, often smaller than two separate static weights.

    Common gotchas

    • Don’t pair two display fonts. One eye-catching font is contrast; two is chaos. Use one display font for headings, a neutral sans or serif for body.
    • Subset to the languages you support. Google Fonts loads only Latin by default, but for sites with Cyrillic, Greek, Vietnamese, or other scripts you must add the subset parameter — otherwise non-Latin characters fall back to a system font.
    • Self-host for GDPR compliance. Google Fonts CDN includes IP-address logging at Google. EU GDPR-strict sites self-host fonts via google-webfonts-helper or the Fontsource npm packages. Same fonts, no third-party request.
    • Variable fonts have axis ranges. Inter Variable goes from weight 100 to 900 in a single file. Specify font-weight: 525 for a custom in-between weight — useful for matching specific brand specs.
    • Body text needs ~16px minimum. Anything smaller fails accessibility recommendations (WCAG-AAA prefers 18px+) and causes mobile zoom-in. Don’t pair a “delicate” body font under 14px.
    • Cumulative Layout Shift (CLS). Web fonts swapping in shifts text reflow. Use font-display: optional to skip the swap on slow connections, or size-adjust CSS to match fallback metrics — both prevent CLS.

    When NOT to use a font pair

    Single-font designs work for many modern apps (Apple’s HIG uses just SF Pro across the system). If your interface is mostly text with little visual hierarchy, one well-designed font with clear weight differences (400 / 500 / 600 / 700) is enough. Pairing adds complexity — only do it when visual contrast helps the reader. For brand-heavy sites where the typography is the brand (publications, fashion, agencies), pairing matters more; for typical SaaS and dashboards, a single variable font is often the right answer.

    Frequently asked questions

    How many fonts should I use on a site?

    Two is the sweet spot — heading + body. One font (with weight variation) is acceptable for utilitarian designs. Three or more usually creates visual noise. Some designers add a third “accent” font sparingly for pull quotes or small UI details, but never for body text.

    Should I self-host Google Fonts?

    For privacy-strict (GDPR-leaning) sites, yes — use Fontsource npm packages or google-webfonts-helper to self-host. For everyone else, Google Fonts CDN is fine — fast, cache-friendly, free. The 2022 German court ruling against using Google Fonts CDN applies under specific GDPR interpretations and is rarely enforced internationally.

    Why does my page flash a different font on load?

    FOIT (flash of invisible text) or FOUT (flash of unstyled text) — caused by web fonts loading after the first paint. Use font-display: swap in your @font-face or Google Fonts URL, plus preconnect hints. For full elimination, preload the critical font subset with <link rel="preload">.

    Are variable fonts better than separate weight files?

    Usually yes for projects using 3+ weights — one variable file is smaller than 3+ static weights and gives you any in-between weight for free. For 1–2 weight projects, static files load slightly faster (variable files have a fixed parse overhead). Inter Variable, Roboto Flex, and Recursive are excellent variable fonts on Google Fonts.

    Is my data uploaded?

    No. The pair finder runs in your browser. Font selections, the live preview, and exported CSS stay on your device.

    Can I find a pair for a non-Latin script?

    Yes — pick a font that supports your script (toggle the language filter to Cyrillic, Greek, Arabic, Devanagari, etc.) and the tool restricts the gallery to fonts with full coverage. Body fonts for non-Latin scripts often need different pairings than Latin equivalents.

    Related tools and guides

     

  • Image Filters Online: Free Browser Photo Effects [2026]

    Image Filters Online: Free Browser Photo Effects [2026]

    TL;DR: An online image-filter tool applies CSS-style adjustments — brightness, contrast, saturate, hue-rotate, blur, sepia, grayscale — and prebuilt presets (vintage, cool, warm, fade) to any photo, in your browser. Useful for quick blog hero images, social posts, and matching photos to a brand palette without opening Photoshop. Our free image filter tool runs the entire pipeline on the canvas in your browser, exports the filtered image as PNG/JPG/WebP, and copies the equivalent CSS filter declaration so you can apply the same effect live in your stylesheet.

    Reaching for Photoshop or Lightroom for a quick photo tweak is overkill when all you need is a brightness boost, a sepia tint, or a quick fade for a blog header. Mobile apps like Snapseed and VSCO solve this on phones; the equivalent for desktop work is a browser tool with the same set of named effects. CSS specifies all the basic image filters — brightness(), contrast(), saturate(), blur(), sepia(), grayscale(), hue-rotate(), invert(), opacity(), drop-shadow() — and most browsers render them at GPU speed.

    Our image filter tool exposes every CSS filter as a slider plus 24 prebuilt presets (vintage, cool, warm, fade, sepia, B&W, dramatic, polaroid, and more). Drop an image, drag sliders or click a preset, export the filtered image as PNG/JPG/WebP. The tool also outputs the equivalent CSS filter: declaration — useful when you want to apply the filter in CSS (live, no rendered file) instead of baking it into the image. This guide explains every filter, the preset presets, and the gotchas with hue-rotate and saturate that produce unexpected results.

    All 10 CSS filter functions

    Filter Range What it does
    brightness(0–2) 0% to 200%+ Linearly scales the intensity of every pixel
    contrast(0–2) 0% to 200%+ Spreads pixel values away from mid-grey
    saturate(0–2) 0% to 200%+ 0% = grayscale; 200% = oversaturated
    grayscale(0–1) 0% to 100% Mixes original and luminance-only versions
    sepia(0–1) 0% to 100% Brown-tinted aging effect
    hue-rotate(0–360deg) 0° to 360° Spins all colours around the colour wheel
    invert(0–1) 0% to 100% Inverts pixel values (negative effect)
    blur(0–20px) 0px to 20px+ Gaussian blur — soften details
    opacity(0–1) 0% to 100% Fade entire image to transparent
    drop-shadow() x / y / blur / colour Shadow that follows non-rectangular silhouettes

    24 prebuilt presets — what each one does

    Filters compose. Stacking contrast(110%) saturate(140%) sepia(20%) produces the “Polaroid” look. Our presets are tuned versions of those compositions:

    • Vintage: warm sepia with reduced saturation and slight contrast boost — instagram circa 2012
    • Cool: blue hue shift and increased contrast — winter photography
    • Warm: orange/yellow tint and slight saturation — sunset feel
    • B&W: grayscale with contrast boost — photojournalism look
    • Fade: reduced saturation and contrast — film fade
    • Sepia: classic 100% sepia tint
    • Polaroid: warm tint, soft contrast, slight grain
    • Dramatic: high contrast + saturation
    • Forest: green-shifted hue + saturation
    • Sunset: orange-shifted hue + warm tint
    • Night: deep blue + reduced brightness
    • Lo-fi: pixel-soft blur + saturation
    • 12 more available in the dropdown

    How to filter an image in your browser

    1. Open the image filter tool
    2. Drop an image (JPG, PNG, WebP, HEIC supported)
    3. Click a preset to apply, or drag individual filter sliders
    4. Watch the live preview update — every change is canvas-rendered in real time
    5. Click Export for PNG/JPG/WebP at 1× / 2× / 4× resolution
    6. Or click Copy CSS to copy the equivalent filter: declaration for live styling

    CSS filter vs baked-in filter — when to pick which

    Two output options matter for different workflows:

    • Bake into image: the filter is applied to the pixels, the image is exported as PNG/JPG. Use when you’re publishing to a CMS, social media, or anywhere the image lives independently of styling. The filter is permanent.
    • Copy as CSS: the original image stays untouched and you apply the filter via img { filter: contrast(120%) saturate(110%); } in your stylesheet. Use when you want one source image to render different ways across themes (light/dark mode, hover states, etc.). The filter is reversible — change the CSS and the image looks different without re-uploading.

    For a photo gallery with hover effects, use CSS. For an image you’ll embed in a tweet or attach to an email, bake it in.

    Common gotchas

    • Hue-rotate isn’t perceptually uniform. Rotating hue by 60° shifts red to yellow, but the same 60° shift from blue lands in purple — the wheel isn’t uniform. Use the visual preview, don’t pick angles by intuition.
    • Brightness above 100% can clip highlights. Once a pixel hits #FFFFFF it stops getting brighter, and details in the highlights are lost forever. Pull contrast down before pushing brightness up if you want to preserve detail.
    • Blur slows older devices. Gaussian blur with radius >10px on a 4000×3000 image can briefly stall the page on a 5-year-old mobile. Resize the image first if performance matters.
    • Grayscale isn’t desaturate. grayscale(100%) uses Rec. 709 luminance weights (red 21%, green 72%, blue 7%); saturate(0) uses an HSL-style desaturation. The two produce subtly different greys for the same input.
    • Drop-shadow follows transparency. Unlike box-shadow, drop-shadow() respects PNG alpha channels — perfect for product photos with transparent backgrounds. JPEG inputs don’t have alpha, so the shadow shows the rectangular outline.
    • Sepia at 100% destroys colour information. Once an image is fully sepia-toned, you can’t recover the original colours from the output. Always keep your original — bake the filter into a copy.

    When NOT to use this tool

    For photography retouching (skin smoothing, dodge/burn, layered adjustments), use Lightroom, Photoshop, or Affinity Photo — CSS filters can’t do localised edits. For colour grading a video sequence, use a video editor with proper LUT support (DaVinci Resolve, Premiere). For batch processing 100s of files, install sharp or ImageMagick and write a script — much faster than running each through a browser tool. For HDR or 16-bit colour work, browsers run filters in 8-bit RGB and can lose precision.

    Frequently asked questions

    Does this support PNG alpha channels?

    Yes. PNG transparency is preserved through every filter. Drop-shadow specifically follows the alpha channel — useful for product photos on transparent backgrounds. JPEG inputs don’t have alpha; everything outside the photo is treated as fully opaque.

    Can I export to WebP?

    Yes — the export menu offers PNG (lossless, alpha), JPG (lossy, no alpha), and WebP (modern compression, alpha supported). Pick PNG for graphics with transparency, JPG for photos, WebP for the smallest file when modern browser support is acceptable.

    Will the filtered output match what I see in CSS?

    Yes — we use the same canvas filter API browsers use for the CSS filter property, so the rendered output is byte-identical to what your stylesheet would produce on a browser of the same version. Older browsers may render slight differences in blur kernels.

    Can I apply multiple filters at once?

    Yes — every slider is independent and they all stack. The preview shows the cumulative effect; the exported CSS lists each filter in order (filter: brightness(110%) contrast(120%) sepia(20%)). The order matters slightly — earlier filters are applied first.

    Is my image uploaded?

    No. The tool runs canvas filters in your browser. The image is loaded into a blob URL and processed locally — never uploaded.

    What’s the resolution limit?

    Effectively your browser’s available canvas memory. Desktop browsers handle 8000×6000 (48 MP) images comfortably; mobile is more limited (around 4000×3000). Heavy filters like blur slow down on large inputs — resize first if you don’t need full resolution.

    Related tools and guides

     

  • CSS Pattern Generator: Pure-CSS Backgrounds [2026]

    CSS Pattern Generator: Pure-CSS Backgrounds [2026]

    TL;DR: A CSS pattern generator outputs pure-CSS code for repeating background patterns — dots, grids, stripes, checks, isometric, halftone — with no image files needed. The technique uses repeating-linear-gradient, radial-gradient, and (modern browsers) image() + masks to draw geometric tiles directly in CSS. Result: tiny payloads (often under 100 bytes), infinite scaling, and styles that change with CSS variables. Our free CSS pattern generator ships 30+ presets with size, color, and angle controls.

    Background patterns used to mean a 1KB tileable PNG. Modern CSS makes most of them unnecessary — a dot grid is two short lines of radial-gradient; diagonal stripes are one repeating-linear-gradient; a graph-paper grid is two layered linear gradients. The CSS approach beats raster images on every axis: smaller payload, perfectly crisp on retina displays, theme-aware (use CSS variables for colors), and editable in DevTools without rebuilding assets.

    Our CSS pattern generator ships 30+ tested patterns across categories: dots (uniform dot grid, scattered, halftone), lines (horizontal, diagonal, crosshatch), grids (graph paper, isometric, hex), geometric (zigzag, chevron, scales). Adjust pattern size, foreground/background color, and angle. Outputs production-ready CSS with the canonical pattern declaration plus a fallback for older browsers.

    Pattern types and what each looks like

    Pattern Technique Best for
    Dot grid radial-gradient tile Subtle background, hero sections
    Graph paper Two linear-gradient layers Notebook / sketch UIs, illustrations
    Diagonal stripes repeating-linear-gradient Caution / warning blocks, accents
    Checkerboard Two linear-gradient layers at 45° offset Transparency indicator, retro aesthetic
    Isometric grid Three linear-gradient layers at 60° 3D illustrations, blueprint look
    Crosshatch Two diagonal repeating-linear-gradient Editorial, illustration backgrounds
    Halftone Sized radial-gradient with background-size Comic / pop-art aesthetic

    A simple dot-grid example

    The minimal CSS for a 2px dot every 24px:

    .dot-grid {
      background-color: #fffdf8;
      background-image: radial-gradient(circle, #635BFF 1px, transparent 1px);
      background-size: 24px 24px;
    }

    Two lines plus background color = a perfect dot grid. Resize the background-size to change spacing, swap the colors for different themes. No image, no PNG asset, scales infinitely.

    How to generate a CSS pattern

    1. Open the CSS pattern generator
    2. Pick a pattern type from the gallery
    3. Adjust pattern size (the spacing of the repeat), foreground color, background color, and angle (where supported)
    4. Watch the live preview update across the full panel
    5. Click Copy CSS for the production-ready declaration with comments and CSS variables

    Why CSS patterns beat image tiles

    • Tiny payload. A dot grid is ~80 characters of CSS. The same as an image is 0.8–2 KB after PNG compression.
    • Infinitely scalable. A 24px tile renders crisp on a 5K display because the gradient is rasterised at the actual pixel density. PNG tiles need 2× / 3× variants for retina.
    • Theme-aware. Use CSS variables for colors and the same pattern adapts automatically to dark mode without separate assets.
    • Editable in DevTools. Tweak background-size live without rebuilding any image.
    • Server caching is irrelevant. No separate request — the pattern is part of the CSS file.

    Common gotchas

    • Performance on huge fills. A repeating-gradient pattern on a full-page background performs fine. Stacking 4+ pattern layers on the same element can slow down older mobile devices — keep complex patterns to small areas.
    • Background-attachment fixed + patterns. Using background-attachment: fixed with a CSS pattern can cause repaints on scroll. Use scroll (default) for performance unless the parallax effect is essential.
    • Patterns don’t shift with mouse / scroll. If you want a “parallax” pattern effect, you need JavaScript or transform-based motion — pure CSS patterns are static relative to their element.
    • Print stylesheets. Browsers often disable background images and patterns for print to save toner. Set -webkit-print-color-adjust: exact if printing the pattern matters.
    • Edge alignment. Pattern tiles align to the element’s background-origin. If you have padding or border-radius, the pattern continues underneath them — useful for seamless backgrounds, but watch for asymmetric clipping at corners.
    • Color overlap. When stacking multiple gradient layers (e.g., grid = horizontal lines + vertical lines), check that they blend correctly. Use the + blend mode or rgba() colors with appropriate transparency.

    When NOT to use a CSS pattern

    For organic, illustrated, or photographic patterns (watercolor textures, fabric, paper grain), use a real image — CSS gradients can’t produce non-geometric shapes. For animated patterns (slowly drifting backgrounds), use SVG with smil animations or a canvas — CSS background-position animation is choppy. For SEO-relevant images (where the pattern is content, not decoration), use a real image with proper alt text. For very complex patterns (snowflakes, paisley, custom logos repeated), use a tileable SVG instead — more efficient than 10+ stacked gradients.

    Frequently asked questions

    Are CSS patterns supported in all browsers?

    Yes — radial-gradient and repeating-linear-gradient have been supported since Chrome 26, Firefox 16, Safari 7. Universal support in 2026. Even IE 11 had partial support (no repeating gradients but solid patterns work).

    Will CSS patterns slow down my page?

    Single patterns: no — they’re rendered at GPU speed and cached. Multiple stacked patterns on the same large element can slow paint times on older mobiles, but typical use (one pattern per page) has zero measurable impact.

    Can I animate a CSS pattern?

    Limited — you can animate background-position for a “scrolling” effect, or animate background-size for pulsing. More complex animation (morphing patterns, shape changes) requires SVG or canvas. Animating background-position is GPU-accelerated and smooth.

    How do I make the pattern darker / lighter?

    Adjust the foreground and background colors directly in the CSS. Pure black/dark patterns on light backgrounds maximise contrast; semi-transparent foregrounds (e.g., rgba(0,0,0,0.05)) produce subtle textures that don’t compete with content.

    Is my data uploaded?

    No. The generator runs in your browser. Pattern selections, customisations, and the generated CSS stay on your device.

    Can I export the pattern as an image?

    Yes — there’s a “Download as PNG” option that rasterises the pattern at chosen size (256×256, 512×512, or full-screen). Useful for fallbacks in old browsers, or when an image asset is required (CMS that doesn’t accept inline CSS, email templates, etc.).

    Related tools and guides

     

  • CSS Triangle Generator: Border Trick + Clip-Path [2026]

    CSS Triangle Generator: Border Trick + Clip-Path [2026]

    TL;DR: CSS triangles use one of two techniques: the classic border trick (a zero-size element with thick transparent borders, where one border has a color — that color shows as a triangle) or modern clip-path with a polygon(). Border trick has perfect browser support back to IE 6; clip-path is cleaner CSS but needs a real-sized box. Our free CSS triangle generator outputs both forms with size, color, and direction controls.

    CSS triangles solve a specific problem: drawing a small triangular shape (tooltip arrows, dropdown indicators, breadcrumb separators, accent shapes) without an SVG or image. The two techniques have been around forever — the border-trick variant is famously hacky CSS that works because of how browsers render border miters at the corners of an element. The clip-path variant is straightforward but needs more recent browser support.

    Our CSS triangle generator builds either form. Pick a direction (up, down, left, right, or one of four diagonals), set size and color, and copy the production CSS. Both versions are inline-able — no extra HTML elements needed beyond the triangle’s own div or span. This guide explains both techniques, when to use which, and the rendering quirks that make one or the other choice for specific contexts.

    Border trick vs clip-path — which to use

    Technique Pros Cons
    Border trick Universal browser support; zero-size element Hard to gradient-fill; smaller hit area
    clip-path polygon() Cleaner CSS; can have content; gradient-fillable Modern only; needs real-size box

    For tooltip arrows and dropdown indicators (decoration only): use the border trick. For triangular badges, decorative shapes, or any triangle that needs gradients, text inside, or animation: use clip-path.

    The border-trick technique explained

    An element with width: 0; height: 0; and thick borders renders as four diagonal-mitered triangles meeting at the centre. Make three of those borders transparent and you’re left with a single triangle in the colour of the visible border:

    /* Triangle pointing up — 30px wide, 20px tall */
    .triangle-up {
      width: 0;
      height: 0;
      border-left: 15px solid transparent;
      border-right: 15px solid transparent;
      border-bottom: 20px solid #635BFF;
    }
    
    /* Triangle pointing down */
    .triangle-down {
      width: 0;
      height: 0;
      border-left: 15px solid transparent;
      border-right: 15px solid transparent;
      border-top: 20px solid #635BFF;
    }

    The size is implicit: the triangle’s width is twice the border-left/right width (30px above), and its height is whatever the visible border thickness is (20px). To change direction, change which border is solid and which are transparent.

    The clip-path technique explained

    A real-sized div clipped to a polygon shape produces an editable, fill-able triangle:

    /* Triangle pointing up */
    .triangle-up {
      width: 60px;
      height: 60px;
      background: #635BFF;
      clip-path: polygon(50% 0%, 100% 100%, 0% 100%);
    }
    
    /* Add gradient or border easily */
    .triangle-gradient {
      width: 60px;
      height: 60px;
      background: linear-gradient(45deg, #635BFF, #00D4FF);
      clip-path: polygon(50% 0%, 100% 100%, 0% 100%);
    }

    Bonus: clip-path triangles can have text inside (it’s a real div), can be flex/grid containers, and can be animated. The cost is needing modern browser support (Chrome 23+, Firefox 54+, Safari 7+ — universal in 2026 except IE).

    How to generate a CSS triangle

    1. Open the CSS triangle generator
    2. Pick direction (up, down, left, right, top-left/top-right/bottom-left/bottom-right diagonals)
    3. Set width and height
    4. Pick color, plus a stroke for the clip-path version
    5. Toggle between Border trick and clip-path output
    6. Click Copy CSS

    When you’d use a triangle in real CSS

    • Tooltip arrows. A triangle pointing at the trigger element. The classic use — small (8–12px), border-trick, positioned absolutely against the tooltip body.
    • Dropdown carets. The little ▼ next to “More” buttons. Often replaced by SVG icons in modern UIs but still common in plain-CSS contexts.
    • Breadcrumb separators. The “›” between items. Often a real character, but a CSS triangle gives precise control over color and angle.
    • Speech-bubble pointers. Chat-bubble UIs use a triangle pointing at the speaker. Border trick or clip-path both work.
    • Decorative section dividers. A wide, flat triangle as a wedge between page sections. Use clip-path on a full-width div for this.
    • Custom badges. Triangular accent on the corner of a card. clip-path with text inside.

    Common gotchas

    • Sub-pixel rendering. Triangles smaller than 8px can look blurry on non-retina displays because the diagonal isn’t a clean pixel boundary. Either use larger triangles or accept slight anti-aliasing artefacts.
    • Background colour bleeds. The transparent borders in the border trick still occupy hit-test area. The visible triangle’s clickable region extends to the full bounding box, not just the visible part.
    • Inline element issues. A border-trick triangle on a <span> may render with line-height padding around it. Use display: inline-block or wrap in a container.
    • Right-to-left layouts. A triangle pointing “left” should flip to point “right” in RTL layouts. CSS logical properties (margin-inline-start etc.) help, but border-direction names don’t have logical equivalents — handle the flip manually with [dir="rtl"] selectors.
    • Animation cost. Border-trick triangles can be expensive to animate (changing border width triggers layout). clip-path triangles animate cheaply (transform-only).
    • Don’t try to gradient-fill a border-trick triangle. Borders take a single solid color. For gradients, use clip-path; for the border trick, use a wrapper element with the gradient and the triangle as a mask.

    When NOT to use a CSS triangle

    For complex shapes (chevron with rounded corners, triangular logos, multi-color triangles), use SVG inline — much more flexible. For a triangle with shadows, drop-shadow, or stroke effects, use clip-path with filter: drop-shadow(). For very tiny triangles (under 4px), consider Unicode characters (▲ ▼ ◀ ▶) which are font-rendered and crisp at small sizes. For animated character indicators (like a pulse arrow), an SVG with proper SVG animations is smoother than a CSS-only approach.

    Frequently asked questions

    Why does the border trick work?

    Browsers render borders with diagonal miters at corners. An element with zero width and height is just a point — the corners meet at the centre — and each border becomes a triangle pointing inward. Make three transparent and one solid coloured, and you see only the solid triangle.

    Which technique should I use?

    For tooltip arrows and small UI triangles: border trick (universal support, simpler positioning). For decorative triangles with content, gradients, or animation: clip-path. Both are universally supported in 2026 except IE (retired).

    Can I make a triangle with rounded corners?

    Not with the border trick. With clip-path, the polygon corners are sharp by default — for rounded triangles, use SVG with stroke-linejoin or a custom path. There’s a CSS proposal for shape-radius but it’s not implemented yet.

    How do I rotate a triangle?

    For arbitrary angles, generate a “pointing-up” triangle and apply transform: rotate(45deg). The triangle rotates around its centre. Combine with transform-origin to rotate around a different point.

    Is my data uploaded?

    No. The generator runs in your browser. Triangle settings, the live preview, and the generated CSS stay on your device.

    Can I have text inside a CSS triangle?

    Yes — only with the clip-path version. The border-trick triangle has zero width and height, so no content fits. clip-path triangles are real divs with full layout properties — text, flex, grid, anything.

    Related tools and guides

     

  • SVG Pattern Generator: Tileable Backgrounds [2026]

    SVG Pattern Generator: Tileable Backgrounds [2026]

    TL;DR: An SVG pattern generator outputs tileable SVG graphics — repeating shapes (dots, triangles, hexagons, lines, scales) that can be used as background-image fills. SVG patterns scale infinitely, accept custom colors via CSS variables, and produce smaller payloads than equivalent PNG tiles for most cases. Our free SVG pattern generator ships 60+ tested shapes, exports as standalone SVG, PNG raster, or CSS data URL — ready to drop into any stylesheet.

    For repeating decorative backgrounds, the choice in 2026 is between three approaches: pure CSS gradients (smallest, geometric only), SVG patterns (vector-perfect, complex shapes), or PNG tiles (legacy fallback). SVG wins when your shape is anything more complex than dots and stripes — hexagonal grids, isometric blocks, scaled fish-scales, abstract logos repeated. SVG patterns are also CSS-variable-friendly: change a single CSS custom property and the entire tiled pattern re-colors without regenerating the asset.

    Our SVG pattern generator ships 60+ tested patterns with size, color, and density controls. Outputs three forms: standalone .svg file (use as background-image: url(...)), Base64 data URL (inline in CSS), or PNG export (legacy fallback). Patterns are seamless — the right edge meets the left edge cleanly, the top meets the bottom — so any tile size repeats without visible seams. This guide explains how SVG patterns are constructed, when SVG beats CSS or PNG, and the gotchas with anti-aliasing at tile boundaries.

    SVG vs CSS vs PNG patterns

    Approach File size Best for
    CSS gradient ~80 bytes Dots, lines, stripes, simple grids
    SVG pattern 300-1500 bytes Triangles, hexagons, complex shapes, custom logos
    PNG tile 2-15 KB per tile Photographic textures, complex non-geometric

    If your pattern can be expressed as gradients (dots, lines, grids), use CSS — smallest payload. If it’s geometric but more complex than gradients allow (triangles, hexagons), use SVG. If it’s photographic or organic (paper texture, fabric weave), use PNG.

    SVG pattern anatomy

    A typical SVG pattern is a repeating tile defined inside a <defs> block, then referenced as a fill:

    <svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%">
      <defs>
        <pattern id="dots" x="0" y="0" width="20" height="20" patternUnits="userSpaceOnUse">
          <circle cx="10" cy="10" r="2" fill="#635BFF"/>
        </pattern>
      </defs>
      <rect width="100%" height="100%" fill="url(#dots)"/>
    </svg>

    The <pattern> element defines a 20×20 tile with a single circle at the centre. The outer rectangle fills the entire SVG with that pattern. Change pattern dimensions, fill colour, or geometry — the pattern updates automatically.

    How to generate an SVG pattern

    1. Open the SVG pattern generator
    2. Pick a shape from the gallery (60+ options across 5 categories)
    3. Adjust tile size, foreground color, background color, and density
    4. Watch the live preview render the seamless tile
    5. Export: standalone SVG file, Data URL (CSS-ready), or PNG rasterized at chosen resolution

    Using SVG patterns as CSS backgrounds

    Two ways to include an SVG pattern in CSS:

    • External file: background: url("/patterns/dots.svg") repeat; — saves a separate request, cacheable, scales with browser zoom.
    • Inline data URL: background: url("data:image/svg+xml;utf8,<svg...>") repeat; — no extra request, theme-able with CSS variables.

    For one-off patterns, inline data URLs save a round-trip; for patterns reused across many pages, external files cache better. For maximum flexibility, use a CSS variable for the pattern’s primary color: the data URL references it via fill="currentColor" or accepts injected colors via background-image stacking.

    60+ shapes shipped with the generator

    • Dots: uniform grid, scattered, halftone, polka, large/small mix
    • Triangles: equilateral, scalene, isometric grid, chevron, sawtooth
    • Hexagons: honeycomb, beehive, isometric, soccer-ball-style
    • Lines: diagonal, crosshatch, sketchy, double-line, wave
    • Scales: fish, dragon, oversized, miniature
    • Geometric: circles, squares, plus signs, asterisks, stars, arrows
    • Floral: abstract flower tile, art-deco fan
    • Tech: circuit traces, schematic, blueprint grid

    Common gotchas

    • Anti-aliasing at seams. If your shape touches the edge of the tile, anti-aliasing can produce visible vertical or horizontal lines where tiles meet. Add 1px padding inside the tile (so shapes don’t touch the edge) or use SVG’s shape-rendering: crispEdges.
    • Data URLs need careful escaping. Inline SVG in CSS data URLs needs URL encoding (%, #, ", etc.). Use ? as a safe alternative for < if your CSS toolchain breaks. Our generator outputs already-escaped data URLs.
    • Vector but not infinite. SVG patterns scale with display zoom but the pattern tile size is fixed in the generator output. To make tiles scale with viewport, use CSS background-size: 5vw 5vw or similar — but that distorts the pattern.
    • Custom fonts in patterns don’t work. If your pattern uses text glyphs (e.g., a tiled “★” character), include the font definition inline via @font-face in the SVG itself, or use SVG path data for the character. External font files won’t load in SVG-as-image contexts.
    • Pattern size affects performance. Tiny tiles (under 8×8) render slower than larger ones because the GPU has to repeat them more times. For very fine patterns, use a 32×32 tile with multiple instances inside.
    • Background-attachment: fixed + SVG patterns. Patterns repeat strangely with background-attachment: fixed on some browsers. Test before deploying parallax-style background effects.

    When NOT to use an SVG pattern

    For simple geometric patterns (dots, lines, grids), use CSS gradients — smaller payload, same effect. For photographic or organic textures (paper, fabric, watercolor), use a PNG with proper compression. For animated patterns (drifting, morphing), use a CSS animation on the SVG itself or a canvas-based approach. For very large patterns where the tile is 1000×1000+, you’re better off with a real image — at that size SVG offers no advantage over PNG. For extremely tight performance budgets, even a small SVG pattern adds 500–1500 bytes; CSS gradients add 80.

    Frequently asked questions

    Are SVG patterns faster than PNG?

    For most simple shapes: yes, smaller and faster. For very complex patterns or photographic-quality textures: no, PNGs (especially WebP or AVIF) compress better. Rule of thumb: if the pattern is geometric, SVG; if it’s organic, raster.

    Can I edit the SVG pattern after generating?

    Yes — the output is plain SVG markup. Open in any text editor, change fill values, adjust shapes inside the <pattern>, scale the tile dimensions. Or import into Figma / Illustrator / Inkscape for visual editing.

    Will the pattern look the same on retina displays?

    Yes — SVG is vector, so it renders pixel-perfect at any DPI. PNG patterns need 2× / 3× variants for retina; SVG doesn’t.

    Can I use CSS variables for pattern colors?

    Inside an SVG file referenced via external URL, CSS variables don’t propagate. For inline data URLs in your CSS, use currentColor in the SVG fills, then set color on the parent element to control the pattern’s primary color. For full theme support, generate the pattern programmatically and inject CSS variable values.

    Is my data uploaded?

    No. The generator runs in your browser. Pattern selections, customisations, and the generated SVG/PNG/data URL stay on your device.

    Can I use these patterns commercially?

    Yes — the generated SVG is your output, no attribution required. The shape templates are designed for any use including commercial work. The exception: if you upload your own custom shape and the original asset has licensing restrictions, those carry over to the generated pattern.

    Related tools and guides

     

  • Tweet to Image Converter: Beautiful Framed Posts [2026]

    Tweet to Image Converter: Beautiful Framed Posts [2026]

    TL;DR: A tweet-to-image converter takes a tweet URL (or composes a fresh tweet) and renders it as a polished image — typically a tweet card on a gradient backdrop, ready to repost on Instagram, LinkedIn, or paste into a slide deck. Used for cross-platform sharing, social media presentations, blog hero images, and quote graphics. Our free tweet-to-image tool ships gradient backdrop presets, font customisation, and 4K export. Browser-only.

    Sharing a tweet outside X usually means a screenshot, but screenshots are inconsistent — different OS, different fonts, different aspect ratios, sometimes including unrelated UI. Designers solved this by rendering tweets as clean rectangular images on branded backdrops. Buffer, Hypefury, and dozens of indie tools popularised the format around 2020; by 2026 it’s standard for cross-platform content.

    Our tweet-to-image converter takes a tweet URL (we extract the text, author, avatar, timestamp, and engagement metrics via X’s oEmbed API) or lets you compose a tweet from scratch. Drop into a gradient backdrop, pick a font (X’s font is licensed; we use a similar open alternative), set padding, and export at 4K resolution. The output looks like a polished social-media graphic, not a phone screenshot. This guide explains the workflow, the legitimate-vs-deceptive line, and the gotchas with verified badges and quote tweets.

    Common use cases

    Use case Why image instead of share?
    Repost your tweet on Instagram IG doesn’t render X embeds; image is the standard
    Quote in a blog post / article Image is portable; embed depends on X being available
    Slide for a presentation Slide tools handle images; X embeds break offline
    LinkedIn post LinkedIn unfurls X URLs poorly; image gets more reach
    YouTube thumbnail Pull a great tweet into a thumbnail
    Newsletter feature Inline image is reliable; embeds depend on email client

    How to convert a tweet to an image

    1. Open the tweet-to-image converter
    2. Paste a tweet URL (we fetch text, author, timestamp via X’s oEmbed) or compose a tweet from scratch
    3. Pick a gradient backdrop preset, or upload your own background
    4. Adjust padding, corner radius, and font
    5. Toggle metadata: show / hide engagement counts, timestamp, verified badge
    6. Export PNG at 1×, 2×, or 4× — copy to clipboard or download

    Legitimate vs deceptive use

    Legitimate: Reposting your own tweets, quoting public statements with attribution, marketing creative for content marketing campaigns, slides for a presentation, blog hero images, podcast episode artwork.

    Don’t:

    • Compose a fake tweet “from” a real person and pass it off as authentic
    • Use the verified-checkmark badge on accounts that don’t have one
    • Modify a real tweet’s text and pretend the author posted that text
    • Generate “leaked” tweets as proof in disputes — defamation laws apply

    The output looks polished enough to fool a casual viewer at first glance. With “fake tweet of a real public figure” being a common misinformation pattern, treat the line carefully — when in doubt, attribute clearly that the image is a generated mockup, not a screenshot of the real platform.

    Common gotchas

    • X’s font is licensed. X (Twitter) uses Chirp font commissioned from Grilli Type — licensed for X use only. Our generator uses Inter as a similar open alternative. Visual parity is close but the typography purist will spot the difference.
    • oEmbed has rate limits. X’s oEmbed endpoint allows roughly 60 requests per minute per IP. Heavy use can hit limits; for batch processing, build the URL programmatically rather than scraping per-tweet.
    • Private tweets can’t be fetched. Tweets from protected accounts return errors. Public tweets work; private don’t.
    • Quote tweets and threads. oEmbed returns just the top-level tweet content. Quote tweets and full threads need separate handling — our generator includes a “thread mode” that fetches each reply tweet’s URL and stacks them.
    • The blue checkmark since 2023. X’s verification system changed in 2023 — paid verification (Twitter Blue) replaced legacy verification. Including a checkmark in your generator is fine for self-tweets where you have it; don’t add it to others’ tweets where the real account doesn’t display one.
    • Engagement counts go stale. The like/retweet/reply numbers in your generated image are the values at fetch time. If the tweet gets bigger, the image is “out of date”. For social-media content, that’s usually fine; for journalism, fetch fresh.

    When NOT to use this tool

    For tweets you’ll embed on a website where the real X embed is acceptable, use X’s official embed code — it loads live engagement counts and links back to the tweet. For deceptive content (fake tweets, manipulated text, fake verifications), don’t use this tool; use of the output for deception is fraud or defamation depending on context. For batch processing of many tweets, install twitter-api-v2 in Node and write a script — much faster than running the tool per-tweet. For animated tweet cards (typing effect, like-count animation), use a video tool like CapCut or After Effects.

    Frequently asked questions

    Does it fetch tweet text from a URL?

    Yes — paste the URL of a public tweet and we fetch text, author, avatar, timestamp via X’s oEmbed API. Private tweets and tweets from suspended accounts return errors.

    Can I compose a fake tweet?

    Yes — switch to “compose mode” and type the tweet from scratch with custom username, display name, and avatar. Use this for tutorials, mockups, and creative work where no real tweet exists. Don’t use it to fabricate a tweet “from” a real person and pass it off as real.

    What resolution does it export?

    Three options: 1× (1200×630, suitable for social), 2× (2400×1260, retina), or 4× (4800×2520, print). Pick based on where you’ll publish — for X reposts to Instagram, 2× is enough; for slide decks at 4K, use 4×.

    Are the gradient backdrops licensed?

    The gradient presets are designed by us, free to use commercially. The output image is yours — no attribution required.

    Is my data uploaded?

    To fetch tweet text from a URL we call X’s oEmbed API — the URL goes from your browser to X. The image rendering happens entirely in your browser; the final image is not uploaded.

    Can I customise the styling?

    Yes — gradient backdrop, font (Inter or system fonts), padding, corner radius, light/dark theme, with/without metadata. Save your style preset to reuse the same visual identity across multiple tweets.

    Related tools and guides

     

  • Instagram Filters in CSS: Clarendon, Gingham, More [2026]

    Instagram Filters in CSS: Clarendon, Gingham, More [2026]

    TL;DR: Instagram’s classic filters (Clarendon, Gingham, Moon, Lark, Reyes, Juno, etc.) can be approximated in CSS by stacking filter properties — contrast, saturate, hue-rotate, sepia — with carefully tuned values per filter. The output isn’t pixel-identical to Instagram’s proprietary algorithms, but it captures the look closely enough for previews, demo apps, and design mockups. Our free Instagram filters tool ships 30+ filter presets, applies them to any image in your browser, and copies the equivalent CSS.

    Instagram launched its filter library in 2010, popularising the now-iconic looks: Clarendon (cool, high-contrast), Gingham (vintage warm), Moon (dramatic black-and-white), Lark (high-saturation outdoor), Reyes (faded warmth), Juno (warm and saturated). Instagram’s actual implementations are proprietary GPU shaders. CSS approximations using filter functions get close to the look — close enough that web designers use them to mimic Instagram’s aesthetic in their own UIs.

    Our Instagram filters in CSS tool ships 30+ tested filter approximations. Drop an image, click a filter to preview, copy the CSS or export the filtered image as PNG. Useful for: feed-style mockups, photo galleries with consistent filter looks, hover effects that mimic Instagram, demo apps showing “before/after” filter comparisons. This guide explains how the CSS approximations work, where they fall short of Instagram’s real shaders, and the gotchas with hue-rotate.

    CSS approximations of classic filters

    Filter CSS approximation Aesthetic
    Clarendon contrast(120%) saturate(125%) High-contrast cool tones
    Gingham contrast(90%) brightness(105%) sepia(8%) Faded vintage warmth
    Moon grayscale(100%) contrast(110%) brightness(110%) Dramatic B&W
    Lark contrast(95%) saturate(110%) brightness(110%) Outdoor / nature
    Reyes sepia(22%) brightness(110%) contrast(85%) saturate(75%) Faded warm
    Juno saturate(130%) contrast(105%) hue-rotate(-10deg) Warm + saturated
    Walden brightness(110%) hue-rotate(-10deg) sepia(30%) saturate(160%) Bright yellow-tint
    1977 contrast(110%) brightness(110%) saturate(130%) sepia(50%) Faded film, retro

    Why CSS approximations aren’t exact

    Instagram’s filters are GPU shaders that operate per-pixel with custom curves, masks, and blend modes. CSS filter functions (contrast, saturate, hue-rotate, sepia) are simpler linear or per-channel transforms. The differences:

    • Tone curves: Instagram applies S-curves and custom tone-mapping that CSS can’t do directly. Our approximations use linear contrast/brightness, which gets close but not pixel-identical.
    • Per-channel adjustments: Real filters often boost reds and dampen blues separately. CSS can do hue-rotate (rotate all hues equally) but not selective per-color editing.
    • Lookup tables (LUTs): Many real filters use 3D LUTs to map every input color to an output color. CSS has no equivalent.
    • Blend modes: Instagram filters layer on tints with screen / multiply / overlay blend modes. CSS supports mix-blend-mode but only on stacked elements, not on the image itself directly.

    For a 95% accurate match in the browser, our approximations are the practical limit. For pixel-exact reproduction, use a dedicated image-processing library (Pixi.js, GLFX) with custom GLSL shaders.

    How to apply Instagram-style filters

    1. Open the Instagram filters tool
    2. Drop an image (or use one of the demo photos)
    3. Click any filter preset to preview live
    4. Adjust strength slider (0–150% — higher than 100% over-applies the effect)
    5. Click Export to bake the filter into a PNG/JPG, or Copy CSS for the equivalent filter declaration

    Common gotchas

    • The Instagram filter trademarks belong to Meta. Filter names like “Clarendon”, “Gingham”, “Moon” are Meta trademarks. Using them in your own product to label CSS approximations is legally grey — for commercial work, use generic names (“Cool”, “Vintage”, “B&W”) to avoid confusion. Our generator labels them with the recognisable names for educational reference.
    • Filters change Instagram’s CSS implementations evolve. Instagram has updated filter algorithms several times. Approximations that matched the look in 2018 may not match the 2026 version exactly.
    • Hue-rotate is unintuitive. Rotating hue by 10° shifts blue toward purple, but the same 10° from yellow lands in green. Test with the actual image — don’t pick angles by intuition.
    • Filters compound badly. Stacking 3+ filters at full strength produces over-processed output. Real Instagram filters are designed as single composites. Keep filter stacks short and adjust strength globally.
    • JPEG compression after filtering. Heavy filters (high contrast, high saturation) push pixels into JPEG’s compression-friendly bands, then JPEG compression can’t capture the subtleties. For high-quality output, export PNG and convert to JPEG only at the final step.
    • CSS filter is render-time, not destructive. Applied via CSS filter: declaration, the original image stays unchanged in the DOM. Apply via canvas (the export path) when you want a permanent change.

    When NOT to use CSS Instagram filters

    For pixel-exact recreation of Instagram’s filters (e.g., for a competitive analysis), you need either Instagram itself or a dedicated GLSL implementation — CSS can’t reach that fidelity. For commercial product features (“apply Instagram filter to your photo”), use proper trademark-friendly names and don’t mention “Instagram” in your UI without licensing. For batch image processing in CI, use sharp + custom transforms in Node — much faster than running through a browser tool. For animated filter transitions (smoothly cross-fading between filters), use CSS transitions on the filter property — works but limited to functions CSS supports.

    Frequently asked questions

    Are these the actual Instagram filters?

    No — they’re CSS approximations. Instagram’s real filters are proprietary GPU shaders. Our CSS combines contrast, saturate, hue-rotate, sepia, etc. to match the look. Visually similar; not pixel-identical.

    Can I use the filter names commercially?

    “Clarendon”, “Gingham”, “Moon” etc. are Meta trademarks. For commercial products labelling filter options, use generic names (“Cool”, “Vintage”) to avoid trademark issues. The CSS techniques themselves are open and free to use.

    Does it support PNG transparency?

    Yes — PNG alpha channels survive every filter. Drop-shadow specifically uses the alpha channel for the silhouette. JPEG inputs don’t have alpha; the rectangular bounding box shows in any drop-shadow.

    Can I apply filters in CSS without baking them in?

    Yes — that’s the use case for the “Copy CSS” option. Apply via img { filter: contrast(120%) saturate(125%); } in your stylesheet, and the original image stays untouched. Use baking (PNG export) when you want the filter permanent.

    Is my image uploaded?

    No. Filters apply via canvas in your browser. The image is loaded into a blob URL and processed locally.

    Can I create a custom filter?

    Yes — use the “Custom” mode and adjust each CSS filter function manually with sliders. Save your settings as a named preset. Useful for matching a brand-specific look across many images.

    Related tools and guides

     

  • Average Color of an Image: Finder Tool [2026]

    Average Color of an Image: Finder Tool [2026]

    TL;DR: An image average color finder computes the single colour that best represents an image — usually the arithmetic mean of every pixel’s RGB values. The mean often produces a muddy gray for colourful images; the dominant colour (most-frequent cluster) is usually more useful. Used for hero gradients that match a photo, fallback colours while a lazy-loaded image loads, theme-detection from album art, and accessibility checks. Our free image average color finder reports mean, median, and dominant in one go.

    “What’s the average colour of this image?” is a deceptively simple question. The naive answer — sum every pixel’s red, green, and blue values, divide by total pixels — produces the mean colour, but that’s often a muddy brown that doesn’t match anyone’s intuition of what the image “looks like”. A bright photo of a sunset (oranges, reds, dark blues) averages to a dull purple-grey. The dominant colour — the colour that appears most frequently after clustering — is usually a more useful answer.

    Our image average color finder reports four different metrics at once: mean (arithmetic average), median (the colour at the centre of the distribution), dominant (most common after clustering), and weighted average (excluding background pixels). Pick the one that matches your need. Drop in any image, get all four values as HEX/RGB/HSL/OKLCH, plus a CSS-variable export. Browser-only.

    Mean vs median vs dominant — pick the right metric

    Metric How it’s computed Best for
    Mean Sum each channel, divide by pixel count Lazy-load placeholders (BlurHash equivalent)
    Median Value at the 50th percentile per channel Robust against outlier pixels
    Dominant Most common cluster after K-means k=1 Theme detection, brand-color extraction
    Weighted Mean excluding near-white / near-black Photos with white background; ignores chrome
    Center-weighted Mean with central pixels weighted higher Subject-focused content (portraits, product shots)

    Why mean often disappoints

    Imagine an image of a sunset: red sun, orange sky, blue water. The mean of red + orange + blue is a desaturated brown-grey — a colour that nothing in the image actually is. Mean is a statistical average, not a perceptual representative. For lazy-load placeholders this is fine (you want a single colour that’s unobtrusive), but for “what colour is this image?” answers, dominant is usually closer to intuition.

    Mean works well for:

    • Image-loading placeholders (Material Design’s blur-up technique)
    • Fallback background colour while lazy-loading
    • Generating a complementary text-overlay colour

    Dominant works better for:

    • Theme detection — pick a UI accent colour matching a hero photo
    • Brand-colour extraction from a logo
    • Generating gradient backgrounds that “match” the image

    How to find the average color

    1. Open the average color finder
    2. Drop your image (JPG, PNG, WebP, HEIC supported)
    3. The tool computes mean, median, dominant, weighted average — all four — in 1–2 seconds
    4. Pick the metric that fits your use case; copy HEX, RGB, HSL, or OKLCH
    5. Export as CSS variable (--image-color: #94896D) for direct use in stylesheets

    Common gotchas

    • Transparent pixels affect mean. By default we count fully-transparent pixels as the chosen “background” colour (white by default). Toggle “ignore alpha” to skip them entirely — better for logos on transparent backgrounds.
    • Resolution affects performance. Computing mean is O(n) over pixel count. A 4000×3000 image (12M pixels) processes in ~200ms; a 12000×9000 image (108M pixels) takes ~2 seconds. The tool downsamples to 1024×1024 internally for speed — visually identical result for any image larger than that.
    • JPEG compression artefacts shift the mean. Heavily compressed JPGs introduce per-block colour shifts that pull the mean toward greys. For brand-color work, use original PNG / TIFF / WebP if available.
    • EXIF rotation matters. A photo from a phone may be stored sideways with EXIF rotation metadata. Our tool reads the EXIF orientation and applies it before computing — ensures the “mean” is over the visible image, not a sideways version.
    • Per-region sampling for hero images. A hero image often has chrome at the top (logo, navigation) that you don’t want included in the average. Use the “region” tool to draw a rectangle covering only the photographic content, then compute over that.
    • Color space matters. Mean in RGB space biases toward greys (perceptually inaccurate). Mean in OKLab space produces a more perceptually-uniform answer. Our tool reports both — pick OKLab for design work, RGB for compatibility.

    When NOT to use this tool

    For a multi-colour palette extracted from an image, use the Image Color Extractor — it returns 2–12 colours via K-means clustering. For pixel-perfect colour sampling at a single point, use the Image Color Picker — it shows the exact colour under your cursor. For lazy-load placeholders in production, libraries like plaiceholder or blurhash are more efficient than recomputing on every page load. For colour-detection in real-time video, use OpenCV.js or a WebGPU shader — much faster than per-frame canvas sampling.

    Frequently asked questions

    Why does the mean colour look different from the image?

    Mean is a statistical average across all pixels. For images with high colour variation (sunsets, landscapes), the mean often lands in muddy territory — desaturated brown or grey — because opposing colours cancel out. The dominant colour is usually closer to what you’d intuitively call “the image’s colour”.

    Mean, median, or dominant — which should I use?

    For lazy-load placeholders: mean (unobtrusive). For theme detection or brand-colour extraction: dominant. For photos with extreme outliers (one bright spot in a dark image): median. Try all four — our tool computes them simultaneously and shows all swatches.

    Does it support transparent backgrounds?

    Yes — toggle “ignore alpha” to skip transparent pixels entirely. Otherwise transparent pixels are blended against your chosen background colour (white by default). Critical for logos on transparent backgrounds.

    Can I sample a specific region?

    Yes — draw a rectangle on the image to limit the sample area. Useful for hero images where you want to skip the navigation chrome, or product photos where you want to skip the white background.

    Is my image uploaded?

    No. The finder runs in your browser via the canvas API. Image data is processed locally — never sent to our servers.

    What’s the difference between OKLab and RGB averaging?

    Averaging in RGB biases toward greys because R+G+B sums tend to centre around perceptual middle. Averaging in OKLab (a perceptually-uniform colour space) produces a result closer to what the eye perceives as the “centre” of the image’s colour distribution. Our tool reports both for comparison.

    Related tools and guides

     

  • SVG Stroke to Fill Converter: Outline-to-Path [2026]

    SVG Stroke to Fill Converter: Outline-to-Path [2026]

    TL;DR: An SVG stroke-to-fill converter takes paths drawn with stroke="..." + stroke-width="N" and replaces them with filled outline paths that produce identical visual rendering — but as filled regions, not strokes. Necessary for laser cutters, CNC routers, vinyl plotters, embroidery machines, and any pipeline that scales SVGs without honouring stroke-width. Our free SVG stroke-to-fill tool uses the same path-offset algorithms as Inkscape and Illustrator’s “Stroke to Path” command.

    SVG paths can be rendered two ways: with a stroke (a line drawn along the path with a configurable width) or as a fill (the area enclosed by the path is filled with colour). Visually they can look identical — a 4px black stroke around a circle and a filled donut shape with the same dimensions render the same. But many pipelines that consume SVG ignore stroke entirely:

    • Laser cutters (Glowforge, Epilog, AxiDraw): cut along path centerlines, but interpret fill as engraving area. A stroked path may be cut as the path itself with no width.
    • CNC routers (vCarve, Carbide Create): treat stroke-width as visual decoration, not toolpath geometry.
    • Vinyl plotters (Cricut, Silhouette): cut along paths; stroke-width has no effect on the cut.
    • Embroidery digitisers: convert paths to stitches; strokes need explicit fill geometry.
    • Some printers and PDF generators: round stroke-width to nearest pixel multiple at low DPI.

    The fix: convert every stroke to a filled outline path before exporting. Our SVG stroke-to-fill converter does this automatically — paste your SVG, get back a version where every stroked path has been replaced with an equivalent filled outline. The visual rendering is unchanged in browsers but the geometry is now portable across every SVG-consuming pipeline.

    When you need stroke-to-fill conversion

    Pipeline Honours stroke-width? Action
    Web browser rendering Yes No conversion needed
    Print PDF Mostly Convert if printing under 100 DPI
    Laser cutter (Glowforge, Epilog) No Convert before export
    CNC router (Shapeoko, Carbide) No Convert before export
    Vinyl plotter (Cricut) No Convert before export
    Embroidery (PE-Design) No Convert before export
    Figma / Illustrator export Yes No conversion needed

    How the conversion works

    The technique is path offsetting. For a path defined by a series of points, the offset path is a new path running parallel to the original at a constant distance (half the stroke-width) on each side. The two offset paths plus the rounded line caps form a closed outline — a filled region equivalent to the stroked line.

    Edge cases that need careful handling:

    • Line caps: butt, round, square. Each requires different geometry at the path endpoints.
    • Line joins: miter, round, bevel. Where path segments meet, the corners need different treatments.
    • Self-intersections: a path that crosses itself produces overlapping offset regions that need union-ing.
    • Bezier curves: the offset of a Bezier isn’t itself a Bezier — it’s approximated with multiple Bezier segments.

    Most converters (including ours) use the Clipper library or paper.js’s PathOffset algorithm — the same code Inkscape’s “Stroke to Path” command runs.

    How to convert SVG strokes to fills

    1. Open the SVG stroke-to-fill converter
    2. Paste your SVG markup or upload an .svg file
    3. The tool detects every stroked path and converts each to a filled outline
    4. Preview shows before/after side by side — should look visually identical
    5. Click Download for the converted SVG

    Common gotchas

    • Output is bigger. A filled-outline path has more points than the stroked version. File size typically grows 30–80%. For laser/CNC export this is fine; for web rendering, keep the stroked version.
    • Anti-aliasing differs slightly. Browsers anti-alias strokes differently from filled paths. Visual difference is usually invisible but exists at the pixel level — zoom to 400% and you may see edge differences.
    • Doesn’t simplify nested groups. If your SVG has nested <g> groups with transforms, the conversion preserves the structure. Some legacy laser-cutter software trips on nested groups; flatten with a separate pass if needed.
    • Stroke-dasharray becomes dashed filled paths. Dashed strokes (stroke-dasharray) convert to multiple separate filled segments. Visual is correct but the path count multiplies.
    • Round caps and joins add curve segments. A path with stroke-linecap="round" gets quarter-circle Bezier curves at endpoints in the output. Visual unchanged; geometry slightly more complex.
    • Variable stroke widths aren’t standard SVG. If you’ve used a non-standard stroke-width-variable extension (Illustrator’s variable-width strokes), the tool can’t reproduce that — it treats stroke-width as constant per path.

    When NOT to use this tool

    If your destination consumes SVG with full stroke support (modern browsers, Adobe Illustrator, Figma, Affinity), don’t convert — it bloats the file with no benefit. For web SVG, stroke-width is rendered correctly everywhere. For interactive SVG (paths animated with stroke-dasharray for “drawing” effects), don’t convert — you’ll lose the ability to animate the stroke offset. For SVGs you’ll edit later in a vector tool, keep strokes — they’re easier to manipulate than filled outlines. Use this tool only when exporting to a destination that ignores stroke-width.

    Frequently asked questions

    Why do I need to convert strokes for laser cutters?

    Laser cutters cut along path geometry, not stroke decoration. A 4mm-wide stroked line in your design isn’t a 4mm-wide cut — the cutter follows the centerline of the path. To produce a 4mm-wide cut region, the geometry must be a filled 4mm-wide outline shape. Conversion makes the geometry match what the cutter sees.

    Will the output look the same in a browser?

    Yes — visually identical at typical viewing zoom. Browsers anti-alias strokes and fills slightly differently, so at 400%+ zoom you might see edge differences, but the rendered effect is the same.

    Does it support all SVG features?

    Most: line caps (butt, round, square), line joins (miter, round, bevel), dashed strokes, miter limits, transforms. It doesn’t handle: variable-width strokes (Illustrator extension), stroke alignment (Inkscape’s stroke-alignment=”inset/outset”), or pattern-based strokes. Those convert with imperfect approximations.

    What’s the file-size penalty?

    Typically 30–80% larger output. A 12 KB SVG with strokes becomes 18–22 KB after conversion. The growth comes from filled outlines having more path points than centerline strokes, especially with rounded line caps.

    Is my SVG uploaded?

    No. The converter runs in your browser. SVG markup is processed locally — never sent to our servers.

    Can I batch-convert many SVGs?

    For one or two files, this tool is fastest. For batch processing (50+ files), use Inkscape’s command line: inkscape --export-type=svg --export-text-to-path --export-area-page --export-stroke-to-path *.svg. Same algorithm, scriptable.

    Related tools and guides