Vilka metoder använder man sig av för att skapa egna typer av "antialiasing"

Inom parentes eftersom jag inte försöker göra någonting som har med kantutjämning att göra..
Bara att varje pixel ska jäföra sig med med angränsande pixlar enligt en algoritm som är likheten, men den algoritmen bryr sig inte om medelvärden och att jämna ut linjer.
En till mycket viktig skillnad är att när en bild är färdig ska arbetet med nästa bild utgå ifrån den förra istället för en obearbetad bild. Tänk om det var antialiasing skulle det bli jämnare och jämnare, sen suddigarr och suddigare ju längre du höll kameran still, dock ska jag intr göra något suddigt, men jag måste kunna bearbeta en bild i flera steg och visa varje steg på skärmen. Jag har kikat på glsl fragment shaders men det är ett virrvarr och verkar inte ha mycket att göra med min idé. Anti aliasing är välkänt men vart sitter dom metoderna? Är dom inbäddade i firware och drivrutiner eller är de bara färdiga metoder man kan komma åt och utveckla egna varianter utav själv utan specialistkunskap?
Jag håller på med en prototyp på cpu nu som inte är klar och tänkt anlita nån att porta/optimisera den när den är funktionellt färdig, men kan va bra att redan nu ha lite grundkoll på hur nästa steg går till i bakhuvudet så dom inte behöver skriva om skiten från grunden med all problemlösning det innebär. För det har jag inte råd med

Glöm min egen idé tills vidare och tänk på nån sorts anti aliasing eller blur.
Har försökt mig på glsl fragment shader i brist på andra alternativ.
Har ett par jättekonstiga problem med att visa något alls,
dels måste jag ha u_time + u_mouse och använda dem för annars blir det error.
Sätter man dem till u_time= 0; och använder filtrerar kompilatorn bort dem.
Det var dock rätt lätt att överlista med min() max().
Också blev Y-ledden upp-och ner vilket bara är naturligt och lätt att rätta till.

#ifdef GL_ES
precision mediump float;
#endif
 
uniform sampler2D texture;
uniform vec2 u_resolution;
uniform vec3 u_mouse;
uniform float u_time;
 
void main () {
float p = 1.0/256.0;
float x = gl_FragCoord.x/u_resolution.x;
float y = 1.0 - gl_FragCoord.y/u_resolution.y + min(0.0, max(0.0, u_time + u_mouse.x)) ;
 vec4 me= texture2D ( texture , vec2( x , y ) );
 vec4 n1 = texture2D ( texture , vec2( x , y+p ) );
 vec4 n2 = texture2D ( texture , vec2( x+p , y ) );
 vec4 n3 = texture2D ( texture , vec2( x+p , y+p ) );
vec4 merge = (me+n1+n2+n3)/4.0;
    gl_FragColor = merge;  
 
}

Men sen har vi ett litet problem, och ett jättestort problem.

Det lilla problemet är att jag får error,
OpenGL error 1282 at bot endDraw(): invalid operation
Den ritar en frame och sen är det kört.

Det jättestora problemet är att även om jag kunde köra programmet flera frames(gissar nu eftersom programmet låser sig) så skulle det inte bli suddigare och suddigare, utan bara göra om samma procedur på orginalbilden och få samma resutat hela tiden.

Läste om frame buffer object, och shader storage buffer object men blir inte klok på om de kan vara till någon hjälp eller inte, grafikkort verkar inte vara gjorda för att göra det jag vill göra men det måste gå ändå.

Inga svar, men här är resultatet.