diff --git a/docs/MESA_ycbcr_texture.spec b/docs/MESA_ycbcr_texture.spec
index a0ef310..1fbb1e1 100644
--- a/docs/MESA_ycbcr_texture.spec
+++ b/docs/MESA_ycbcr_texture.spec
@@ -33,9 +33,9 @@
 
     This extension supports texture images in the YCbCr format.  There is
     no support for converting YCbCr images to RGB or vice versa.  The
-    intention is for YCbCr image data to be directly sent to the renderer
-    without any pixel transfer operations.  Only 2D texture images are
-    supported (not glDrawPixels, glReadPixels, etc).
+    texture's YCbCr colors are converted to RGB during texture sampling.
+    Only 2D texture images are supported (not glDrawPixels, glReadPixels,
+    etc).
 
     A YCbCr pixel (texel) is a 16-bit unsigned short with two components.
     The first component is luminance (Y).  For pixels in even-numbered
@@ -61,12 +61,12 @@
     Accepted by the <internalFormat> and <format> parameters of
     TexImage2D and TexSubImage2D:
 
-        GL_YCBCR_MESA                   0x8757
+        YCBCR_MESA                   0x8757
 
     Accepted by the <type> parameter of TexImage2D and TexSubImage2D:
 
-        GL_UNSIGNED_SHORT_8_8_MESA      0x85BA /* same as Apple's */
-        GL_UNSIGNED_SHORT_8_8_REV_MESA  0x85BB /* same as Apple's */
+        UNSIGNED_SHORT_8_8_MESA      0x85BA /* same as Apple's */
+        UNSIGNED_SHORT_8_8_REV_MESA  0x85BB /* same as Apple's */
 
 Additions to Chapter 2 of the OpenGL 1.4 Specification (OpenGL Operation)
 
@@ -181,7 +181,7 @@
     <internalFormat> is MESA_YCBCR and <border> is not zero.
 
     INVALID_OPERATION is generated by TexSubImage2D if the internal image
-    format is YCBCR_MESA and format is not YCBCR_MESA.
+    format is YCBCR_MESA and <format> is not YCBCR_MESA.
 
     INVALID_OPERATION is generated by CopyTexSubImage2D if the internal
     image is YCBCR_MESA.
@@ -195,3 +195,4 @@
 Revision History
 
     20 September 2002 - Initial draft
+    29 April 2003 - minor updates
diff --git a/docs/VERSIONS b/docs/VERSIONS
index 97a44c7..146f74f 100644
--- a/docs/VERSIONS
+++ b/docs/VERSIONS
@@ -1,4 +1,4 @@
-$Id: VERSIONS,v 1.124 2003/03/30 16:20:23 brianp Exp $
+$Id: VERSIONS,v 1.125 2003/05/02 15:05:02 brianp Exp $
 
 
 Mesa Version History
@@ -1125,9 +1125,12 @@
 	- GL_SGI_texture_color_table extension (Eric Plante)
 	- GL_NV_fragment_program extension
 	- new X86 feature detection code (Petr Sebor)
+	- less memory used for display lists and vertex buffers
+	- demo of per-pixel lighting with a fragment program (demos/fplight.c)
     Bug fixes:
 	- really enable OpenGL 1.4 features in DOS driver.
 	- fixed issues in glDrawPixels and glCopyPixels for very wide images
     Changes:
 	- dropped API trace feature (src/Trace/)
-
+	- documentation overhaul.  merged with website content.  more html.
+	- glxgears.c demo updated to use GLX swap rate extensions
diff --git a/docs/osmesa.html b/docs/osmesa.html
index ace4200..5dc2e81 100644
--- a/docs/osmesa.html
+++ b/docs/osmesa.html
@@ -37,25 +37,29 @@
    accuracy (film and IBR, for example).  If you're in this situation
    you'll be happy to know that Mesa supports 16-bit and 32-bit color
    channels through the OSMesa interface.  When using 16-bit channels,
-   channels are GLushorts and pixels occupy 8 bytes.  When using 32-bit
-   channels, channels are GLfloats and pixels occupy 16 bytes.
+   channels are GLushorts and RGBA pixels occupy 8 bytes.  When using 32-bit
+   channels, channels are GLfloats and RGBA pixels occupy 16 bytes.
 </p>
 <p>
    To build Mesa/OSMesa with 16-bit color channels:
 <pre>
-      cd Mesa-4.x/src
+      cd Mesa-5.x/src
       make -f Makefile.X11 clean
       make -f Makefile.OSMesa16 linux-osmesa16
 </pre>
 
    For 32-bit channels:
 <pre>
-      cd Mesa-4.x/src
+      cd Mesa-5.x/src
       make -f Makefile.X11 clean
       make -f Makefile.OSMesa16 linux-osmesa32
 </pre>
 
 <p>
+You'll wind up with a library named libOSMesa16.so or libOSMesa32.so.
+</p>
+
+<p>
 If you're not using Linux, you can easily edit Make-config and add
 an appropriate configuration.
 </p>
