diff --git a/about.php b/about.php
index c99011a..b43371a 100644
--- a/about.php
+++ b/about.php
@@ -64,9 +64,7 @@
     a lightweight communication protocol specifically suited for embedded software development
     is also part of our offering.</p>
     <p>
-    The basis for our implementations is an open-source version
-    of the <A HREF="http://www.developer.ibm.com/isv/rational/remote_system_explorer.html">
-    IBM Remote System Explorer</A>. Current releases can be downloaded for evaluation
+    Current releases can be downloaded for evaluation
     <a href="http://download.eclipse.org/dsdp/tm/downloads/">here</a>.
 	  <div class="homeitem3col">
 		<h3>For more information, see the</h3>
@@ -88,9 +86,6 @@
     	<li><a href="/dsdp/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
       		Target Management Use-Case Document</a> 
       		to understand what scenarios we want to cover with our project.</li>
-    	<li><a href="http://www.developer.ibm.com/isv/rational/rse_pres.pdf">
-      		IBM Remote Systems Explorer (RSE) Presentation</a>
-			to get a preview of what RSE looks like.
 		<li><a href="/dsdp/tm/development/plan.php">
 			Target Management Project Planning</a> 
 			to understand what features and releases are coming next.</li>
diff --git a/development/contributors.php b/development/contributors.php
index e49807f..b1095d1 100644
--- a/development/contributors.php
+++ b/development/contributors.php
@@ -177,8 +177,6 @@
 				<li><a
 					href="/dsdp/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
-				<li><a href="http://www.developer.ibm.com/isv/rational/rse_pres.pdf"
-					target="_self">IBM RSE Presentation</a></li>
 				<!-- <li><a href="/dsdp/tm/development/index.php">Developer Resources</a></li> -->
 				<li><a href="/dsdp/tm/doc/index.php">Developer Documents</a></li>
 			</ul>
diff --git a/development/index.php b/development/index.php
index 87713eb..e9c7b88 100644
--- a/development/index.php
+++ b/development/index.php
@@ -151,8 +151,6 @@
 				<li><a
 					href="/dsdp/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
 					target="_top">TM Use Cases Document</a></li>
-				<li><a href="http://www.developer.ibm.com/isv/rational/rse_pres.pdf"
-					target="_self">IBM RSE Presentation</a></li>
 				<!-- <li><a href="/dsdp/tm/development/index.php">Developer Resources</a></li> -->
 				<li><a href="/dsdp/tm/doc/index.php">Developer Documents</a></li>
 			</ul>
diff --git a/development/tm_project_plan_2_0.html b/development/tm_project_plan_2_0.html
index a388cca..cf5e3b4 100644
--- a/development/tm_project_plan_2_0.html
+++ b/development/tm_project_plan_2_0.html
@@ -449,8 +449,7 @@
 <p>
 <strong>Contribute Import/Export from RSE7.</strong>
 The predecessor of Eclipse RSE was an IBM product, 
-<a href="http://www.developer.ibm.com/isv/rational/remote_system_explorer.html">
-IBM RSE 7.0</a>. Not all features of RSE 7.0 have been ported yet.
+IBM RSE 7.0. Not all features of RSE 7.0 have been ported yet.
 For Eclipse RSE 2.0, we will port the <em>Import/Export</em> feature.
 Porting User actions and Compile Commands need to be deferred to a later
 release. While porting the feature, it will be refactored and optimized.
@@ -599,8 +598,7 @@
 <blockquote> 
 <p>
 <strong>Contribute User Actions from RSE7.</strong>
-The <a href="http://www.developer.ibm.com/isv/rational/remote_system_explorer.html">
-IBM RSE 7.0</a> <em>User Actions</em> and <em>Compile Commands</em>
+The IBM RSE 7.0 <em>User Actions</em> and <em>Compile Commands</em>
 could not be ported to Eclipse TM RSE 2.0 in time due to lack of resources.
 They will be added in a later release. See the link above
 for a presentation with more details about these features.
diff --git a/development/tm_project_plan_3_0.html b/development/tm_project_plan_3_0.html
index 6e942f8..986c2b8 100644
--- a/development/tm_project_plan_3_0.html
+++ b/development/tm_project_plan_3_0.html
@@ -455,8 +455,7 @@
 <p>
 <strong>Contribute Import/Export from RSE7.</strong>
 The predecessor of Eclipse RSE was an IBM product, 
-<a href="http://www.developer.ibm.com/isv/rational/remote_system_explorer.html">
-IBM RSE 7.0</a>. Not all features of RSE 7.0 have been ported yet.
+IBM RSE 7.0. Not all features of RSE 7.0 have been ported yet.
 For Eclipse RSE 2.0, we will port the <em>Import/Export</em> feature.
 Porting User actions and Compile Commands need to be deferred to a later
 release. While porting the feature, it will be refactored and optimized.
@@ -605,8 +604,7 @@
 <blockquote> 
 <p>
 <strong>Contribute User Actions from RSE7.</strong>
-The <a href="http://www.developer.ibm.com/isv/rational/remote_system_explorer.html">
-IBM RSE 7.0</a> <em>User Actions</em> and <em>Compile Commands</em>
+IBM RSE 7.0 <em>User Actions</em> and <em>Compile Commands</em>
 could not be ported to Eclipse TM RSE 2.0 in time due to lack of resources.
 They will be added in a later release. See the link above
 for a presentation with more details about these features.
diff --git a/doc/index.php b/doc/index.php
index 505ecd5..aa5d5af 100644
--- a/doc/index.php
+++ b/doc/index.php
@@ -73,8 +73,6 @@
 		   <a href="http://www.eclipse.org/downloads/download.php?file=/dsdp/tm/presentations/2006-3-22_EclipseCon_Target_Management.ppt">
 		   Using and Extending the DSDP Target Management Framework (PPT: 850k)</a>
 		   | <a href="http://eclipsezilla.eclipsecon.org/php/attachment.php?bugid=287">(Zipped PPT: 559k)</a></li>
-		<li><a href="http://www.developer.ibm.com/isv/rational/rse_pres.pdf">
-		    IBM RSE Presentation</a></li>
 		</ul>
 
 		<h2>Older Meeting Notes (Newer notes are on the <a href="http://wiki.eclipse.org/DSDP/TM">Wiki</a>)</h2>
@@ -122,8 +120,6 @@
 				<li><a
 					href="/dsdp/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
-				<li><a href="http://www.developer.ibm.com/isv/rational/rse_pres.pdf"
-					target="_self">IBM RSE Presentation</a></li>
 				<!-- <li><a href="/dsdp/tm/development/index.php">Developer Resources</a></li> -->
 				<li><a href="/dsdp/tm/development/plan.php"
 					target="_self">TM Project Plan</a></li>
diff --git a/downloads.php b/downloads.php
index c1966e5..c047c0a 100644
--- a/downloads.php
+++ b/downloads.php
@@ -68,8 +68,6 @@
 				<li><a
 					href="/dsdp/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
-				<li><a href="http://www.developer.ibm.com/isv/rational/rse_pres.pdf"
-					target="_self">IBM RSE Presentation</a></li>
 				<!-- <li><a href="/dsdp/tm/development/index.php">Developer Resources</a></li> -->
 				<li><a href="/dsdp/tm/doc/index.php">Developer Documents</a></li>
 			</ul>
diff --git a/tm-new/about/index.php b/tm-new/about/index.php
index 940315d..173c7fc 100644
--- a/tm-new/about/index.php
+++ b/tm-new/about/index.php
@@ -64,9 +64,7 @@
     a lightweight communication protocol specifically suited for embedded software development
     is also part of our offering.</p>
     <p>
-    The basis for our implementations is an open-source version
-    of the <A HREF="http://www.developer.ibm.com/isv/rational/remote_system_explorer.html">
-    IBM Remote System Explorer</A>. Current releases can be downloaded for evaluation
+    Current releases can be downloaded for evaluation
     <a href="http://download.eclipse.org/dsdp/tm/downloads/">here</a>.
 	  <div class="homeitem3col">
 		<h3>For more information, see the</h3>
@@ -88,9 +86,6 @@
     	<li><a href="/dsdp/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
       		Target Management Use-Case Document</a> 
       		to understand what scenarios we want to cover with our project.</li>
-    	<li><a href="http://www.developer.ibm.com/isv/rational/rse_pres.pdf">
-      		IBM Remote Systems Explorer (RSE) Presentation</a>
-			to get a preview of what RSE looks like.
 		<li><a href="/dsdp/tm/development/plan.php">
 			Target Management Project Planning</a> 
 			to understand what features and releases are coming next.</li>
diff --git a/tm-new/downloads/index.php b/tm-new/downloads/index.php
index c1966e5..c047c0a 100755
--- a/tm-new/downloads/index.php
+++ b/tm-new/downloads/index.php
@@ -68,8 +68,6 @@
 				<li><a
 					href="/dsdp/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
-				<li><a href="http://www.developer.ibm.com/isv/rational/rse_pres.pdf"
-					target="_self">IBM RSE Presentation</a></li>
 				<!-- <li><a href="/dsdp/tm/development/index.php">Developer Resources</a></li> -->
 				<li><a href="/dsdp/tm/doc/index.php">Developer Documents</a></li>
 			</ul>
diff --git a/tm-new/team/index.php b/tm-new/team/index.php
index a949f5a..38c31f5 100644
--- a/tm-new/team/index.php
+++ b/tm-new/team/index.php
@@ -133,8 +133,6 @@
 				<li><a
 					href="/dsdp/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf"
 					target="_self">TM Use Cases Document</a></li>
-				<li><a href="http://www.developer.ibm.com/isv/rational/rse_pres.pdf"
-					target="_self">IBM RSE Presentation</a></li>
 				<!-- <li><a href="/dsdp/tm/development/index.php">Developer Resources</a></li> -->
 				<li><a href="/dsdp/tm/doc/index.php">Developer Documents</a></li>
 			</ul>
diff --git a/tm-new/tutorial/index.php b/tm-new/tutorial/index.php
index 86097d8..8116dd8 100644
--- a/tm-new/tutorial/index.php
+++ b/tm-new/tutorial/index.php
@@ -75,10 +75,7 @@
 	and an <a href="http://wiki.eclipse.org/TM_and_RSE_FAQ">
 	FAQ</a> is available on the project Wiki.</p>
 	<p>
-    The basis of RSE is a former IBM product, for which a
-    <A href="http://www.developer.ibm.com/isv/rational/remote_system_explorer.html">
-    slide show</A> is still available. Our plans beyond 
-    TM 2.0 are available from the
+	Our plans beyond TM 2.0 are available from the
     Target Management <a href="/dsdp/tm/development/plan.php">Project Plan
     </a> and our <a href="/dsdp/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
     Use Cases Document</a>, which covers all areas of interest to us.</p>
@@ -119,10 +116,6 @@
     	<li><a href="/dsdp/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
       		Target Management Use-Case Document</a> 
       		to understand what scenarios we want to cover with our project.</li>
-    	<li><a href="http://www.developer.ibm.com/isv/rational/rse_pres.pdf">
-      		IBM Remote Systems Explorer (RSE) Presentation</a>
-			to get a preview of what the first release of the Target Management System
-			will look like.
 		<li><a href="/dsdp/tm/development/plan.php">
 			Target Management Project Plan</a> 
 			to understand what features and releases are coming next.</li>
diff --git a/tutorial/index.php b/tutorial/index.php
index 15f500a..8232f9b 100644
--- a/tutorial/index.php
+++ b/tutorial/index.php
@@ -77,10 +77,7 @@
 	and an <a href="http://wiki.eclipse.org/TM_and_RSE_FAQ">
 	FAQ</a> is available on the project Wiki.</p>
     <p>
-    The basis of RSE is a former IBM product, for which a
-    <A href="http://www.developer.ibm.com/isv/rational/remote_system_explorer.html">
-    slide show</A> is still available. Our plans beyond 
-    TM 3.0 are available from the
+	Our plans beyond TM 3.0 are available from the
     Target Management <a href="/dsdp/tm/development/plan.php">Project Plan
     </a> and our <a href="/dsdp/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
     Use Cases Document</a>, which covers all areas of interest to us.</p>
@@ -121,10 +118,6 @@
     	<li><a href="/dsdp/tm/doc/DSDPTM_Use_Cases_v1.1c.pdf">
       		Target Management Use-Case Document</a> 
       		to understand what scenarios we want to cover with our project.</li>
-    	<li><a href="http://www.developer.ibm.com/isv/rational/rse_pres.pdf">
-      		IBM Remote Systems Explorer (RSE) Presentation</a>
-			to get a preview of what the first release of the Target Management System
-			will look like.
 		<li><a href="/dsdp/tm/development/plan.php">
 			Target Management Project Plan</a> 
 			to understand what features and releases are coming next.</li>
