diff --git a/downloads/index.php b/downloads/index.php
index c5a59a2..0caa280 100644
--- a/downloads/index.php
+++ b/downloads/index.php
@@ -71,7 +71,8 @@
 	$rootDir = $App->getDownloadBasePath();
 	# This is what AspectJ does:
  	# $builds = ListDevBuilds("$rootDir/tools/aspectj/dev");
-	
+
+	$builds42 = ListDevBuilds("$rootDir/tools/ajdt/42/dev/update", "4.2");	
 	$builds37 = ListDevBuilds("$rootDir/tools/ajdt/37/dev/update", "3.7");
 	$builds36 = ListDevBuilds("$rootDir/tools/ajdt/36/dev/update", "3.6");
 	$builds35 = ListDevBuilds("$rootDir/tools/ajdt/35/dev/update", "3.5");
@@ -86,14 +87,91 @@
 
 <div id="maincontent">
 	<div id="midcolumn" style="width: 70%">
-	
 	<h1>Downloads</h1>
 
 <p>Please make sure you pick a version of AJDT which matches the version
 of Eclipse you are using.</p>
 
-<p>Note also that the Update Sites are now under /tools instead
-of /technology, since AJDT become a Tools project.</p>
+<div class="homeitem3col">
+<a name="2.2"></a>
+<h3>AJDT 2.2 release builds for Eclipse 4.2 and 3.7</h3>
+<ul>
+<li>
+	AJDT 2.2.0 for Eclipse 4.2 and 3.7 <em>with JDT weaving</em><br>
+	What is <a href="http://wiki.eclipse.org/JDT_weaving_features">JDT weaving</a>?
+	<table class="tasklist" width="80%">
+	  <tr>
+	    <th align="left">2.2.0 Release Date:</th><td>July 5, 2012</td>
+	  </tr>
+	  <tr>
+	    <th align="left">AspectJ Version in 2.2.0:</th><td><a href="http://www.eclipse.org/downloads/download.php?file=/tools/aspectj/aspectj-1.7.0.jar">1.7.0</a></td>
+	  </tr>
+	  <tr>
+	    <th align="left">Eclipse 4.2 Update Site URL:</th>
+	    <td><strong><code>http://download.eclipse.org/tools/ajdt/42/update</code></strong></td>
+	  </tr>
+	  <tr>
+	    <th align="left">Eclipse 3.7 Update Site URL:</th>
+	    <td><strong><code>http://download.eclipse.org/tools/ajdt/37/update</code></strong></td>
+	  </tr>
+	  <tr>
+	    <th align="left">AJDT for Eclipse 3.6 Zip file:</th>
+	    <td><a href="http://download.eclipse.org/tools/ajdt/36/update/ajdt_2.2.0_for_eclipse_4.2.zip">ajdt_2.2.0_for_eclipse_4.2.zip</a></td>
+	  </tr>	  
+	  <tr>
+	    <th align="left">AJDT for Eclipse 3.7 Zip file:</th>
+	    <td><a href="http://download.eclipse.org/tools/ajdt/37/update/ajdt_2.2.0_for_eclipse_3.7.zip">ajdt_2.2.0_for_eclipse_3.7.zip</a></td>
+	  </tr>	  
+	</table>
+	To install from a zip file, download the zip and point your p2 installer to that file.  Then proceed as if it were a normal update site.
+	Do <em>not</em> unzip the update site into the dropins directory.
+</li>
+</ul>
+</div>
+
+<div class="homeitem3col">
+<a name="dev42"></a>
+<h3>Development builds for Eclipse 3.7</h3>
+<ul>
+	<li>
+		AJDT 2.2.1 dev builds for Eclipse 4.2
+		<table class="tasklist" width="80%">
+		  <tr>
+		    <th align="left">Update Site URL:</th>
+		    <td><strong><code>http://download.eclipse.org/tools/ajdt/42/dev/update</code></strong></td>
+		  </tr>
+		  <tr>
+		    <th align="left">Zip file:</th>
+		    <td><a href="#42zips">See below</a></td>
+		  </tr>	  
+		</table>
+	To install from a zip file, download the zip and point your p2 installer to that file.  Then proceed as if it were a normal update site.
+	Do <em>not</em> unzip the update site into the dropins directory.
+	</li>
+</ul>
+</div>
+
+<div class="homeitem3col">
+<a name="dev37"></a>
+<h3>Development builds for Eclipse 3.7</h3>
+<ul>
+	<li>
+		AJDT 2.2.1 dev builds for Eclipse 3.7
+		<table class="tasklist" width="80%">
+		  <tr>
+		    <th align="left">Update Site URL:</th>
+		    <td><strong><code>http://download.eclipse.org/tools/ajdt/37/dev/update</code></strong></td>
+		  </tr>
+		  <tr>
+		    <th align="left">Zip file:</th>
+		    <td><a href="#37zips">See below</a></td>
+		  </tr>	  
+		</table>
+	To install from a zip file, download the zip and point your p2 installer to that file.  Then proceed as if it were a normal update site.
+	Do <em>not</em> unzip the update site into the dropins directory.
+	</li>
+</ul>
+</div>
 
 
 	<div class="homeitem3col">
@@ -111,11 +189,7 @@
 		    <th align="left">AspectJ Version in 2.1.3:</th><td><a href="http://www.eclipse.org/downloads/download.php?file=/tools/aspectj/aspectj-1.6.12.M1.jar">1.6.12.M1</a></td>
 		  </tr>
 		  <tr>
-		    <th align="left">Eclipse 3.7 Update Site URL:</th>
-		    <td><strong><code>http://download.eclipse.org/tools/ajdt/37/update</code></strong></td>
-		  </tr>
-		  <tr>
-		    <th align="left">Eclipse 3.6 Update Site URL:</th>
+		    <th align="left">Eclipse 3.6 Update Site URL: (No longer under active development)</th>
 		    <td><strong><code>http://download.eclipse.org/tools/ajdt/36/update</code></strong></td>
 		  </tr>
 		  <tr>
@@ -143,27 +217,6 @@
 	</ul>
 	</div>
 	
-<div class="homeitem3col">
-<a name="dev37"></a>
-<h3>Development builds for Eclipse 3.7</h3>
-<ul>
-	<li>
-		AJDT 2.1.3 dev builds for Eclipse 3.7
-		<table class="tasklist" width="80%">
-		  <tr>
-		    <th align="left">Update Site URL:</th>
-		    <td><strong><code>http://download.eclipse.org/tools/ajdt/37/dev/update</code></strong></td>
-		  </tr>
-		  <tr>
-		    <th align="left">Zip file:</th>
-		    <td><a href="#37zips">See below</a></td>
-		  </tr>	  
-		</table>
-	To install from a zip file, download the zip and point your p2 installer to that file.  Then proceed as if it were a normal update site.
-	Do <em>not</em> unzip the update site into the dropins directory.
-	</li>
-</ul>
-</div>
 
 <div class="homeitem3col">
 <a name="dev36"></a>
@@ -187,7 +240,7 @@
 </ul>
 </div>
 
-	<h3>AJDT 2.1 release builds for Eclipse 3.7 and 3.6</h3>
+	<h3>AJDT 2.1 release builds for Eclipse 3.6 and 3.5</h3>
 	<ul>
 	<li>
 		AJDT 2.1.1 for Eclipse 3.5 <em>with JDT weaving</em><br>
@@ -352,6 +405,21 @@
 	<ul>
 	
 		<li>
+			<a name="42zips"></a>Eclipse 4.2 builds
+			<br>Update Site URL:<br>
+			<code>http://download.eclipse.org/tools/ajdt/42/dev/update</code>
+			</p>
+			<p>
+			<table class="tasklist" width="100%">
+  			<tr align="left">
+    			<th>Zip&nbsp;file</th>
+  			</tr>
+$builds42
+			</table>
+			</p>
+		</li>
+		
+		<li>
 			<a name="37zips"></a>Eclipse 3.7 builds
 			<br>Update Site URL:<br>
 			<code>http://download.eclipse.org/tools/ajdt/37/dev/update</code>
diff --git a/index.php b/index.php
index 2a9610b..024faba 100644
--- a/index.php
+++ b/index.php
@@ -63,14 +63,22 @@
 		<div class="homeitem3col">
 			<h3>News and Releases</h3>
 			<ul>
- 				 <li>
+				 <li>
 						<img src="images/new.gif" width="11" height="11">
+						<a href="whatsnew220">AJDT 2.2.0</a>
+						is now available.  This is the first release that targets Juno.  This release includes <a
+						href="http://eclipse.org/aspectj/doc/released/README-170.html">AspectJ 1.7.0</a>.
+						The release build is available from the <a href="downloads">downloads</a> page.
+						<br><span class="dates">posted 07-05-12</span>
+				 </li>
+ 				 <li>
 						AJDT configurator for m2e v1.0 is now available at 
 						<a href="http://dist.springsource.org/release/AJDT/configurator/">http://dist.springsource.org/release/AJDT/configurator/</a>.
 						Add this update site to your Eclipse install manager to install the configurator.  This configurator will ensure that 
 						Maven projects in Eclipse are properly configured with AspectJ and AJDT.
 						<br><span class="dates">posted 09-30-11</span>
 				 </li>
+			  <!--
  				 <li>
 						<a href="whatsnew213">AJDT 2.1.3</a>
 						is now available.  This is the first release that targets Indigo.  This release includes <a
@@ -78,7 +86,6 @@
 						The release build is available from the <a href="downloads">downloads</a> page.
 						<br><span class="dates">posted 06-29-11</span>
 				 </li>
-			  <!--
  				 <li>
 						AJDT 2.1.3 targeting Eclipe 3.7 (Indigo) 
 						dev builds are now available.  See <a href="downloads#dev37">downloads</a> page for more detail.
diff --git a/whatsnew220/index.html b/whatsnew220/index.html
new file mode 100644
index 0000000..be65112
--- /dev/null
+++ b/whatsnew220/index.html
@@ -0,0 +1,109 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+<head>
+<link rel="STYLESHEET" href="http://www.eclipse.org/default_style.css"
+	charset="ISO-8859-1" type="text/css">
+<meta content="text/html; charset=ISO-8859-1" http-equiv="content-type">
+<title>AJDT 2.2.0 - New and Noteworthy</title>
+
+</head>
+<body>
+	<h1>AJDT 2.2.0 - New and Noteworthy</h1>
+
+	<table border="0" cellpadding="10" cellspacing="0" width="80%">
+		<tbody>
+			<tr>
+				<td valign="top"><b>Overview</b>
+				</td>
+				<td valign="top">The main pieces of this release has been our Eclipse Juno support and our AspectJ 1.7 support.</td>
+			</tr>
+
+
+			<tr>
+				<td colspan="2">
+					<hr></td>
+			</tr>
+			<tr>
+				<td valign="top"><b>Eclipse 4.2 (Juno) support</b>
+				</td>
+				<td>As of this AJDT release (2.2.0), the main development line will be the Eclipse 4.2 branch.  We will produce at least one more 
+				version of the 4.2 branch of AJDT before deprecating it.  The update site for Eclipse 4.2 support is:
+				<a href ="http://download.eclipse.org/tools/ajdt/42/update"><strong><pre>http://download.eclipse.org/tools/ajdt/42/update</pre></strong></a>
+				And as before the update site for Eclipse 3.7-based AJDT is:
+				<a href ="http://download.eclipse.org/tools/ajdt/37/update"><strong><pre>http://download.eclipse.org/tools/ajdt/37/update</pre></strong></a>
+				</td>
+			</tr>
+
+			<tr>
+				<td colspan="2">
+					<hr></td>
+			</tr>
+			<tr>
+				<td valign="top"><b>AspectJ 1.7.0</b>
+				</td>
+				<td>AJDT 2.2.0 include AspectJ 1.6.7.0.  See the <a href="http://eclipse.org/aspectj/doc/released/README-170.html">
+				release notes</a> for more information.</td>
+			</tr>
+
+			<tr>
+				<td colspan="2">
+					<hr></td>
+			</tr>
+			<tr>
+				<td valign="top"><b>Migration to git</b>
+				</td>
+				<td>The AJDT source code is now located in an Eclipse git repository.  
+				<a href="http://git.eclipse.org/c/ajdt/org.eclipse.ajdt.git/" target="_blank"></a>You can clone and make pull requests here</a>.</td>
+			</tr>
+
+			<tr>
+				<td colspan="2">
+					<hr></td>
+			</tr>
+			<tr>
+				<td valign="top"><b>Bug Fixes</b>
+				</td>
+				<td>Some of the notable bug fixes in this release are:
+				
+				<ul>
+				<li><a href="http://bugs.eclipse.org/245265">Bug 245265</a>: <em>Add content assist proposal kind for AspectJ</em></li>
+				<li><a href="http://bugs.eclipse.org/352369">Bug 352369</a>: <em>Update M2Eclipse AJDT configurator to work with m2e 1.0+</em></li>
+				<li><a href="http://bugs.eclipse.org/354413">Bug 354413</a>: <em>Class reference searching not working. Complicates refactoring.</em></li>
+				<li><a href="http://bugs.eclipse.org/367354">Bug 367354</a>: <em>Invalid code generated in re-organize imports</em></li>
+				</ul>
+				See <a href="http://tinyurl.com/7acbey7" target="_blank">bugzilla</a>
+					for a list of all bugs addressed in this release.</td>
+			</tr>
+
+			<tr>
+				<td colspan="2">
+					<hr></td>
+			</tr>
+			<tr>
+				<td valign="top"><b>Previous Releases</b>
+				</td>
+				<td>See <a
+					href="http://www.eclipse.org/ajdt/whatsnew213/index.html">here</a>
+					for information on the new features in AJDT 2.1.3.</td>
+			</tr>
+			<tr>
+				<td colspan="2">
+					<hr></td>
+			</tr>
+			<tr>
+				<td valign="top"><b>Thanks!</b>
+				</td>
+				<td>Thanks for community help and feedback during this release
+					cycle. You can contact the AJDT team on the <a
+					href="https://dev.eclipse.org/mailman/listinfo/ajdt-dev">mailing
+						list</a>, and raise bugs on <a href="https://bugs.eclipse.org/bugs/">bugzilla</a>.
+					We also lurk on the <a
+					href="http://eclipse.org/aspectj/userlists.php">AspectJ users
+						list</a>, and on the <a
+					href="http://forum.springsource.org/forumdisplay.php?f=32">SpringSource
+						Tool Suite forum</a>.</td>
+			</tr>
+		</tbody>
+	</table>
+</body>
+</html>
