Second Image:

So what your saying is that of the reference escapes, I need to set it back to what the reference's starting value was, right?

If not, how would I implement this by code in the fragment shader?

As far as I know nobody knows the best method to select the next reference point. Knighty's SMB which I think is still a bit faster than KF though being more of a testbed than a usable renderer puts the glitches in distinct sets (G1,.., Gn) with same iteration number where glitch was detected. Next references will then be 1 random pixel from each of the G1,..,Gn and is used only to recalculate the pixels in each set G. Secondary glitches simply generate another set G and you just put then in some queue or stack and keep going at it till no more G sets left. When dealing with glitched pixels you can use the same series expansion as a starting point.

I've experimented a lot with using non-escaping reference points (centers of minibrot or Misiurewicz points) so glitched never occur because reference does not escape but never found a reliable way to do that though it can be faster (fewer glitches).

Search for the SMB code which is easy to understand apparently, I can almost understand it.

Other methods of great ingenuity have been proposed, esp. one by Claude which allows you to not just start over after glitching but seamlessly continue with a new non-escaping reference, but it does not always work AFAIK.

It's been a while since I worked on this, if I garbled anything someone will hopefully correct me.

There are two types (at least) of glitches:
1. Reference escapes early, this type can be avoided by picking a non-escaping reference
2. Too-different dynamics (detected easily by Pauldelbrot's heuristic, detected accurately by gerrit's backwards error analysis, think knighty had another method too)

Type 1 can be improved by picking a random glitched pixel as the new reference and retrying

Type 2 can sometimes be fixed by using pixel with minimum |z| at the glitch iteration (possibly using derivative for 1 step of Newton's method to make it closer to a miniset), but often picking a random pixel works just as well - the advantage for minimum |z| comes for Mandelbrot set where you don't need to restart iterations from the beginning because minisets are periodic through 0 and the period is the glitch iteration (I use this in my mandelbrot-perturbator thing)

KF uses an algorithm I don't really understand for finding the "glitch center" based on pixel regions, but also has options for random choice and minimum |z| (without the fancy stuff from mandelbrot-perturbator).

 By code, how would I find a random gliched pixel? (Sorry I'm a beginner to Perturbation theory...)

how would I find a random gliched pixel?

There are at least two ways I can think of, the first is simpler but the second can be parallelized more easily.

1. loop over the image and count the glitched pixels.  if there are any, pick a random number in [0..count).  loop over the image again, counting glitched pixels, stopping when you reach the number you picked.  output the coordinates at hat point.

2. loop over the image.  for each glitched pixel, pick a random fractional number in [0..1). keep track of the coordinates of the point with the smallest number, and output it at the end.  make sure you detect the case of no glitched pixels at all.