diff --git a/NewAndNoteworthy_3.12.1.html b/NewAndNoteworthy_3.12.1.html
new file mode 100644
index 0000000..abfbe75
--- /dev/null
+++ b/NewAndNoteworthy_3.12.1.html
@@ -0,0 +1,217 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+       "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<title>ECF New and Noteworthy</title>
+<link rel="stylesheet" href="http://www.eclipse.org/default_style.css"
+	type="text/css">
+
+</head>
+
+<body bgcolor="#FFFFFF">
+	<table border=0 cellspacing=5 cellpadding=2 width="100%">
+		<tbody>
+			<tr>
+				<td width="69%" class="bannertext">
+				<img src="https://wiki.eclipse.org/images/b/b8/Logo128x37.png" alt="ECF Logo"/>
+				<font class="indextop style">Eclipse Communication Framework (ECF)</font>
+						
+						<br>
+				<br> <font class="indexsub">an eclipse runtime project</font> <br>
+				<br> <font class="indextop style2">New and Noteworthy</font><br>
+					3.12.1 Release <br> <br>
+				<br> Return to <a href="downloads.php">ECF download page</a><br>
+					<br>
+
+				<br><a
+					href="NewAndNoteworthy_3.11.0.html">New and Noteworthy for 3.11.0/Mars</a><br>
+					<br>
+				<br><a
+					href="NewAndNoteworthy_3.12.0.html">New and Noteworthy for 3.12.0</a><br>
+					<br>
+				<br></td>
+				<td width="31%">
+					<div align="center">
+						<img src="images/Idea.jpg" width="120" height="86" hspace="50"
+							align="middle" alt="Idea Icon">
+					</div>
+				</td>
+			</tr>
+		</tbody>
+	</table>
+
+	<hr>
+
+	<table>
+			 <tr>
+			<td valign="top" align="left" width="15%">
+				<p align="left">
+					<b>Enhanced Remote Services/Remote Service Admin Tooling</b>
+				</p>
+			</td>
+			<td valign="top" width="85%"><p>In <a
+					href="NewAndNoteworthy_3.10.0.html">ECF 3.10.0/Mars a Remote Services Perspective</a> was introduced.   This perspective included
+					an Endpoint Discovery View allowing endpoints to be discovered (via network discovery and/or xml/EDEF-file-based discovery), examined,
+					and imported for use as a remote service.   
+			<p>
+			<p>
+			In this release, there's a new Remote Service Admin (RSA) manager view.  This view presents the Exported Services and Imported Endpoints 
+			for the RSA running within Eclipse, allowing the programmer to <a href="http://wiki.eclipse.org/Remote_Services_Admin">examine and manipulate exported services and imported endpoints</a>.  
+			This tooling may be used to test and debug ECF Remote Services by monitoring and managing the remote services export, discovery, and import.
+			<p>
+			<p>
+			For example, here is a screenshot showing an endpoint that has been exported and published for 
+			by a remote  
+			host (e.g. by a <a href="http://wiki.eclipse.org/EIG:Install_Timeline_Example_into_Apache_Karaf">Karaf-based host</a>),
+			and then <a href="http://wiki.eclipse.org/Discovery_Providers">discovered via the Zeroconf protocol</a> (presented
+			in the Endpoint Discovery View)<p>
+			<p>
+			<img src="images/screens/remoteserviceperspective.3.12.1.png">
+			</p>
+			The user can select this Discovered Endpoint, open the context menu, and select the 'Import Remote Service' menu.
+			The selected Endpoint will then be imported, and the Imported Endpoint will appear in the RSA Manager view.
+			<p>
+			<p>
+			<img src="images/screens/remoteserviceperspective.3.12.2.png">
+			</p>
+			<p>
+			Note that the imported endpoint (the remote service proxy) is also presented in the OSGi Services View, and the properties
+			associated with the selected mported endpoint are presented in the properties view.<p>
+			<p>
+			The Imported Endpoints presented in the RSA Manager view can be Unimported (again via context menu).  As well,
+			if remote service hosts are exported, they will appear under the Exported Services group in the RSA Manager, and
+			can also be unexported via the RSA Manager context menu.
+			</p>
+			</td>
+		</tr>
+	
+			 <tr>
+			<td valign="top" align="left" width="15%">
+				<p align="left">
+					<b>Remote Services Distribution Provider API</b>
+				</p>
+			</td>
+			<td valign="top" width="85%"><p>Remote Services distribution providers are responsible for implementing the remote method call...i.e. the 
+			serialization of parameters and return values, and the communications protocol used to communicate between the caller and the
+			remote service.
+			caller.  
+			</p>
+			<p>
+			ECF's Remote Services implementation allows the use of custom or alternative distribution providers.  Allows ECF's
+			Remote Services implementation to be used with any desired serialization mechanism and any suitable communications protocol.
+			</p> 
+			<p>For easy creation of distribution providers, we've added a new <a href="http://download.eclipse.org/rt/ecf/3.11.0/javadoc/org/eclipse/ecf/remoteservice/provider/IRemoteServiceDistributionProvider.html">IRemoteServiceDistributionProvider</a>
+			interface so that a distribution provider may be registered for use via the <a href="http://www.osgi.org/wiki/uploads/Links/whiteboard.pdf">OSGi whiteboard pattern</a>.  
+			<a href="http://download.eclipse.org/rt/ecf/3.11.0/javadoc/org/eclipse/ecf/remoteservice/provider/package-frame.html">Here is the org.eclipse.ecf.remoteservice.provider</a> package.
+			</p>
+			<p>
+			For example, <a href="https://github.com/ECF/JaxRSProviders/blob/master/bundles/org.eclipse.ecf.provider.jersey.client/src/org/eclipse/ecf/provider/jersey/client/JerseyClientDistributionProvider.java">here is a distribution
+			provider</a> implemented using <a href="http://jersey.java.net">Jersey Jax-RS</a> REST framework.   A single instance of this class
+			is <a href="https://github.com/ECF/JaxRSProviders/blob/master/bundles/org.eclipse.ecf.provider.jersey.server/OSGI-INF/distributionprovider.xml">registered via Declarative Services</a> and any remote services using the 'ecf.jaxrs.jersey.server' config type will
+			use Jersey as the distribution mechanism.  See the <a href="https://github.com/ECF/JaxRSProviders/tree/master/examples">examples</a> in 
+			the <a href="https://github.com/ECF/JaxRSProviders">JaxRSProviders</a> repo for complete examples of using this provider. 
+			</p>
+			</td>
+		</tr>
+	
+				 <tr>
+			<td valign="top" align="left" width="15%">
+				<p align="left">
+					<b>New Distribution Providers and Distribution Provider documentation</b>
+				</p>
+			</td>
+			<td valign="top" width="85%"><p>Using the remote services distribution provider API above, several new 
+			distribution providers have been created:
+			<ul>
+			<li><a href="https://github.com/ECF/JaxRSProviders">Jax-RS Providers (Jersey, CXF, Resteasy)</a></li>
+			<li><a href="https://github.com/ECF/HazelcastProvider">Hazelcast</a></li>
+			<li><a href="https://github.com/ECF/Mqtt-Provider">MQTT</a></li>
+			</ul>
+			</p>
+			<p><a href="https://wiki.eclipse.org/Distribution_Providers">Detailed documentation of existing distribution providers</a>
+			</td>
+		</tr>
+		
+				 <tr>
+			<td valign="top" align="left" width="15%">
+				<p align="left">
+					<b>Remote Management for OSGi Runtimes and Eclipse</b>
+				</p>
+			</td>
+			<td valign="top" width="85%"><p>At the <a href="https://github.com/ECF">ECF Github site</a>, we've made new services...implemented as 
+			OSGi remote service...that allow OSGi frameworks to be remotely monitored and managed.   The <a href="https://github.com/ECF/OSGIRemoteManagement">OSGiRemoteManagement repository is here</a>.  Each remote management service is defined and implemented separately,
+			so that relevant services can be installed and used in appropriate environments.  For example, if <a href="https://wiki.eclipse.org/EIG:Install_into_Apache_Karaf">Karaf server environments</a> the
+			OSGi management services would be completely appropriate, and the Eclipse-specific services from the list below would not be appropriate.
+			
+			<ul>
+			   <li><b>Framework Management Services</b>
+			      <ul>
+			         <li>
+			           <a href="https://github.com/ECF/OSGIRemoteManagement/tree/master/bundles/org.eclipse.ecf.mgmt.framework/src/org/eclipse/ecf/mgmt/framework/IFrameworkManager.java">Framework Manager</a> - Remotely access framework-level information such as framework properties, and get/set start levels.
+			         </li>
+			      	 <li>
+			           <a href="https://github.com/ECF/OSGIRemoteManagement/tree/master/bundles/org.eclipse.ecf.mgmt.framework/src/org/eclipse/ecf/mgmt/framework/IServiceManager.java">Service Manager</a> - Remotely access information about running services.
+			         </li>
+			      	 <li>
+			           <a href="https://github.com/ECF/OSGIRemoteManagement/tree/master/bundles/org.eclipse.ecf.mgmt.framework/src/org/eclipse/ecf/mgmt/framework/IBundleManager.java">Bundle Manager</a> - Remotely access information about bundles in framework, and remotely start/stop bundles.
+			         </li>
+
+			          <li>
+			           <a href="https://github.com/ECF/OSGIRemoteManagement/tree/master/bundles/org.eclipse.ecf.mgmt.framework/src/org/eclipse/ecf/mgmt/framework/wiring/IWiringManager.java">Wiring Manager</a> - Remotely access information about bundle wiring.
+			         </li>
+			          <li>
+			           <a href="https://github.com/ECF/OSGIRemoteManagement/blob/master/bundles/org.eclipse.ecf.mgmt.application/src/org/eclipse/ecf/mgmt/application/IApplicationManager.java">Application Manager</a> - Remotely access information about OSGi applications.  Also allows remotely starting/stopping applications.
+			         </li>
+			          <li>
+			           <a href="https://github.com/ECF/OSGIRemoteManagement/blob/master/bundles/org.eclipse.ecf.mgmt.scr/src/org/eclipse/ecf/mgmt/scr/ISCRManager.java">Service Component Runtime (SCR) Manager</a> - Remotely access meta-data about SCR/DS components.  Also allows remotely enabling/disabling components.
+			         </li>
+			          <li>
+			           <a href="https://github.com/ECF/OSGIRemoteManagement/blob/master/bundles/org.eclipse.ecf.mgmt.rsa/src/org/eclipse/ecf/mgmt/rsa/IRemoteServiceAdminManager.java">Remote Service Admin Manager</a> - Remotely access meta-data about RSA such as RSA events, and remote service registrations and references.  Also allows remotely exporting, importing, updating, and closing remote services.
+			         </li>
+			      </ul>
+			   </li>
+			   <li><b>Eclipse-specific Management Services</b>
+			      <ul>
+			      <li><b>P2 Management Services</b>
+				      <ul>
+				         <li>
+				           <a href="https://github.com/ECF/OSGIRemoteManagement/blob/master/bundles/org.eclipse.ecf.mgmt.p2.install/src/org/eclipse/ecf/mgmt/p2/install/IFeatureInstallManager.java">Feature Install Manager</a> - Remotely access feature meta-data and install, update, and install P2 feature groups.
+				         </li>
+				      	 <li>
+				           <a href="https://github.com/ECF/OSGIRemoteManagement/blob/master/bundles/org.eclipse.ecf.mgmt.p2.profile/src/org/eclipse/ecf/mgmt/p2/profile/IProfileManager.java">Profile Manager</a> - Remotely access meta-data about existing and active P2 profiles.
+				         </li>
+				      	 <li>
+				           <a href="https://github.com/ECF/OSGIRemoteManagement/blob/master/bundles/org.eclipse.ecf.mgmt.p2.repository/src/org/eclipse/ecf/mgmt/p2/repository/IRepositoryManager.java">Repository Manager</a> - Remotely access meta-data about repositories and their contents, and remotely add, refresh, and remove repositories.
+				         </li>
+				      </ul>
+				  </li>
+			      <li><b>ECF Management Services</b>
+				      <ul>
+				         <li>
+				           <a href="https://github.com/ECF/OSGIRemoteManagement/blob/master/bundles/org.eclipse.ecf.mgmt.identity/src/org/eclipse/ecf/mgmt/identity/IIdentityFactoryManager.java">Identity Manager</a> - Remotely access meta-data about ECF Namespaces and IDs, and remotely create/add namespaces and IDs.
+				         </li>
+				      	 <li>
+				           <a href="https://github.com/ECF/OSGIRemoteManagement/blob/master/bundles/org.eclipse.ecf.mgmt.container/src/org/eclipse/ecf/mgmt/container/IContainerFactoryManager.java">Container Manager</a> - Remotely access meta-data about existing and active ECF Containers, and remotely create new containers.
+				         </li>
+				      	 <li>
+				           <a href="https://github.com/ECF/OSGIRemoteManagement/tree/master/bundles/org.eclipse.ecf.mgmt.sharedobject">Shared Object Manager</a> - Remotely access information about existing meta-data about shared object containers and shared objects, and remotely create and delete shared objects.
+				         </li>
+				      </ul>
+				  </li>
+			      </ul>
+			   </li>  
+			</ul>
+			</p><p></p>
+			<p>
+			Each of the above services also has an async proxy interface, allowing the remote service to be accessed via a non-blocking<a href="https://wiki.eclipse.org/ECF/Asynchronous_Remote_Services">async proxy</a> create automatically for the 
+			remote service by ECF's Remote Services implementation.  Host implementations of each of these services are also available.
+			</p>
+			</td>
+		</tr>
+		
+</table> 
+ 
+</body> 
+</html> 
diff --git a/images/screens/remotemanagementhost.png b/images/screens/remotemanagementhost.png
new file mode 100644
index 0000000..02d9ef3
--- /dev/null
+++ b/images/screens/remotemanagementhost.png
Binary files differ
