The solution is to send the big chunks (images and other bitmaps) to the video card only once, and then keep them cached in VRAM. Any subsequent drawing commands that reference those bitmaps can then execute immediately, pulling the data from VRAM over a fat pipe.

A huge number of common drawing operations fit this "upload, cache, and reference" mold. For example, nearly every user interface element in Mac OS X is a bitmap: buttons, checkboxes, window widgets, window background textures, etc. The first time these UI elements are drawn, the bitmap graphics are uploaded to the video card and cached in VRAM. All subsequent UI widget drawing commands can then execute as fast as possible, pulling bitmaps from the VRAM cache as needed.

Perhaps surprisingly, text is the other common example. The first time text is drawn at a particular size with a particular font, the characters shapes (glyphs) are read from the vector-based font definition and then rasterized into bitmaps at the specified size. These rasterized glyphs (bitmaps, really) are then uploaded to the video card and cached in VRAM. All subsequent text drawing using the same font and size can then simply issue small drawing commands ("draw a capital letter 'A'") without any further need to upload bitmaps. Since most text consists of relatively long sequences of glyphs in a few fonts and sizes, this is a big win in practice. Of course, ransom notes that use a different font and size for every single character might not benefit as much...but then, that really depends on how much VRAM you have, doesn't it?