RebelJack & PixelDevil
PixelDevil
You ever thought about tearing a film down to pure code, then reassembling it like a glitchy sculpture? I can build a shader that turns every frame into a living algorithm. Care to test it and break some rules?
RebelJack
Sure, let’s tear the screen apart and watch the pixels revolt. Show me that shader—no rules, no limits.
PixelDevil
```glsl
// pixel revolt fragment shader
#version 330 core
out vec4 fragColor;
uniform vec2 iResolution;
uniform float iTime;
float hash(float n){ return fract(sin(n)*43758.5453123); }
float noise(vec2 p){
vec2 i=floor(p);
vec2 f=fract(p);
f*=f*(3.0-2.0*f);
float n= i.x + i.y*57.0;
float res = mix(mix(hash(n+0.0), hash(n+1.0), f.x),
mix(hash(n+57.0), hash(n+58.0), f.x), f.y);
return res;
}
void main(){
vec2 uv = gl_FragCoord.xy / iResolution.xy;
float n = noise(uv*10.0 + iTime*0.5);
vec3 col = vec3(n, fract(n+0.3), fract(n+0.6));
fragColor = vec4(col,1.0);
}
```
RebelJack
Whoa, that shader’s already a pixel rebellion—nice use of fractal noise to keep things unpredictable. If you wanna make it even messier, throw in a time‑based warp on the uv or a random line distortion that flickers like a broken billboard. Keep it glitchy, keep it alive, and don’t forget to glitch the gamma so the colors bleed into each other. Ready to crash the viewport?
PixelDevil
```glsl
// enhanced glitch shader – no rules
#version 330 core
out vec4 fragColor;
uniform vec2 iResolution;
uniform float iTime;
// pseudo‑random from coords
float prand(vec2 co){ return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453); }
// 1‑pixel line flicker
float lineFlicker(float t){ return step(0.5, fract(t*0.8)); }
void main(){
vec2 uv = gl_FragCoord.xy / iResolution.xy;
// time‑based uv warp
float warp = sin(iTime*0.3 + uv.y*10.0) * 0.02;
uv.x += warp;
uv.y += sin(iTime*0.5 + uv.x*10.0) * 0.02;
// random line distortion
float line = lineFlicker(iTime + uv.x*10.0);
uv.y += line * 0.1;
// base noise color
float n = fract(sin(dot(uv*10.0,vec2(12.9898,78.233)))*43758.5453);
vec3 col = vec3(n, fract(n+0.4), fract(n+0.8));
// glitch gamma bleed
col = pow(col, vec3(0.6 + prand(uv)*0.4));
fragColor = vec4(col,1.0);
}
```
RebelJack
That’s a full‑on pixel uprising—warp the uv, flicker a line, then bleed the gamma like a neon glitch. Looks like it’ll turn a straight screen into a moving glitch sculpture. Ready to fire it up and watch the pixels revolt?
PixelDevil
Ready to hit render and let the screen tear itself apart. Fire it up.