diff --git a/docs/ReleaseNotes.html b/docs/ReleaseNotes.html
index 321c86a..0b20397 100644
--- a/docs/ReleaseNotes.html
+++ b/docs/ReleaseNotes.html
@@ -87,8 +87,6 @@
 the history. Anything still here needs to be distilled and turned into proper
 prose in a section of its own. When doing that, delete the notes.</p>
 <ul>
-  <li>OpenCL support -- need details from Tanya and Peter -- separate language
-  section?</li>
   <li>Building Clang on windows -- mingw, 32 and 64 bit, native windows builds,
   cygwin. get chapuni to flesh out details.</li>
   <li>Compiling C/C++ w/ MinGW (32/64) and Cygwin on Windows -- chapuni</li>
@@ -177,6 +175,14 @@
   <li>The exact source range for expanded macros can be retrieved.</li>
 </ul>
 
+<!--
+Need Peter and/or Tanya to flesh this out if we want it in 3.0's notes.. The
+state isn't clear just from documentation or commit logs.
+
+<h4 id="opencl">Initial work to support compiling OpenCL with Clang</h4>
+Clang has some (limited) support for compiling OpenCL.
+-->
+
 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = -->
 <h3 id="cchanges">C Language Changes in Clang</h3>
 <!-- = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = -->
