Jim,

> Depends what you are doing: if you are doing serious 3D: do OpenGL.

Certainly true but...

> The issue comes up in 2 D graphics though that it tends be painted
> once, and the people stare at the results for a while.

... with a reasonable support on the platform this is not an issue
anymore because you can update only the portions needed. However, what's
even better is if you got support for both, render to texture and AGP
client-side textures (Apple has both). In this case you can cache your
"interesting" objects (aka everything that tends to change often) in a
client side texture - being virtually unlimited by VRAM constraints,
render as fast as you can do do "repaints" and still be able to do all
sorts of "weird pixel manipulations" (since the texture is client-side
you _can_ access the pixels, heh, heh - it's a little more expensive
than usual but _way_ faster than copying the pixels from/to the graphics
card). Unfortunately, the necessary extensions haven't made their way
into the standard yet.

[Which reminds me: What OpenGL version is supported "by default" these
days on Linux?! Still at 1.2?]

> As I understand it, OpenGL will tend to have "interesting" artifacts
> at the boundaries between triangles: these tend not to be noticed
> in 3D applications due to the rapid repaint, but are often highly
> objectionable in 2D apps.

Where have you heard this?! I have been using techniques like this for
many years and "boundaries between triangles" never were a problem (at
least for planar configurations and compliant implementations). The only
place where I have in fact noticed artifacts was due to clipping effects
(round-off problems in particular if not done by the hardware - much of
this has been solved when T&L hardware came along). This used to be a
problem for partial redraws "back in the old days" when graphics cards
didn't support stencil buffers. But these days you just use stencil
buffers and they will clip on a per-fragment base and won't have any of
those artifacts.

> BTW, Keith Packard and Carl Worth are working on a client library for
> rendering that will either push pixels or use Render when it is done,
> you might think of using it it (along with the really georgeous spline
> stuff they are doing) with different back ends.  This is to allow apps
> to convert to a new API and not care if the server has render or not.
> I suspect this is 6 months from completion.

Interesting. Will there be versions for Windows, Mac etc. as well?!

Cheers,
  - Andreas