diff --git a/index.html b/index.html
index 97f660e..2d7d500 100644
--- a/index.html
+++ b/index.html
@@ -293,7 +293,7 @@
 			  <div class="team-content">
 				<div class="team-name">Antonio Luciano</div>
 				<div class="team-role">
-				  <h4>Project Manager / Board Member</h4>
+				  <h4>Board Member / Project Manager</h4>
 				</div>
 				<div class="team-description"></div>
 			  </div>
@@ -554,7 +554,7 @@
         <div class="col-md-6 text-center about-info">
           <img class="img-circle text-center profile-img" src="images/bliss_opt_logo.png">
           <p class="text-center">We are a team of designers, developers, maintainers, and business professionals who work together to help achieve the dreams of our teammates and the Android Community. Our goal is to help provide a unique learning environment, using the FOSS
-            mentality, and not only train people how to make and monetize what they aspire, but also help provide unique business opportunities for already existing projects too. </p>
+            mentality, and not only train people how to make and monetize what they aspire to, but also help provide unique business opportunities for already existing projects as well. </p>
           <p class="text-center">If you are interested in joining our team, please fill out the form found here:
             <a href="https://goo.gl/forms/PdiaAj1PojosmehK2"></a>
           </p>
@@ -604,12 +604,12 @@
       <div class="row">
         <div class="text-center">
           <img class="img-circle text-center profile-img" src="images/bliss_opt_logo.png">
-          <p class="text-center">We are currently in the process of moving into a new era of Bliss. As a ROM team, we worked together to overcome some of the hardest obstacles that a ROM team could face. And in doing so, we have grown and acted as an example to other teams. This growth allowed us to grow into a family of ROM teams, helping to support one another in our innovative efforts, and also inspire work from other community members as well. </p>
-		  <p class="text-center">This growth allowed us to see many of the needs our fellow community members had, and sparked an idea to allow us all to succeed in the future. So, we decided to start our journey into making that happen, and are turning Bliss Family of ROMs into a nonprofit corporation, with the intent to enable the development community like never before. </p>
+          <p class="text-center">We are currently in the process of moving into a new era of Bliss. As a ROM team, we worked together to overcome some of the hardest obstacles that a ROM team could face. And in doing so, we have grown and acted as an example to other teams. This growth allowed us to grow into a family of ROM teams, helping to support one another in our innovative efforts, and inspire work from other community members in the process. </p>
+		  <p class="text-center">This growth allowed us to see many of the needs our fellow community members had, and sparked an idea to allow us all to succeed in the future. This inspired us to start our journey into making that happen, and we have turned Bliss Family of ROMs into a nonprofit corporation, with the intent to enable the development community like never before. </p>
 		  <p></p>
-		  <p class="text-center">Our Bliss Family projects can range from Applications, forks of other projects, ports, ROMs, API's, Services, etc. Most if not all of our Bliss Family projects will be Open Source too, allowing us to truly give back to the community as a team.  </p>
+		  <p class="text-center">Our Bliss Family projects include applications, ports, ROMs, API's, services, and forks of other projects. Most if not all of our Bliss Family projects will be Open Source, allowing us to truly give back to the community as a team.  </p>
           <p></p>
-          <p class="text-center">Or if you represent an already existing project and would like to join the Bliss Family, please fill out the form found here:
+          <p class="text-center">Or if you represent an existing project and would like to join the Bliss Family, please fill out the form found here:
           </p>
 		  <a class="btn btn-rounded family-projects--btn" href="https://goo.gl/kAb7ti" role="button">Join Bliss Family</a>
           
@@ -638,7 +638,7 @@
 				  <h4>Dark Style ROM, AOSP/CAF</h4>
 				</div>
 				<h4 class="family-description">
-				Desolation ROM is a great dark style rom, offering heavy optimizations along with a unique style.</h4>
+				Desolation ROM emphasizes performance, offering heavy optimizations along with a unique dark themed style.</h4>
 			  </div>
 			  <!-- /.family-content -->
 			</div>
@@ -664,7 +664,7 @@
 				  <h4>Xperia Style ROM, AOSP/CAF</h4>
 				</div>
 				<h4 class="family-description">
-				XOSP offers the unique stylings of Sony's Xperia line to AOSP/CAF devices, along with many welcomed features worth checking out.</h4>
+				XOSP offers the unique stylings of Sony's "Xperia" line to AOSP/CAF devices, combining open-source innovation with proven design and quality.</h4>
 			  </div>
 			  <!-- /.family-content -->
 			</div>
@@ -690,7 +690,7 @@
 				  <h4>AOSP/CAF ROM</h4>
 				</div>
 				<h4 class="family-description">
-				Not much info available at this time. Please check in later. </h4>
+				Currently pre-release, this project is progressing steadily and will soon have more details to share. Please check in later. </h4>
 			  </div>
 			  <!-- /.family-content -->
 			</div>
