diff --git a/sidebars/root.php b/sidebars/root.php
index 462d628..cf21e1e 100644
--- a/sidebars/root.php
+++ b/sidebars/root.php
@@ -1,7 +1,7 @@
 <div class="sideitem">
     <h6>We Are Looking for a Sponsor</h6>
     <p>
-    	<b>Become a sponsor of the most popular project in Eclipse ecosystem.</b>
+    	<b>Become a Sponsor for the most popular project in the Eclipse ecosystem.</b>
     </p>
     <p align="right">
     	<a href="/subversive/sponsor.php">Learn more &gt;</a>    
diff --git a/sponsor.php b/sponsor.php
index 877a17a..82ec8f9 100644
--- a/sponsor.php
+++ b/sponsor.php
@@ -11,7 +11,7 @@
 	$localVersion = false;
 	
 	# Define these here, or in _projectCommon.php for site-wide values
-	$pageTitle 		= "Subversive Project is Looking for Sponsors";
+	$pageTitle 		= "Subversive Project is Looking for a Sponsor";
 	$pageKeywords	= "subversive, svn, subversion, project";
 	$pageAuthor		= "Igor Vinnykov";
 	
@@ -23,13 +23,13 @@
 	<div id="midcolumn">
 		<h1>Subversive Project is Looking for a Sponsor</h1>
 		<p>
-			The Subversive project was started in 2005 as an open-source initiative of Polarion company. It was started as a small in-house project that aimed to help developers to work with SVN, but after a couple of years it was migrated to Eclipse as a fully-functional SVN team provider and is one of the most popular plug-ins in Eclipse ecosystem with hundreds of thousands of users all over the world. 
+			The Subversive project was started in 2005 as an open-source initiative of Polarion. It originated as a small in-house project aiming to help developers to work with SVN, and a few years later it migrated to Eclipse as a fully functional SVN team provider. Now, it is one of the most popular plug-ins in the Eclipse ecosystem with hundreds of thousands of users all over the world. 
 		</p>
 		<p>
-			Since the beginning of the project Subversive development and support was managed and sponsored by Polarion. Recently Polarion was acquired by another company, so it was decided to discontinue financial support of the project. The good news for Eclipse community is that the project can continue its life on Eclipse and the team of Subversive authors can continue the work on the project.
+			From the project beginning, Subversive development and support was managed and sponsored by Polarion. Recently, Polarion has been acquired by another company whose scope of interest does not include this project, so its financial support will be discontinued. The good news for the Eclipse community is that the project can stay on Eclipse and the team of the Subversive authors can continue working on the project.
 		</p>
 		<p>
-			To continue Subversive development the Subversive team of Eclipse committers is looking for funding and we are looking for a company that can sponsor Subversive development. The required budget is pretty low. The Subversive team will be glad to provide the additional information on a request, so please feel free to <a href="mailto:igor.vinnykov@polarion.com?subject=[Subversive sponsorship request]">contact us</a> if you would like to become the Subversive sponsor. 
+			To continue with the Subversive development, the Subversive team of Eclipse committers is looking for funding and for a company that could sponsor the Subversive development. The budget requirements are quite low. The Subversive team will be glad to provide additional information on request, so please feel free to <a href="mailto:igor.vinnykov@polarion.com?subject=[Subversive sponsorship request]">contact us</a> if you would like to become a Subversive sponsor. 
 		</p>
 		<p align="right">
 			Your Subversive Development Team
