<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html lang="en">
<head>
  <meta http-equiv="content-type" content="text/html; charset=utf-8">
  <title>Mesa Release Notes</title>
  <link rel="stylesheet" type="text/css" href="mesa.css">
</head>
<body>

<h1>Mesa 8.0 Release Notes / February 9, 2012</h1>

<p>
Mesa 8.0 is a new development release.
People who are concerned with stability and reliability should stick
with a previous release or wait for Mesa 8.0.1.
</p>
<p>
Mesa 8.0 implements the OpenGL 3.0 API, but the version reported by
glGetString(GL_VERSION) depends on the particular driver being used.
Some drivers don't support all the features required in OpenGL 3.0.
</p>
<p>
See the <a href="install.html">Compiling/Installing page</a> for prerequisites
for DRI hardware acceleration.
</p>


<h2>MD5 checksums</h2>
<pre>
3516fea6c28ce4a0fa9759e4894729a1  MesaLib-8.0.tar.gz
1a5668fe72651a670611164cefc703b2  MesaLib-8.0.tar.bz2
66f5a01a85530a91472a3acceb556db8  MesaLib-8.0.zip
</pre>


<h2>New features</h2>
<ul>
<li>GL_ARB_ES2_compatibility (r300g, r600g)
<li>GL_ARB_depth_buffer_float (r600g)
<li>GL_ARB_vertex_type_2_10_10_10_rev (r600g)
<li>GL_ARB_texture_storage (gallium drivers and swrast)
<li>GL_EXT_packed_float (i965)
<li>GL_EXT_texture_array (r600g, i965)
<li>GL_EXT_texture_shared_exponent (i965)
<li>GL_NV_fog_distance (all gallium drivers, nouveau classic)
<li>GL_NV_primitive_restart (r600g)
<li>GL_OES_EGL_image_external (gallium drivers)
<li>GL_OES_compressed_ETC1_RGB8_texture (softpipe, llvmpipe)
<li>ARB_texture_rgb10_a2ui (softpipe, r600g)
<li>Many updates to the VMware svga Gallium driver
</ul>


<h2>Bug fixes</h2>


<h2>Changes</h2>
<ul>
<li>Removed all DRI drivers that did not support DRI2.  Specifically,
  i810, mach64, mga, r128, savage, sis, tdfx, and unichrome were
  removed.</li>
<li>Removed support for BeOS.</li>
<li>Removed the obsolete (and unmaintained) Windows "gldirect" and
  "ICD" drivers.</li>
<li>Removed the linux-fbdev software driver.</li>
<li>Removed all remnants of paletted texture support.  As required by
  desktop OpenGL, <tt>GL_COLOR_INDEX</tt> data can still be uploaded
  to a color (e.g., RGBA) texture.  However, the data cannot be stored
  internally as color-index.</li>
<li>Removed support for GL_APPLE_client_storage extension.</li>
<li>Removed the classic Mesa r300 and r600 drivers, which are superseded
  by the gallium drivers for this hardware.</li>
<li>Removed the dead Gallium i965, cell and failover drivers, which were
  either broken and with nobody in sight to fix the situation or
  deprecated.</li>
</ul>


</body>
</html>
