Recomposed
Shader

Einführung in Shader

Oct 20, 2026 · 5 min read

Einführung in Shader

Was ein Shader eigentlich ist

Ein Shader ist ein kleines Programm, das die GPU ausführt, keine Funktion, die man einmal aufruft. Bei einem läuft dieses Programm einmal pro Pixel, für jedes Pixel innerhalb der gezeichneten Fläche, in jedem einzelnen Frame.

AGSL (Android Graphics Shading Language) ist Androids Shader-Sprache. Sie ist keine Neuerfindung, sondern ein eingeschränkter Dialekt von , das selbst nahe an GLSL ES liegt. Man schreibt sie als einfachen String, kompiliert sie zur Laufzeit mit RuntimeShader und verwendet das Ergebnis überall dort als Brush oder RenderEffect, wo Compose eines erwartet.

Die Intuition

Es liegt nahe, sich einen Shader als Filter vorzustellen, den man einmal konfiguriert und auf ein ganzes Bild anwendet, so wie BlurEffect oder ColorMatrix funktionieren. So ist ein Shader nicht. Er kommt eher einer Funktion gleich, die keine Ahnung hat, dass überhaupt ein Bild existiert:

  • Die GPU ruft die main-Funktion des Shaders für jedes Pixel in der Zeichenfläche separat auf, parallel, ohne garantierte Reihenfolge zwischen den Aufrufen.
  • Jeder Aufruf kennt nur seine eigene Pixelkoordinate und die -Werte, die man ihm vor dem Zeichenaufruf übergeben hat. Er kann kein benachbartes Pixel lesen, nicht über das Bild iterieren und sich an nichts vom Nachbarpixel oder vom vorherigen Frame erinnern.
  • Alles, was ein Shader über seine eigene Koordinate hinaus "sieht", eine Textur, einen Gradienten, die Ausgabe des letzten Frames, muss explizit abgetastet werden, denn zwischen den Aufrufen wird nichts implizit geteilt.

Das ist der ganze mentale Wechsel: Ein Shader beschreibt die Farbe eines Pixels als reine Funktion seiner Koordinate und seiner Uniforms, und die GPU ist das, was diese Beschreibung Millionen Mal pro Frame ausführt.

Ein minimaler AGSL-Shader

Hier ist ein Fragment-Shader, der ein animiertes Plasmafeld zeichnet: Die Farbe wird aus der Position jedes Pixels und der aktuellen Zeit berechnet und fügt sich zu Bändern zusammen, die sich kontinuierlich verschieben. Ein Brush.radialGradient kann eine statische Vignette vortäuschen, aber nichts in Brush kann das hier vortäuschen, weil die Farbe an jedem Pixel eine nichtlineare Funktion von zwei Eingaben gleichzeitig ist, Position und Zeit, die von der GPU in jedem einzelnen Frame neu berechnet wird. Der AGSL-Quelltext ist ein String, nicht anders als jedes andere Kotlin-String-Literal:

private const val PLASMA_SHADER = """
    uniform float2 resolution;
    uniform float time;
 
    half4 main(float2 fragCoord) {
        float2 uv = fragCoord / resolution;
        float wave = sin(uv.x * 10.0 + time) + cos(uv.y * 10.0 - time * 1.3);
        float3 color = 0.5 + 0.5 * cos(float3(wave, wave + 2.0, wave + 4.0));
        return half4(color, 1.0);
    }
"""

Man beachte, was main tatsächlich erhält: fragCoord, das Pixel, für das genau dieser Aufruf verantwortlich ist, nichts weiter. Weder resolution noch time ist automatisch vorhanden, beide sind Uniforms, die man selbst setzen muss, denn der Shader hat keinen eingebauten Begriff von "der Größe des Dings, in das ich zeichne" oder "wie lange die App schon läuft".

Ihn in Compose einzubinden bedeutet, ihn einmal mit RuntimeShader zu kompilieren, beide Uniforms aktuell zu halten, resolution wenn sich die Größe ändert und time in jedem einzelnen Frame, und das Ergebnis an jede API zu übergeben, die einen Brush entgegennimmt:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
    val plasmaShader = remember { RuntimeShader(PLASMA_SHADER) }
    val elapsedSeconds by produceState(0f) {
        val start = withFrameMillis { it }
        while (true) {
            withFrameMillis { value = (it - start) / 1000f }
        }
    }
 
    Box(
        modifier = Modifier
            .fillMaxSize()
            .onSizeChanged { size ->
                plasmaShader.setFloatUniform(
                    "resolution",
                    size.width.toFloat(),
                    size.height.toFloat(),
                )
            }
            .drawBehind {
                plasmaShader.setFloatUniform("time", elapsedSeconds)
                drawRect(brush = ShaderBrush(plasmaShader))
            },
    )
}

RuntimeShader kompiliert den AGSL-Quelltext sofort, sodass ein Tippfehler im Shader-String schon bei der Konstruktion und nicht erst beim Zeichnen eine Exception auslöst. ShaderBrush ist das, was die Brücke zu Compose schlägt: Es implementiert Brush, sodass alles, was mit einem Brush malt (background, Canvas.drawRect, eine Text-Farbe), statt mit einer Flächenfarbe oder einem Gradienten mit einem Shader malen kann.

FIG. 01
Animated plasma shader filling a Box: color bands shifting continuously from sin/cos of position and time, something no static Brush gradient can reproduce.

Das Fundamentale

Ein Shader ist ein datenparalleles, zustandsloses Pro-Pixel-Programm. "Datenparallel" bedeutet, dass dasselbe Programm gleichzeitig und unabhängig auf vielen Pixeln läuft, statt sie einzeln in einer Schleife abzuarbeiten. "Zustandslos" bedeutet, dass jeder Aufruf von Neuem beginnt: keine Erinnerung an andere Pixel, keine Erinnerung an den letzten Frame, sofern man sie nicht explizit als Uniform oder abgetastete Textur wieder einspeist.

Wo das in echten Apps auftaucht

Das Plasmafeld oben ist bewusst nur ein Spielzeugbeispiel. Dasselbe Pro-Pixel-Modell läuft tatsächlich hinter Effekten, die man schon in produktiven Apps gesehen hat:

  • Frosted-Glass- / Blur-behind-Dialoge: Der Shader tastet einen Snapshot von allem ab, was sich dahinter befindet, und verwischt ihn pro Pixel, so funktioniert der Dialog- und Notification-Shade-Blur von Android 12+ unter RenderEffect.
  • Color-Grading und LUT-Filter: Der RGB-Wert jedes Pixels wird über eine Lookup-Funktion neu abgebildet, dieselbe Idee, die Instagram- oder Lightroom-artige Filter verwenden, nur als AGSL-Mathematik ausgedrückt statt als feste ColorMatrix.
  • Touch-Ripple- und Verzerrungs-Feedback: Der Shader tastet seinen eigenen Inhalts-Shader an einem Offset ab, der aus dem Abstand zur Berührung und der verstrichenen Zeit berechnet wird, und erzeugt so ein wasserwellenartiges "Squish", während sich der Finger bewegt, dieselbe Effektfamilie steckt hinter benutzerdefiniertem Pull-to-Refresh und Liquid-Swipe-Interaktionen (nicht Androids eingebautes RippleDrawable, das ein einfacher kreisförmiger Alpha-Reveal ohne Shader-Beteiligung ist).
  • Prozedurale Texturen und Grain: Hintergründe, Rauschen und Dither-Muster, die zur Zeichenzeit aus reiner Mathematik erzeugt werden, wie das Plasmafeld in diesem Beitrag, statt ein Bitmap-Asset mitzuliefern, das skaliert und gekachelt werden muss.
  • Chromatische Aberration und Glitch-Effekte: Der rote, grüne und blaue Kanal werden an leicht unterschiedlichen Koordinaten-Offsets abgetastet, ein verbreiteter Stileffekt in Kamera- und Fotobearbeitungs-Apps.

Jeder dieser Effekte ist dasselbe mentale Modell aus diesem Beitrag, angewendet auf eine andere Pro-Pixel-Funktion: Nur die Mathematik innerhalb von main ändert sich.

Anderswo: gleiches Fundament, anderes Framework

  • GLSL (OpenGL/WebGL): die Shading-Sprache, von der sowohl AGSL als auch SkSL abstammen. Die void main()-Funktion eines WebGL-Fragment-Shaders, die in gl_FragColor schreibt, ist genau dasselbe Pro-Pixel-, zustandslose Modell, nur mit OpenGLs Bindungskonventionen statt denen von RuntimeShader.
  • HLSL (Direct3D, Unity): derselbe Pro-Pixel-Einstiegspunkt, andere Syntax und ein anderes Bindungsmodell. Die frag-Funktion eines Unity-Fragment-Shaders erhält interpolierte Pro-Pixel-Daten und gibt eine Farbe zurück, genau wie main in AGSL.
  • Metal Shading Language (iOS/macOS): eine mit fragment annotierte Funktion, die einmal pro Pixel/Fragment läuft und explizite Argumente für alles liest, was sie benötigt, kein impliziter Zugriff auf benachbarte Ausgaben.
  • SkSL (Skia): nicht nur eine Analogie, sondern AGSLs tatsächlicher Elternteil. Skia nutzt SkSL intern für seine eigenen Effekte, und AGSL ist die öffentliche, leicht eingeschränkte Teilmenge davon, die für App-Code freigegeben ist.

Wo man hier wirklich stolpert

  • Es stürzt zur Laufzeit unterhalb von API 33 ab, nicht zur Kompilierzeit. RuntimeShader benötigt Android 13 (Tiramisu). Es gibt keine Kompilierwarnung dafür, es auf einem älteren minSdk aufzurufen, der Absturz passiert erst, wenn dieser Codepfad zum ersten Mal ausgeführt wird, sodass die Build.VERSION.SDK_INT-Prüfung kein optionaler Boilerplate ist, sondern tragend.
  • Der Shader kompiliert, aber die Ausgabe ist schwarz oder vollständig transparent. Die häufigste Ursache ist ein unangetastetes Uniform: resolution ist standardmäßig (0, 0), bis man setFloatUniform aufruft, sodass fragCoord / resolution im allerersten Frame durch Null teilt, wenn man es nach dem ersten Zeichenvorgang statt davor setzt.
  • AGSL verwendet standardmäßig volle float-Präzision, nicht GLSL ES's mediump. Portiert man einen GLSL-ES-Fragment-Shader, der sich auf den schmaleren Wertebereich von mediump float für einen beabsichtigten Banding- oder Wraparound-Effekt verlässt, reproduziert man in AGSL nicht dasselbe Artefakt, sofern man die breitere Standardpräzision nicht explizit berücksichtigt.

Mentales Modell, das man tatsächlich nutzen sollte

Man sollte aufhören zu fragen "was sieht dieser Shader". Man sollte stattdessen fragen: "Was weiß dieses eine Pixel?" Ein Shader sieht niemals das Bild, den Bildschirm oder den vorherigen Frame, er sieht immer nur seine eigene Koordinate und die Uniforms, die man daran gedacht hat zu setzen, und genau deshalb kann er eine Million Mal pro Frame laufen, ohne sich selbst im Weg zu stehen.

Keep reading

Related reads

Neue Beiträge direkt in dein Postfach