diff --git a/doc/LinuxTools2.2ReleaseReview.html b/doc/LinuxTools2.2ReleaseReview.html
new file mode 100644
index 0000000..03e0294
--- /dev/null
+++ b/doc/LinuxTools2.2ReleaseReview.html
@@ -0,0 +1 @@
+<?xml version='1.0' encoding='utf-8' ?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"/></head><body><h1 id="Linux_Tools_2.2_Release_Review">Linux Tools 2.2 Release Review</h1><p>Planned Review Date: 2013-12-10</p><p>Communication Channel:  linuxtools-dev@eclipse.org (<a href="https://dev.eclipse.org/mailman/listinfo/linuxtools-dev">https://dev.eclipse.org/mailman/listinfo/linuxtools-dev</a>)</p><p>Author:  Jeff Johnston &lt;jjohnstn@redhat.com&gt;</p><h2 id="Introduction">Introduction</h2><ul><li>The Linux Tools project is a two-faceted project</li></ul><ol><li>Firstly, it provides tools and frameworks for writing tools relevant to Linux developers.</li><li>Secondly, it provides a place for Linux distributions to collaboratively overcome issues surrounding distribution packaging of Eclipse technology. The project produces both best practices and tools related to packaging.</li></ol><ul><li>Project plan:  <a href="http://www.eclipse.org/projects/project-plan.php?projectid=tools.linuxtools">http://www.eclipse.org/projects/project-plan.php?projectid=tools.linuxtools</a></li></ul><h2 id="Features">Features</h2><ul><li>a framework for integrating native profiling tools with the CDT</li><li>visualization, fetching, and control of LTTng traces</li><li>GCov code coverage tool integration</li><li>GProf integration including function-based profiling and integration with the CDT</li><li>an RPM .spec editor with rpmlint integration</li><li>plugins integrating the OProfile profiler with the CDT</li><li>plugins bridging the CDT's hover help functionality with the various open source API documentation formats and tools; called libhover</li><li>Valgrind integration for memcheck, massif, cachegrind and helgrind</li><li>ChangeLog management tools</li></ul><h2 id="New_in_2.2">New in 2.2</h2><ul><li>OPerf is the default for OProfile profiling</li><li>Enhanced SystemTap graphing<ul><li>multiple graph sets with separate regexes allowed</li></ul></li><li>Compare Editor support for perf stat data<ul><li>users can use "Compare with" on selected perf stat output files</li></ul></li><li>More New and Noteworthy for 2.2:<ul><li><a href="http://www.eclipse.org/linuxtools/new/2.2">http://www.eclipse.org/linuxtools/new/2.2</a></li><li>(will be moved to <a href="http://www.eclipse.org/linuxtools/new">http://www.eclipse.org/linuxtools/new</a> after 2.2 is released)</li></ul></li></ul><h3 id="Maturity_and_Communities">Maturity and Communities</h3><ul><li>A number of years of development and adoption by a variety of companies and many users</li><li>Tools included in Linux distributions</li><li>Open source and commercial extension of plugins and APIs</li><li>Multiple organizations (6 at the time of writing), committers, and contributors involved in community:<ul><li><a href="http://www.eclipse.org/projects/project.php?id=tools.linuxtools">http://www.eclipse.org/projects/project.php?id=tools.linuxtools</a></li></ul></li></ul><h3 id="Openness">Openness</h3><ul><li>Project uses open communication media:<ul><li>mailing list, IRC, Bugzilla</li></ul></li><li>Discussions happen in public and all are invited to any project phone calls</li><li>Project schedule, policies, and procedures are clearly documented and followed</li></ul><h3 id=".22Eclipse_way.22">"Eclipse way"</h3><ul><li>All development occurs in Eclipse git repositories</li><li>Eclipse IP policy strictly adhered to</li><li>A copy of our 2.2 IP log, once approved by the Eclipse Legal team, will be archived here:<ul><li><a href="http://www.eclipse.org/linuxtools/doc/2.2-approvedIPLog.html">http://www.eclipse.org/linuxtools/doc/2.2-approvedIPLog.html</a></li></ul></li><li>Eclipse development process followed including releases, documentation, ramp-down, etc.</li><li>Interaction and integration with other Eclipse projects</li></ul><h2 id="APIs">APIs</h2><ul><li>Our APIs have been reviewed and we consider those that are exposed to be suitable for adopters to use.  They will remain stable for the duration of our 2.x lifecycle. </li><li>As always, the project appreciates feedback via Bugzilla or our mailing list.  This is especially true of adopters and their API needs.</li></ul><h2 id="Architectural_Issues">Architectural Issues</h2><ul><li>Ongoing work to integrate with tracing and profiling toolkits will enable us to have more extensible frameworks with exemplary implementations.</li><li>Despite being user-focused, we have a few components which provide extension points:<ul><li>our profiling tool framework whose use is demonstrated by all of our profiling integration plug-ins: Gcov, Gprof, Perf, OProfile and Valgrind</li><li>our ChangeLog plugin which allows for extensible parsers, formatters, and editors. The extensibility of formatters is demonstrated by our RPM .spec editor</li><li>our libhover component. This plugin provides an extension point that defines a common documentation format for C library hover help</li><li>our LTTng component. This plugin provides an extension point to integrate any type of trace and an extension point for producing UML2 sequence diagrams from traces</li></ul></li></ul><h2 id="Tool_Usability">Tool Usability</h2><ul><li>Our releases thus far have been well-received and at present have satisfied users.  This 2.2 release will hopefully continue to grow our base of satisfied users.</li><li>Our work integrating native profiling tools like LTTng, perf, OProfile, and Valgrind has been introduced to excited audiences. We aim to improve the power of these tools within the IDE making them easier to use and to support additional functionality that is provided via the command line.  Developers making use of our tools will be able to focus on their own projects and not on setting up the underlying tools.</li></ul><h2 id="End-of-Life">End-of-Life</h2><ul><li>We have no end-of-life issues to discuss at this time.  Note that some of our plugins will shortly migrated to our incubator (see below).</li></ul><h2 id="Bugzilla">Bugzilla</h2><ul><li>For our 2.2 release we will have 0 outstanding release-blocker bugs.</li><li>We closed or resolved over 25 bugs during our 2.2 release cycle:</li></ul><p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced;classification=Tools;product=Linux%20Tools;target_milestone=2.2;bug_status=RESOLVED;bug_status=VERIFIED;bug_status=CLOSED;bugidtype=include;list_id=2295921">https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced;classification=Tools;product=Linux%20Tools;target_milestone=2.2;bug_status=RESOLVED;bug_status=VERIFIED;bug_status=CLOSED;bugidtype=include;list_id=2295921</a></p><h2 id="Standards">Standards</h2><ul><li>Our project conforms to the following standards, some of which are ad-hoc and some which are more well-defined:<ul><li>Fedora RPM packaging guidelines<ul><li><a href="http://fedoraproject.org/wiki/Packaging/Guidelines">http://fedoraproject.org/wiki/Packaging/Guidelines</a></li></ul></li><li>Informal conventions around use of the GNU Autotools</li><li>GNU ChangeLog formatting<ul><li><a href="http://www.gnu.org/prep/standards/html_node/Style-of-Change-Logs.html#Style-of-Change-Logs">http://www.gnu.org/prep/standards/html_node/Style-of-Change-Logs.html#Style-of-Change-Logs</a></li></ul></li></ul></li><li>LTTng trace format<ul><li><a href="http://lttng.org">http://lttng.org</a></li></ul></li></ul><h2 id="UI_Usability">UI Usability</h2><ul><li>Our project aims to conform to the Eclipse user interface guidelines.</li><li>All of our user interface components support keyboard navigation.</li><li>We support interactivity of our Valgrind BIRT-generated charts and intend on further increasing our accessibility.</li><li>All of our strings are externalized but we currently have no language packs</li><li>Our strings are registered in Babel for use by translators</li></ul><h2 id="Schedule">Schedule</h2><ul><li>Our project aims to release minor releases (2.2, etc.) ahead of Eclipse maintenance releases</li></ul><h2 id="Communities">Communities</h2><ul><li>Our project has a strong relationship with the various Linux distributions (Fedora, Mandriva, Debian, Ubuntu, etc.) with many using our eclipse-build project's output for their Eclipse SDK packages</li><li>The majority of our project's interactions occur on IRC (#eclipse-linux) and our mailing list (linuxtools-dev@eclipse.org)</li><li>We have a centralized update site and use eclipse.org bugzilla for all of our planning and bug tracking</li><li>We make use of our newsgroup for user feedback</li><li>Our project members often speak at conferences such as EclipseCon, the Red Hat Summit, etc.</li><li>Our team members maintain the following blogs:<ul><li><a href="http://akurtakov.blogspot.com/">http://akurtakov.blogspot.com/</a> (part of Planet Eclipse)</li></ul></li><li>We interact often with the CDT project and make use of the GEF and CDT projects</li><li>We are growing our community of adopters</li></ul><h2 id="IP_Log">IP Log</h2><ul><li>Our IP log including information about all CQs, external contributions, and committers can be found here<ul><li><a href="http://www.eclipse.org/projects/ip_log.php?projectid=tools.linuxtools">http://www.eclipse.org/projects/ip_log.php?projectid=tools.linuxtools</a></li></ul></li><li>A copy of our 2.2 IP log, once approved by the Eclipse Legal team, is archived here:<ul><li><a href="http://www.eclipse.org/linuxtools/doc/2.2-approvedIPLog.html">http://www.eclipse.org/linuxtools/doc/2.2-approvedIPLog.html</a></li></ul></li></ul><h2 id="Committers">Committers</h2><ol><li>Alexander Kurtakov</li><li>Alexandre Montplaisir</li><li>Bernd Hufmann</li><li>Camilo Bernal</li><li>Krzysztof Daniel</li><li>Daniel Henrique Barboza</li><li>Francois Chouinard</li><li>Jeff Johnston</li><li>Matthew Khouzam</li><li>Otavio Pontes</li><li>Patrick Tasse</li><li>Roland Grunberg</li><li>Sami Wagiaalla</li><li>Xavier Raynaud</li></ol><h2 id="Legal">Legal</h2><p>This document copyright 2013, Mozilla and others; licensed under the EPL v1.0.</p></body></html>
\ No newline at end of file
diff --git a/doc/LinuxTools2.2ReleaseReview.mediawiki b/doc/LinuxTools2.2ReleaseReview.mediawiki
new file mode 100755
index 0000000..4a89518
--- /dev/null
+++ b/doc/LinuxTools2.2ReleaseReview.mediawiki
@@ -0,0 +1,134 @@
+= Linux Tools 2.2 Release Review =
+Planned Review Date: 2013-12-10
+
+Communication Channel:  linuxtools-dev@eclipse.org (https://dev.eclipse.org/mailman/listinfo/linuxtools-dev)
+
+Author:  Jeff Johnston <jjohnstn@redhat.com>
+
+== Introduction ==
+* The Linux Tools project is a two-faceted project
+# Firstly, it provides tools and frameworks for writing tools relevant to Linux developers.
+# Secondly, it provides a place for Linux distributions to collaboratively overcome issues surrounding distribution packaging of Eclipse technology. The project produces both best practices and tools related to packaging.
+* Project plan:  http://www.eclipse.org/projects/project-plan.php?projectid=tools.linuxtools
+
+== Features ==
+* a framework for integrating native profiling tools with the CDT
+* visualization, fetching, and control of LTTng traces
+* GCov code coverage tool integration
+* GProf integration including function-based profiling and integration with the CDT
+* an RPM .spec editor with rpmlint integration
+* plugins integrating the OProfile profiler with the CDT
+* plugins bridging the CDT's hover help functionality with the various open source API documentation formats and tools; called libhover
+* Valgrind integration for memcheck, massif, cachegrind and helgrind
+* ChangeLog management tools
+
+== New in 2.2 ==
+* OPerf is the default for OProfile profiling
+* Enhanced SystemTap graphing
+** multiple graph sets with separate regexes allowed
+* Compare Editor support for perf stat data
+** users can use "Compare with" on selected perf stat output files
+* More New and Noteworthy for 2.2:
+** http://www.eclipse.org/linuxtools/new/2.2
+** (will be moved to http://www.eclipse.org/linuxtools/new after 2.2 is released)
+
+=== Maturity and Communities ===
+* A number of years of development and adoption by a variety of companies and many users
+* Tools included in Linux distributions
+* Open source and commercial extension of plugins and APIs
+* Multiple organizations (6 at the time of writing), committers, and contributors involved in community:
+** http://www.eclipse.org/projects/project.php?id=tools.linuxtools
+
+=== Openness ===
+* Project uses open communication media:
+** mailing list, IRC, Bugzilla
+* Discussions happen in public and all are invited to any project phone calls
+* Project schedule, policies, and procedures are clearly documented and followed
+
+=== "Eclipse way" ===
+* All development occurs in Eclipse git repositories
+* Eclipse IP policy strictly adhered to
+* A copy of our 2.2 IP log, once approved by the Eclipse Legal team, will be archived here:
+** http://www.eclipse.org/linuxtools/doc/2.2-approvedIPLog.html
+* Eclipse development process followed including releases, documentation, ramp-down, etc.
+* Interaction and integration with other Eclipse projects
+
+== APIs ==
+* Our APIs have been reviewed and we consider those that are exposed to be suitable for adopters to use.  They will remain stable for the duration of our 2.x lifecycle. 
+* As always, the project appreciates feedback via Bugzilla or our mailing list.  This is especially true of adopters and their API needs.
+
+== Architectural Issues ==
+* Ongoing work to integrate with tracing and profiling toolkits will enable us to have more extensible frameworks with exemplary implementations.
+* Despite being user-focused, we have a few components which provide extension points:
+** our profiling tool framework whose use is demonstrated by all of our profiling integration plug-ins: Gcov, Gprof, Perf, OProfile and Valgrind
+** our ChangeLog plugin which allows for extensible parsers, formatters, and editors. The extensibility of formatters is demonstrated by our RPM .spec editor
+** our libhover component. This plugin provides an extension point that defines a common documentation format for C library hover help
+** our LTTng component. This plugin provides an extension point to integrate any type of trace and an extension point for producing UML2 sequence diagrams from traces
+
+== Tool Usability ==
+* Our releases thus far have been well-received and at present have satisfied users.  This 2.2 release will hopefully continue to grow our base of satisfied users.
+* Our work integrating native profiling tools like LTTng, perf, OProfile, and Valgrind has been introduced to excited audiences. We aim to improve the power of these tools within the IDE making them easier to use and to support additional functionality that is provided via the command line.  Developers making use of our tools will be able to focus on their own projects and not on setting up the underlying tools.
+
+== End-of-Life ==
+* We have no end-of-life issues to discuss at this time.  Note that some of our plugins will shortly migrated to our incubator (see below).
+
+== Bugzilla ==
+* For our 2.2 release we will have 0 outstanding release-blocker bugs.
+* We closed or resolved over 25 bugs during our 2.2 release cycle:
+https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced;classification=Tools;product=Linux%20Tools;target_milestone=2.2;bug_status=RESOLVED;bug_status=VERIFIED;bug_status=CLOSED;bugidtype=include;list_id=2295921
+
+== Standards ==
+* Our project conforms to the following standards, some of which are ad-hoc and some which are more well-defined:
+** Fedora RPM packaging guidelines
+*** http://fedoraproject.org/wiki/Packaging/Guidelines
+** Informal conventions around use of the GNU Autotools
+** GNU ChangeLog formatting
+*** http://www.gnu.org/prep/standards/html_node/Style-of-Change-Logs.html#Style-of-Change-Logs
+* LTTng trace format
+** http://lttng.org
+
+== UI Usability ==
+* Our project aims to conform to the Eclipse user interface guidelines.
+* All of our user interface components support keyboard navigation.
+* We support interactivity of our Valgrind BIRT-generated charts and intend on further increasing our accessibility.
+* All of our strings are externalized but we currently have no language packs
+* Our strings are registered in Babel for use by translators
+
+== Schedule ==
+* Our project aims to release minor releases (2.2, etc.) ahead of Eclipse maintenance releases
+
+== Communities ==
+* Our project has a strong relationship with the various Linux distributions (Fedora, Mandriva, Debian, Ubuntu, etc.) with many using our eclipse-build project's output for their Eclipse SDK packages
+* The majority of our project's interactions occur on IRC (#eclipse-linux) and our mailing list (linuxtools-dev@eclipse.org)
+* We have a centralized update site and use eclipse.org bugzilla for all of our planning and bug tracking
+* We make use of our newsgroup for user feedback
+* Our project members often speak at conferences such as EclipseCon, the Red Hat Summit, etc.
+* Our team members maintain the following blogs:
+** http://akurtakov.blogspot.com/ (part of Planet Eclipse)
+* We interact often with the CDT project and make use of the GEF and CDT projects
+* We are growing our community of adopters
+
+== IP Log ==
+* Our IP log including information about all CQs, external contributions, and committers can be found here
+** http://www.eclipse.org/projects/ip_log.php?projectid=tools.linuxtools
+* A copy of our 2.2 IP log, once approved by the Eclipse Legal team, is archived here:
+** http://www.eclipse.org/linuxtools/doc/2.2-approvedIPLog.html
+
+== Committers ==
+# Alexander Kurtakov
+# Alexandre Montplaisir
+# Bernd Hufmann
+# Camilo Bernal
+# Krzysztof Daniel
+# Daniel Henrique Barboza
+# Francois Chouinard
+# Jeff Johnston
+# Matthew Khouzam
+# Otavio Pontes
+# Patrick Tasse
+# Roland Grunberg
+# Sami Wagiaalla
+# Xavier Raynaud
+
+== Legal ==
+This document copyright 2013, Mozilla and others; licensed under the EPL v1.0.
diff --git a/new/2.2/new.html b/new/2.2/new.html
index 96b48ee..c199131 100755
--- a/new/2.2/new.html
+++ b/new/2.2/new.html
@@ -10,13 +10,13 @@
 	</tr>
 
 	<tr>
-	    <td bgcolor="#E0D0E6">0.0.0<br>
-	    <i>?? ?? ??</i></td>
+	    <td bgcolor="#E0D0E6">2.2<br>
+	    <i>10 Dec 2013</i></td>
 	    <td bgcolor="#E0D0E6" align="center">
-	    <a href="https://querygoeshere">
-	    ?? bugs</a></td>
+	    <a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&classification=Tools&product=Linux+Tools&target_milestone=2.2&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&status_whiteboard_type=allwordssubstr&status_whiteboard=&keywords_type=allwords&keywords=&bug_status=RESOLVED&bug_status=VERIFIED&bug_status=CLOSED&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=&chfieldto=Now&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0">
+	    27 bugs</a></td>
 	    <td bgcolor="#E0D0E6"><font size="1">
-	    People helped us with stuff.  Put any details here.
+	    Minor release containing SystemTap graphing upgrades, LTTng upgrades, making OPerf the default tool for OProfile profiling, plus the addition of comparison editor support for perf stat data files, in addition to bug fixes.
 	    </font></td>
 	</tr>
 	</table>
@@ -25,18 +25,19 @@
 
 <p><span style="font-weight: 700; background-color: #E0D0E6">New in Linux Tools 2.2</span> </p>
 <ul>
-	<li><a href="#changelog">ChangeLog Tools (# of items for this area; comment out if none)</a></li>
-	<li><a href="#eclipsebuild">Building the Eclipse SDK (# of items for this area; comment out if none)</a></li>
-	<li><a href="#gprof">GCov support (# of items for this area; comment out if none)</a></li>	
-	<li><a href="#gprof">GProf support (# of items for this area; comment out if none)</a></li>
-	<li><a href="#libhover">API Documentation Hover Help (# of items for this area; comment out if none)</a></li>
+	<!-- <li><a href="#changelog">ChangeLog Tools (# of items for this area; comment out if none)</a></li> -->
+	<!-- <li><a href="#eclipsebuild">Building the Eclipse SDK (# of items for this area; comment out if none)</a></li> -->
+	<!-- <li><a href="#gprof">GCov support (# of items for this area; comment out if none)</a></li>	-->
+	<!-- <li><a href="#gprof">GProf support (# of items for this area; comment out if none)</a></li> -->
+	<!-- <li><a href="#libhover">API Documentation Hover Help (# of items for this area; comment out if none)</a></li> -->
 	<li><a href="#oprofile">OProfile Profiling (1)</a></li>
 	<li><a href="#specfileeditor">RPM <tt>.spec</tt> Editor (2)</a></li>
 	<li><a href="#rpmstubby">RPM Stubby (1)</a></li>
 	<li><a href="#systemtap">Systemtap Integration (1)</a></li>
-	<li><a href="#valgrind">Valgrind Profiling (# of items for this area; comment out if none)</a></li>
+	<!-- <li><a href="#valgrind">Valgrind Profiling (# of items for this area; comment out if none)</a></li> -->
 </ul>
 
+<!-- 
 <h2><a id="autotools">GNU Autotools Support</a></h2>
 
 <table cellpadding="10" cellspacing="0">
@@ -71,7 +72,8 @@
 			</td>
 		</tr>
 </table>
-
+-->
+<!--
 <h2><a id="changelog">ChangeLog Tools</a></h2>
 
 <table cellpadding="10" cellspacing="0">
@@ -106,7 +108,9 @@
 			</td>
 		</tr>
 </table>
+-->
 
+<!--
 <h2><a id="eclipsebuild">Building the Eclipse SDK</a></h2>
 
 <table cellpadding="10" cellspacing="0">
@@ -141,7 +145,9 @@
 			</td>
 		</tr>
 </table>
+-->
 
+<!--
 <h2><a id="gprof">GProf Integration</a></h2>
 <table cellpadding="10" cellspacing="0">
 		<tr>
@@ -175,7 +181,9 @@
 			</td>
 		</tr>
 </table>
+-->
 
+<!--
 <h2><a id="libhover">API Documentation Hover Help</a></h2>
 <table cellpadding="10" cellspacing="0">
 		<tr>
@@ -209,6 +217,7 @@
 			</td>
 		</tr>
 </table>
+-->
 
 <h2><a id="oprofile">OProfile Profiling</a></h2>
 
@@ -357,6 +366,7 @@
 		</tr>
 </table>
 
+<!--
 <h2><a id="valgrind">Valgrind Profiling</a></h2>
 
 <table cellpadding="10" cellspacing="0">
@@ -391,6 +401,7 @@
 			</td>
 		</tr>
 </table>
+-->
 
 
 <h2>&nbsp;</h2>
