sksl examples from https://github.com/jimmckeeth/SkiaSimpleShaderViewer/

    cd SkiaSimpleShaderViewer
    git archive --prefix=shaders/ v1.5:shaders/ | (cd ~/my-git/skia-python-examples && tar -xpvf - )
    cd ~/my-git/skia-python-examples
    cd shaders
    git add *.sksl
    git commit .

Excluding screenshots.

Author: HinTak

shaders/2D Clouds.sksl

@@ -0,0 +1,117 @@
+uniform float3 iResolution;      // Viewport resolution (pixels)
+uniform float  iTime;            // Shader playback time (s)
+
+// 2D Clouds
+// Created by drift in 2016-11-13
+// https://www.shadertoy.com/view/4tdSWr
+
+const float cloudscale = 1.1;
+const float speed = 0.03;
+const float clouddark = 0.5;
+const float cloudlight = 0.3;
+const float cloudcover = 0.2;
+const float cloudalpha = 8.0;
+const float skytint = 0.5;
+const vec3 skycolour1 = vec3(0.2, 0.4, 0.6);
+const vec3 skycolour2 = vec3(0.4, 0.7, 1.0);
+
+const mat2 m = mat2( 1.6,  1.2, -1.2,  1.6 );
+
+vec2 hash( vec2 p ) {
+	p = vec2(dot(p,vec2(127.1,311.7)), dot(p,vec2(269.5,183.3)));
+	return -1.0 + 2.0*fract(sin(p)*43758.5453123);
+}
+
+float noise( in vec2 p ) {
+    const float K1 = 0.366025404; // (sqrt(3)-1)/2;
+    const float K2 = 0.211324865; // (3-sqrt(3))/6;
+	vec2 i = floor(p + (p.x+p.y)*K1);	
+    vec2 a = p - i + (i.x+i.y)*K2;
+    vec2 o = (a.x>a.y) ? vec2(1.0,0.0) : vec2(0.0,1.0); //vec2 of = 0.5 + 0.5*vec2(sign(a.x-a.y), sign(a.y-a.x));
+    vec2 b = a - o + K2;
+	vec2 c = a - 1.0 + 2.0*K2;
+    vec3 h = max(0.5-vec3(dot(a,a), dot(b,b), dot(c,c) ), 0.0 );
+	vec3 n = h*h*h*h*vec3( dot(a,hash(i+0.0)), dot(b,hash(i+o)), dot(c,hash(i+1.0)));
+    return dot(n, vec3(70.0));	
+}
+
+float fbm(vec2 n) {
+	float total = 0.0, amplitude = 0.1;
+	for (int i = 0; i < 7; i++) {
+		total += noise(n) * amplitude;
+		n = m * n;
+		amplitude *= 0.4;
+	}
+	return total;
+}
+
+// -----------------------------------------------
+
+vec4 main( in vec2 fragCoord ) {
+    vec2 p = fragCoord.xy / iResolution.xy;
+	vec2 uv = p*vec2(iResolution.x/iResolution.y,1.0);    
+    float time = iTime * speed;
+    float q = fbm(uv * cloudscale * 0.5);
+    
+    //ridged noise shape
+	float r = 0.0;
+	uv *= cloudscale;
+    uv -= q - time;
+    float weight = 0.8;
+    for (int i=0; i<8; i++){
+		r += abs(weight*noise( uv ));
+        uv = m*uv + time;
+		weight *= 0.7;
+    }
+    
+    //noise shape
+	float f = 0.0;
+    uv = p*vec2(iResolution.x/iResolution.y,1.0);
+	uv *= cloudscale;
+    uv -= q - time;
+    weight = 0.7;
+    for (int i=0; i<8; i++){
+		f += weight*noise( uv );
+        uv = m*uv + time;
+		weight *= 0.6;
+    }
+    
+    f *= r + f;
+    
+    //noise colour
+    float c = 0.0;
+    time = iTime * speed * 2.0;
+    uv = p*vec2(iResolution.x/iResolution.y,1.0);
+	uv *= cloudscale*2.0;
+    uv -= q - time;
+    weight = 0.4;
+    for (int i=0; i<7; i++){
+		c += weight*noise( uv );
+        uv = m*uv + time;
+		weight *= 0.6;
+    }
+    
+    //noise ridge colour
+    float c1 = 0.0;
+    time = iTime * speed * 3.0;
+    uv = p*vec2(iResolution.x/iResolution.y,1.0);
+	uv *= cloudscale*3.0;
+    uv -= q - time;
+    weight = 0.4;
+    for (int i=0; i<7; i++){
+		c1 += abs(weight*noise( uv ));
+        uv = m*uv + time;
+		weight *= 0.6;
+    }
+	
+    c += c1;
+    
+    vec3 skycolour = mix(skycolour2, skycolour1, p.y);
+    vec3 cloudcolour = vec3(1.1, 1.1, 0.9) * clamp((clouddark + cloudlight*c), 0.0, 1.0);
+   
+    f = cloudcover + cloudalpha*f*r;
+    
+    vec3 result = mix(skycolour, clamp(skytint * skycolour + cloudcolour, 0.0, 1.0), clamp(f + c, 0.0, 1.0));
+    
+	return( vec4( result, 1.0 ));
+}

shaders/Analytic Motionblur 2D.sksl

@@ -0,0 +1,74 @@
+uniform float2 iResolution;
+uniform float iTime;
+
+// The MIT License
+// Copyright ? 2014 Inigo Quilez
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// Original: https://www.shadertoy.com/view/MdSGDm
+
+// Analytic motion blur, for 2D spheres (disks).
+//
+// (Linearly) Moving Disk - pixel/ray overlap test. The resulting
+// equation is a quadratic that can be solved to compute time coverage
+// of the swept disk behind the pixel over the aperture of the camera
+// (a full frame at 24 hz in this test).
+
+
+
+// draw a disk with motion blur
+vec3 diskWithMotionBlur( in vec3 pcol,    // pixel color (background)
+                         in vec2 puv,     // pixel coordinates
+                         in vec3 dpr,     // disk (pos,rad)
+                         in vec2 dv,      // disk velocity
+                         in vec3 dcol )   // disk color
+{
+	vec2 xc = puv - dpr.xy;
+	float a = dot(dv,dv);
+	float b = dot(dv,xc);
+	float c = dot(xc,xc) - dpr.z*dpr.z;
+	float h = b*b - a*c;
+	if( h>0.0 )
+	{
+		h = sqrt( h );
+		
+		float ta = max( 0.0, (-b-h)/a );
+		float tb = min( 1.0, (-b+h)/a );
+		
+		if( ta < tb ) // we can comment this conditional, in fact
+		    pcol = mix( pcol, dcol, clamp(2.0*(tb-ta),0.0,1.0) );
+	}
+
+	return pcol;
+}
+
+
+vec3 hash3( float n ) { return fract(sin(vec3(n,n+1.0,n+2.0))*43758.5453123); }
+vec4 hash4( float n ) { return fract(sin(vec4(n,n+1.0,n+2.0,n+3.0))*43758.5453123); }
+
+const float speed = 8.0;
+vec2 getPosition( float time, vec4 id ) { return vec2(       0.9*sin((speed*(0.75+0.5*id.z))*time+20.0*id.x),        0.75*cos(speed*(0.75+0.5*id.w)*time+20.0*id.y) ); }
+vec2 getVelocity( float time, vec4 id ) { return vec2( speed*0.9*cos((speed*(0.75+0.5*id.z))*time+20.0*id.x), -speed*0.75*sin(speed*(0.75+0.5*id.w)*time+20.0*id.y) ); }
+
+vec4 main( vec2 fragCoord )
+{
+	vec2 p = (2.0*fragCoord-iResolution.xy) / iResolution.y;
+	
+	vec3 col = vec3(0.03) + 0.015*p.y;
+	
+	for( int i=0; i<16; i++ )
+	{		
+		vec4 off = hash4( float(i)*13.13 );
+        vec3 sph = vec3( getPosition( iTime, off ), 0.02+0.1*off.x );
+        vec2 dv = getVelocity( iTime, off ) /24.0 ;
+		vec3 sphcol = 0.55 + 0.45*sin( 3.0*off.z + vec3(4.0,0.0,2.0) );
+		
+        col = diskWithMotionBlur( col, p, sph, dv, sphcol );
+	}		
+
+    col = pow( col, vec3(0.4545) );
+    
+    col += (1.0/255.0)*hash3(p.x+13.0*p.y);
+
+	return(vec4(col,1.0));
+}

shaders/Atmospheric Scattering Sample.sksl

@@ -0,0 +1,172 @@
+uniform float2 iResolution;
+uniform float iTime;
+
+// Written by GLtracy
+// Original: https://www.shadertoy.com/view/lslXDr
+
+// math const
+const float PI = 3.14159265359;
+const float MAX = 10000.0;
+
+// ray intersects sphere
+// e = -b +/- sqrt( b^2 - c )
+vec2 ray_vs_sphere( vec3 p, vec3 dir, float r ) {
+	float b = dot( p, dir );
+	float c = dot( p, p ) - r * r;
+	
+	float d = b * b - c;
+	if ( d < 0.0 ) {
+		return vec2( MAX, -MAX );
+	}
+	d = sqrt( d );
+	
+	return vec2( -b - d, -b + d );
+}
+
+// Mie
+// g : ( -0.75, -0.999 )
+//      3 * ( 1 - g^2 )               1 + c^2
+// F = ----------------- * -------------------------------
+//      8pi * ( 2 + g^2 )     ( 1 + g^2 - 2 * g * c )^(3/2)
+float phase_mie( float g, float c, float cc ) {
+	float gg = g * g;
+	
+	float a = ( 1.0 - gg ) * ( 1.0 + cc );
+
+	float b = 1.0 + gg - 2.0 * g * c;
+	b *= sqrt( b );
+	b *= 2.0 + gg;	
+	
+	return ( 3.0 / 8.0 / PI ) * a / b;
+}
+
+// Rayleigh
+// g : 0
+// F = 3/16PI * ( 1 + c^2 )
+float phase_ray( float cc ) {
+	return ( 3.0 / 16.0 / PI ) * ( 1.0 + cc );
+}
+
+// scatter const
+const float R_INNER = 1.0;
+const float R = R_INNER + 0.5;
+
+const int NUM_OUT_SCATTER = 8;
+const int NUM_IN_SCATTER = 80;
+
+float density( vec3 p, float ph ) {
+	return exp( -max( length( p ) - R_INNER, 0.0 ) / ph );
+}
+
+float optic( vec3 p, vec3 q, float ph ) {
+	vec3 s = ( q - p ) / float( NUM_OUT_SCATTER );
+	vec3 v = p + s * 0.5;
+	
+	float sum = 0.0;
+	for ( int i = 0; i < NUM_OUT_SCATTER; i++ ) {
+		sum += density( v, ph );
+		v += s;
+	}
+	sum *= length( s );
+	
+	return sum;
+}
+
+vec3 in_scatter( vec3 o, vec3 dir, vec2 e, vec3 l ) {
+	const float ph_ray = 0.05;
+    const float ph_mie = 0.02;
+    
+    const vec3 k_ray = vec3( 3.8, 13.5, 33.1 );
+    const vec3 k_mie = vec3( 21.0 );
+    const float k_mie_ex = 1.1;
+    
+	vec3 sum_ray = vec3( 0.0 );
+    vec3 sum_mie = vec3( 0.0 );
+    
+    float n_ray0 = 0.0;
+    float n_mie0 = 0.0;
+    
+	float len = ( e.y - e.x ) / float( NUM_IN_SCATTER );
+    vec3 s = dir * len;
+	vec3 v = o + dir * ( e.x + len * 0.5 );
+    
+    for ( int i = 0; i < NUM_IN_SCATTER; i++ ) {
+        v += s;
+		float d_ray = density( v, ph_ray ) * len;
+        float d_mie = density( v, ph_mie ) * len;
+        
+        n_ray0 += d_ray;
+        n_mie0 += d_mie;
+        
+        vec2 f = ray_vs_sphere( v, l, R );
+		vec3 u = v + l * f.y;
+        
+        float n_ray1 = optic( v, u, ph_ray );
+        float n_mie1 = optic( v, u, ph_mie );
+		
+        vec3 att = exp( - ( n_ray0 + n_ray1 ) * k_ray - ( n_mie0 + n_mie1 ) * k_mie * k_mie_ex );
+        
+		sum_ray += d_ray * att;
+        sum_mie += d_mie * att;
+	}
+	
+	float c  = dot( dir, -l );
+	float cc = c * c;
+    vec3 scatter =
+        sum_ray * k_ray * phase_ray( cc ) +
+     	sum_mie * k_mie * phase_mie( -0.78, c, cc );
+    
+	
+	return 10.0 * scatter;
+}
+
+// angle : pitch, yaw
+mat3 rot3xy( vec2 angle ) {
+	vec2 c = cos( angle );
+	vec2 s = sin( angle );
+	
+	return mat3(
+		c.y      ,  0.0, -s.y,
+		s.y * s.x,  c.x,  c.y * s.x,
+		s.y * c.x, -s.x,  c.y * c.x
+	);
+}
+
+// ray direction
+vec3 ray_dir( float fov, vec2 size, vec2 pos ) {
+	vec2 xy = pos - size * 0.5;
+
+	float cot_half_fov = tan( radians( 90.0 - fov * 0.5 ) );	
+	float z = size.y * 0.5 * cot_half_fov;
+	
+	return normalize( vec3( xy, -z ) );
+}
+
+vec4 main( in vec2 fragCoord )
+{
+	// default ray dir
+	vec3 dir = ray_dir( 45.0, iResolution.xy, fragCoord.xy );
+	
+	// default ray origin
+	vec3 eye = vec3( 0.0, 0.0, 3.0 );
+
+	// rotate camera
+	mat3 rot = rot3xy( vec2( 0.0, iTime * 0.5 ) );
+	dir = rot * dir;
+	eye = rot * eye;
+	
+	// sun light dir
+	vec3 l = vec3( 0.0, 0.0, 1.0 );
+			  
+	vec2 e = ray_vs_sphere( eye, dir, R );
+	if ( e.x > e.y ) {
+		return( vec4( 0.0, 0.0, 0.0, 1.0 ));
+	}
+	
+	vec2 f = ray_vs_sphere( eye, dir, R_INNER );
+	e.y = min( e.y, f.x );
+
+	vec3 I = in_scatter( eye, dir, e, l );
+	
+	return(vec4( pow( I, vec3( 1.0 / 2.2 ) ), 1.0 ));
+}