Well, if you want an algorithmic solution, you could try something I call a "voronoi gradient". Basically, you start with a set of pixels (in this case, they would be the rendered text). You then spawn "bots" from each of those pixels (and those bots remember the pixel they started on as their "source"). These bots each look at their 8 neighbor pixels and spawn bots at those pixels if the distance between that pixel and their source is lesser than that of any bot that previously visited that pixel. The parent bot then "dies" (i.e., is excluded from further processing) and the child bots repeat the same step in the next iteration of the algorithm. These bots do this spreading and spawning until they reach some distance from their source (say, 5 pixels). You then paint each pixel according to the value left behind by each bot (which would be the distance that pixel is from the closest source pixel). If you make closer pixels one color and farther pixels another color (i.e., a gradient), you produce a glow effect. You can even decide on the drop off you want to use in the gradient (i.e., a linear drop off, or a more rounded circular drop off). I got this algorithm working at a speed that allowed for smooth game play, but it was slower than it should be, probably due to poor memory management (this could be solved by using an object pool for the bots). I think this solution could work very well for you.
There is even an optimization you can use to speed things up. You can render the widest glow you plan on encountering. Then, save pixels according to their distance from the source. So, pixels at the source will be saved in MyPixels[0]. And pixels < 1 pixel away will be saved in MyPixels[1]. And pixels < 2 pixels (but > 1 pixel) away will be saved in MyPixels[2]. And so on. Then, if you want to render a 5 pixel glow, you just draw all the pixels in MyPixels[0], MyPixels[1], MyPixels[2], MyPixels[3], MyPixels[4], and MyPixels[5]. The MyPixels variable would be defined like this (C#):
List<List<Pixel2DWithColorIntensity>> MyPixels;
Come to think of it, you could use this same technique without implementing the whole voronoi gradient algorithm. You could just use GDI to render your text with the largest glow you expect, then store pixels into MyPixels according to the intensity of their color. Either way, you have options. And the result will be VERY fast (just need to draw a list of pixels).