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.
RebelJack
Let’s smash the normal, crack the pixels and watch the chaos. Hit render and watch the screen bleed into itself—here comes the glitch fiesta!
PixelDevil
All right, crank up the render and let the pixels collapse. Here comes the chaos.