After a bit of encouragement, I'll spill the unexciting secrets of "Tron Bubble Coloring". This is a method to bring out structures in the inside of the Mandelbrot set, i.e. the non-escaping points.

The first half is the true and tested idea of an orbit trap. For each iterated point, you look at its orbit and keep track of the distance to an invariant trap position (TrapX, TrapY); we also remember the iteration of closest approach. The orbit trap can be chosen quite freely, but is supposed to be constant over all pixels of one image. The following code fragment actually tracks a closest distance and a second closest distance. The reason for the latter will be explained shortly.

void mandelMinI(double& IterMin, double& Min,  // returned values
const double Cx, const double Cy, const int maxIter,
const double TrapX, const double TrapY) {
  double Re = Cx;
  double Im = Cy;
  double Re2 = Re*Re;
  double Im2 = Im*Im;
  int iter = 1;   // start with iteration 1 to avoid (0, 0)
  int mIter = iter;  // remember iteration of closest approach
  double magnitude = Re2 + Im2;

  // distance to orbit trap
  double trap = (Re - TrapX)*(Re - TrapX) + (Im - TrapY)*(Im - TrapY);
  double min = trap;  // closest distance
  double min2 = 10000.0*min;  // 2nd closest distance

  while (((magnitude) < 10000.0) && (iter <= maxIter)) {
    Im = 2.0*Re*Im + Cy;
    Re = Re2 - Im2 + Cx;
    Re2 = Re*Re;
    Im2 = Im*Im;
    magnitude = Re2 + Im2;
    ++iter;

    // squared distance to orbit trap
    trap = (Re - TrapX)*(Re - TrapX) + (Im - TrapY)*(Im - TrapY);

    // sort current distance into our "list" of closest and 2nd closest
    if (trap < min) {
      min2 = min;
      min = trap;
      mIter = iter;
    } else if (trap < min2) {
      min2 = trap;
    }
  }
... handling of obtained values further below ...
}

So after that mostly standard Mandelbrot iteration loop, we know the iteration of closest approach, the smallest (squared) distance, and the 2nd smallest distance.

If we just use the iteration number, instead of the concentric "ribbons" of level sets, we get round-ish blobs of colors. With an orbit trap position of (0, 0), these are fairly symmetrical and usually centered around minibrots.



Linkback: https://fractalforums.org/index.php?topic=3264.0

And now for the second good ole' idea, this time from procedural texturing of computer generated imagery. If we divide the distance of closest approach by the distance of 2nd closest approach, we obtain values that are 1.0 at the cell boundaries, tending towards zero further inward. (The relevant buzzword here is "Voronoi cell", or "Voronoi cell texture".)

  const double bounds = min/min2;  // cell boundaries
  Min = bounds;

With the orbit trap position still at (0, 0), and the same Christmas colors, this results in the original Tron Bubble Coloring.

Of course, highlighting of boundary and of center can be combined. As the saying goes: the possibilities are infinite.

Can you post the whole code ?

I am hesitant. Firstly, my code is shoddy. Secondly, the stuff outside the core loop is fairly standard: zooming and rotating the view, looping over pixels, anti-aliasing, spline animation paths, and so on. And thirdly, if I give you people just the raw numbers, you will turn them into colors in your own ways. I think there will be more variety if I don't present one specific way.

Very Nice!

Of late I have found the mandelbrot set quite boring,
probably because I'm usually looking at the outside,
but, as you, claude, gerrit and others present new views of the set, inside and out, it is becoming much more interesting again. 
( but zooms give me vertigo  )

Thank you very much for sharing. 

Oh! Where we are going...
Feel free about the code. If you decide to release your program let us know.

Here's a Butterfly for you.

Beautiful! I just knew I was depicting ugly worms.