MarknadenUtforskaProva
Priser
Logga inKom igång
FältguidenCSS och webb
CSS och webb

WebGL-gradientshaders förklarade för designers

Vissa gradienter på webben driver, glöder och skimrar på ett sätt ingen bild eller CSS-regel kan. De är shaders. Så fungerar de, med ord en designer kan använda.

GradientlyVerifierat Gradiently-konto·1 oktober 2026·6 minuters läsning
Omslag: Nara Key · GR·RXWA·2K

Kortversionen

  • En WebGL-gradient ritas av en shader: ett litet program som körs på grafikchippet och avgör färgen på varje pixel, ofta många gånger i sekunden.
  • Eftersom en shader räknar ut färg ur matematik i stället för att läsa en lagrad bild kan den lägga till rörelse, brus, korn och ljus i vilken storlek som helst utan att filen blir större.
  • Shadergradienter kostar mer att köra än CSS-gradienter, så en bra sådan pausar när den är utanför skärmen, respekterar minskad rörelse och har en enkel CSS-reserv.
  • Använd CSS för statiska övergångar och enkel rörelse, och ta till en shader när texturen, djupet eller rörelsen är poängen med designen.
På den här sidan
Vad en shader är, med enkla ordHur en shadergradient skiljer sig från en CSS-gradientDärför känns shadergradienter levandeKostnaden för en rörlig WebGL-bakgrundDesigna en shadergradient: vad du ska angeSå ritar Gradiently Marks med shaders

En WebGL-gradient är en gradient som din webbläsare målar med en shader: ett kort program som körs på grafikchippet (GPU:n) och svarar på en fråga för varje pixel på skärmen, ”vilken färg har du just nu?” En CSS-gradient är ett fast recept av färger och positioner. En shader är en formel, så den kan böja, ge korn åt, låta glöda och flytta färgen, och göra om det sextio gånger i sekunden, utan att någon bild laddas ner.

Du behöver inte skriva shaders för att designa med dem, men att veta vad de kan och inte kan hjälper dig att instruera en utvecklare, bedöma ett verktyg och avgöra när en vanlig CSS-gradient är det bättre valet.

Vad en shader är, med enkla ord

WebGL är webbläsarens sätt att tala med GPU:n, och varje WebGL-ritning använder två sorters shader. Vertexshadern placerar former; för en gradient i helskärm är det bara en rektangel som täcker duken. Fragmentshadern gör det intressanta jobbet: den körs en gång per pixel, tar emot pixelns position och den aktuella tiden och returnerar en färg.

Eftersom GPU:n kör tusentals av de här små programmen parallellt blir en formel som skulle vara långsam i vanlig kod billig nog att rita om varje bildruta. Här är en komplett fragmentshader för en trefärgsgradient vars gräns svajar mjukt över tid, med en rad korn ovanpå.

text
#version 300 es
precision highp float;

uniform vec2 u_resolution;   // bildytans storlek i pixlar
uniform float u_time;        // sekunder sedan start
out vec4 outColor;

void main() {
  vec2 uv = gl_FragCoord.xy / u_resolution;   // 0 till 1 över bildytan

  vec3 night  = vec3(0.07, 0.04, 0.18);  // #120a2e
  vec3 violet = vec3(0.49, 0.23, 0.93);  // #7c3aed
  vec3 coral  = vec3(0.98, 0.45, 0.45);  // #fa7373

  // En långsam våg böjer övergången så att färgerna glider.
  float wave = sin(u_time * 0.3 + uv.x * 3.0) * 0.08;
  float t = clamp(uv.y + wave, 0.0, 1.0);

  vec3 color = mix(night, violet, smoothstep(0.0, 0.6, t));
  color = mix(color, coral, smoothstep(0.55, 1.0, t));

  // Fint korn: ett nytt slumpvärde per pixel och bildruta.
  float n = fract(sin(dot(gl_FragCoord.xy + u_time, vec2(12.9898, 78.233))) * 43758.5453);
  color += (n - 0.5) * 0.04;

  outColor = vec4(color, 1.0);
}
En WebGL2-fragmentshader i GLSL. smoothstep mjukar upp varje övergång, sinusvågen flyttar gränsen och de sista raderna lägger till korn som också döljer bandning.
De tre färgerna i shadern. GLSL skriver färg som 0 till 1 per kanal, så #7c3aed blir 124, 58 och 237 delat med 255.

Hur en shadergradient skiljer sig från en CSS-gradient

En CSS-gradient är deklarativ: du listar färger och positioner, och webbläsaren målar dem. Det är rätt verktyg för det mesta. En shader är procedurell: du beskriver hur färg ska bete sig, och matematiken producerar den. Den skillnaden syns i vad var och en kan göra och vad var och en kostar.

Definieras av

CSS-gradient

Färger, stopp och en riktning

Shadergradient

En formel som körs per pixel
RörelseFlyttad position, storlek eller animerade egna egenskaper

Shadergradient

Allt du kan uttrycka i matematik, varje bildruta
Textur och korn

CSS-gradient

Behöver ett extra lager, som SVG-brus

Shadergradient

Inbyggt, och det kan röra sig
Kostnad att köra

CSS-gradient

Mycket låg när den väl är målad

Shadergradient

Håller GPU:n sysselsatt medan den animeras
Fungerar utan JavaScript

CSS-gradient

Ja

Shadergradient

Nej: ett skript ställer in duken
Fungerar i mejl

CSS-gradient

Delvis, beroende på klienten

Shadergradient

Nej
AspektCSS-gradientShadergradient
Definieras avFärger, stopp och en riktningEn formel som körs per pixel
RörelseFlyttad position, storlek eller animerade egna egenskaperAllt du kan uttrycka i matematik, varje bildruta
Textur och kornBehöver ett extra lager, som SVG-brusInbyggt, och det kan röra sig
Kostnad att köraMycket låg när den väl är måladHåller GPU:n sysselsatt medan den animeras
Fungerar utan JavaScriptJaNej: ett skript ställer in duken
Fungerar i mejlDelvis, beroende på klientenNej
Ingen är bättre i allmänhet. Var och en vinner på ett annat jobb.
CSS-reservenlinear-gradient(180deg, #120a2e 0%, #4c1d95 40%, #7c3aed 62%, #fa7373 100%)
Samma palett som en stillastående CSS-gradient. Varje shaderbakgrund bör levereras med en reserv som den här, som visas innan shadern startar och närhelst den inte kan köras.

Därför känns shadergradienter levande

Tre tekniker gör det mesta av jobbet, och du kommer att höra utvecklare nämna dem. Brus är mjuk slumpmässighet: i stället för en rak övergång följer färgen ett landskap av mjuka kullar, vilket är varför shadergradienter ser organiska ut snarare än geometriska. Domain warping matar tillbaka brus i sig självt, så att färgen viks och virvlar som bläck i vatten. Tid glider hela landskapet framåt, vilket förvandlar ett stilla fält till en drift.

  • Korn kan genereras per pixel och per bildruta, så att det skimrar som film i stället för att sitta stilla som en textur lagd ovanpå. Se korniga gradienter.
  • Ljus kan fejkas med några rader: en högdager som följer bruset läses som glans på siden eller glas.
  • Upplösning är gratis. Formeln körs i den storlek skärmen har, så en shadergradient förblir skarp på en telefon och på en 4K-skärm med samma kod.
  • Bandning är lättare att slå, eftersom shadern kan lägga till lite dither innan färgen avrundas till 8 bitar. Gradientbandning förklarar varför det spelar roll.

Använd CSS när

  • Gradienten är stilla, eller rör sig på ett enkelt sätt
  • Den ligger bakom mycket text på en lång sida
  • Den måste fungera med skript avstängda, eller i mejl
  • Du behöver den på en rad kod

Använd en shader när

  • Rörelsen eller texturen är poängen med designen
  • Det är ett hero-område, inte varje sektion
  • Du vill ha korn, glans eller flöde som CSS inte kan fejka
  • Du kan ge en CSS-reserv och en paus

Kostnaden för en rörlig WebGL-bakgrund

En shader som animeras håller GPU:n igång så länge den syns på skärmen. På en dator märks det knappt. På en äldre telefon kan det betyda varma händer, ett batteri som töms och en sida som scrollar mindre mjukt. Kostnaderna växer med antalet pixlar och formelns komplexitet, så en shader i helskärm på en skärm med hög täthet är det tyngsta fallet. Gör gradienter en webbplats långsammare tar upp hur du mäter det.

  1. 1

    Visa CSS-reserven först

    Måla den stillastående gradienten direkt och tona sedan in duken när shadern har ritat sin första bildruta. Ingen ska se en tom ruta.

  2. 2

    Kontrollera att WebGL finns

    Vissa webbläsare, enheter och integritetsinställningar stänger av det. Om kontexten inte kan skapas, behåll reserven.

  3. 3

    Respektera minskad rörelse

    Om besökaren ber om mindre rörelse, rita en bildruta och stanna. Minskad rörelse förklarar inställningen.

  4. 4

    Pausa när den inte syns

    Stoppa animationsloopen när duken scrollar ut ur bild eller fliken är dold.

  5. 5

    Rendera i en rimlig upplösning

    Mjuka gradienter behöver sällan varje enhetspixel. Att rita i halv upplösning och låta webbläsaren skala upp kan minska arbetet mycket för en suddighet du inte kan skilja från originalet.

js
const canvas = document.querySelector('#hero-canvas')
const gl = canvas.getContext('webgl2')
const still = matchMedia('(prefers-reduced-motion: reduce)').matches
let visible = true

if (!gl) {
  canvas.remove() // the CSS gradient behind it stays
} else {
  new IntersectionObserver(([entry]) => {
    visible = entry.isIntersecting
  }).observe(canvas)

  const frame = (ms) => {
    if (visible && !document.hidden) draw(gl, ms / 1000) // your draw call
    if (!still) requestAnimationFrame(frame)
  }
  requestAnimationFrame(frame)
}
Skyddsräckena på några rader: en reserv när WebGL saknas, bara en bildruta vid minskad rörelse och ingen ritning utanför skärmen eller i en dold flik.

Som referens dokumenterar WebGL API på MDN varje anrop som används här, och caniuse följer stödet för WebGL2 i olika webbläsare.

Designa en shadergradient: vad du ska ange

Du kan styra en shader utan att läsa GLSL. Instruera den som du skulle instruera ett material, inte ett färgprov. Ange bottenfärgen och de tre till fem färger som lever på den, i hex. Beskriv strukturen: mjuka pooler, långa band, veckat siden. Ange farten i sekunder per cykel i stället för ”långsam”, eftersom långsam betyder olika saker för olika människor. Säg hur mycket korn, och om det rör sig. Säg till sist var texten ska sitta, så att fältets livligaste del hålls borta från den.

Bedöm den stilla först

Pausa shadern på en slumpmässig bildruta och titta på den som en stillbild. Om en stillbild inte ser bra ut räddar inte rörelsen den. Rörelse ska tillföra något till en design som redan fungerar.

Så ritar Gradiently Marks med shaders

Marks i Gradiently är shadergradienter. Varje Mark är ett recept av färger, upp till tre staplade material, ljus, korn och rörelse, och Studion ritar den live med WebGL2 bakom allt du designar. Eftersom den räknas ut i stället för att lagras renderas samma Mark skarpt i vilken plattformsstorlek som helst och rör sig när du exporterar en loopvideo. Renderaren vet också var dina ord finns, så den kan flytta fältets lugnaste del bakom dem. Vad är en Mark förklarar receptet i sin helhet.

GR·RXWA·2K

Nara Key

Se den här Marken
En Mark är ett shaderrecept med ett namn, en kod och en ägare. Dess sida visar den renderas live.

Hitta en gradient som bara är din

Bläddra bland tusentals Marks, designa med vilken som helst av dem utan kostnad och säkra den som känns som du.

Utforska Marknaden

Vanliga frågor

Vad är en WebGL-gradient?

Det är en gradient ritad av en shader, ett litet program som körs på grafikchippet och räknar ut färgen på varje pixel. Eftersom den är en formel kan den röra sig, lägga till korn och renderas i vilken storlek som helst.

Är en shadergradient dålig för prestandan?

En stillastående eller pausad shader kostar lite, men en som animeras håller GPU:n sysselsatt medan den syns på skärmen. Pausa den när den är utanför bild, rita i en rimlig upplösning och behåll en CSS-reserv.

Respekterar shadergradienter inställningar för minskad rörelse?

Bara om de är byggda för det. Kontrollera mediefrågan prefers-reduced-motion i JavaScript och rita en enda stillbildsruta när den är satt.

Vad är GLSL?

GLSL är det shaderspråk WebGL använder. Fragmentshaders skrivna i det avgör färgen på varje pixel, och webbläsaren kompilerar dem för grafikchippet.

Dela den här guiden

Skriven av GradientlyVerifierat Gradiently-konto

Teamet bakom Gradiently, ett designverktyg byggt kring Marks: levande gradienter som får allt du gör att kännas som ditt.

Se vår profil

På den här sidan

Vad en shader är, med enkla ordHur en shadergradient skiljer sig från en CSS-gradientDärför känns shadergradienter levandeKostnaden för en rörlig WebGL-bakgrundDesigna en shadergradient: vad du ska angeSå ritar Gradiently Marks med shaders

Dela den här guiden

Nästa i CSS och webb

Gradientbakgrunder i mejl: vad som fungerar i Gmail och Outlook

Läs vidare

Alla guider om CSS och webb
CSS och webb

Animerade gradientbakgrunder i CSS, gjorda rätt

4 minuters läsning

Gradienter kan inte animeras direkt, men allt runt dem kan. Fyra tekniker, vad var och en kostar webbläsaren och hur du håller rörelsen lugn och valfri.

CSS och webb

CSS mesh-gradient: så bygger du en av radiella lager

5 minuters läsning

Det finns ingen mesh-gradient() i CSS. Här är lagermetoden som fejkar en på ett övertygande sätt, oskärpan och kornet som gör den färdig, och när en bild eller en shader är det bättre valet.

CSS och webb

CSS-gradienters prestanda: gör de en webbplats långsammare?

6 minuters läsning

En statisk CSS-gradient är nästan gratis. Kostnaderna kommer av vad folk gör med gradienter: enorma oskärpor, bakgrunder som ritas om vid scroll och animationer som aldrig slutar. Så ser du skillnaden.

Hitta looken som bara är din.

Varje Mark är en levande bakgrund med en enda ägare. Prova en ledig Mark och säkra din när det känns rätt.

Börja designaSe lanseringserbjudandet

Marks kvar att säkra

50av 1 000

950 säkrade hittillsHitta din

Kontrollera ett certifikat

Skriv ett certifikatnummer eller en Marks kod för att se vem som äger den.

Fungerar med ChatGPT och Claude

Be din AI om en design. Den skapar den i din Mark, redo att redigera.

ChatGPTClaude
Så ansluter du

Produkt

  • Marknaden
  • Utforska
  • Priser
  • Lanseringspaket
  • Certifikat

Lär dig

  • Fältguiden
  • Hjälpcenter
  • Nyheter

Utvecklare

  • Översikt
  • ChatGPT och Claude
  • API-referens
  • API-nycklar

Företaget

  • Om oss
  • Kontakta oss
  • Logga in

Juridik

  • Villkor
  • Integritet
  • Återbetalningar
  • Mark-skydd
  • Cookies
  • Alla policyer
Rör dig över bokstäverna. Var och en bär en riktig Mark.Tryck på en bokstav för att se dess Mark.Ett namn. Tio Marks inuti.
© 2026 Gradiently