diff --git a/orion/5.0/M2/images/50m2-edit-compare.png b/orion/5.0/M2/images/50m2-edit-compare.png
new file mode 100644
index 0000000..f2a0e43
--- /dev/null
+++ b/orion/5.0/M2/images/50m2-edit-compare.png
Binary files differ
diff --git a/orion/5.0/M2/images/50m2-find-file-filter.png b/orion/5.0/M2/images/50m2-find-file-filter.png
new file mode 100644
index 0000000..5ee2dab
--- /dev/null
+++ b/orion/5.0/M2/images/50m2-find-file-filter.png
Binary files differ
diff --git a/orion/5.0/M2/images/50m2-gerrit-push-branch.png b/orion/5.0/M2/images/50m2-gerrit-push-branch.png
new file mode 100644
index 0000000..9086031
--- /dev/null
+++ b/orion/5.0/M2/images/50m2-gerrit-push-branch.png
Binary files differ
diff --git a/orion/5.0/M2/images/50m2-push-review.png b/orion/5.0/M2/images/50m2-push-review.png
new file mode 100644
index 0000000..9602600
--- /dev/null
+++ b/orion/5.0/M2/images/50m2-push-review.png
Binary files differ
diff --git a/orion/5.0/M2/orion-news-M2.html b/orion/5.0/M2/orion-news-M2.html
index 5f5df98..f9c411e 100644
--- a/orion/5.0/M2/orion-news-M2.html
+++ b/orion/5.0/M2/orion-news-M2.html
@@ -50,41 +50,36 @@
 <p><img src="images/50m2-json-lint.png" alt="JSON syntax highlighting"/></p>
 
 <h3 id="gerrit">Improved Gerrit support</h3>
-Orion is steadily making progress towards support for <a href="https://code.google.com/p/gerrit/">Gerrit</a> workflows. In the current release the following features have been added:
+Orion is steadily making progress towards support for <a href="https://code.google.com/p/gerrit/">Gerrit</a> workflows. In the current release the following features have been added to make it easier to use Orion with Gerrit:
 <p>
 Support to attach a Gerrit change-id to your commits:
 </p>
 <p><img src="images/50m2-gerrit-changeid.png" alt="Gerrit change id in commit dialog"/></p>
 <p>
-Git push without tags. When pushing a change to Gerrit for review you don't want to push tags as well. The <b>Push</b> button now has a drop-down menu on the right that provides an option to push commits only.
+Git push without tags. When pushing a change to Gerrit for review you don't want to push tags as well. The <b>Push</b> button now has a drop-down menu on the right that provides a <b>Push Branch</b> option to push commits only.
 </p>
+<p><img src="images/50m2-gerrit-push-branch.png" alt="Push branch without tags"/></p>
+<p>
+Push for review. When a contributor wants to submit a proposed patch for review in Gerrit, they push to a special branch with the format <tt>refs/for/[branchName]</tt>. Previously Orion always assumed pushes occurred to <tt>heads</tt> branches. Now, when you select <b>Push</b> followed by <b>More</b>, you can enter a branch name such as <tt>refs/for/master</tt> to push a change for review that is intended for the <b>master</b> branch.
+</p>
+<p><img src="images/50m2-push-review.png" alt="Git push to Gerrit for review"/></p>
 
-	
-	</li>
-</ul>
+<h3 id="syntax-highlight">New pluggable syntax highlighting system</h3>
+The Orion editor has adopted a new syntax highlighting framework, designed specifically for Orion. Notable improvements include better performance, and built in support for more languages (currently JavaScript, JSON, XML, CSS, HTML, Java, PHP, Python, Ruby, and YAML). Syntax highlighting for additional languages can be provided by plugins. In addition, the syntax highlighting framework can be used with the <a href="http://git.eclipse.org/c/orion/org.eclipse.orion.client.git/tree/bundles/org.eclipse.orion.client.editor/web/examples/editor/edit.html?id=e06ad033cf09495b71bef4f0255d397ede2b2971">standalone Orion editor</a>, which is handy if you want a smaller package for embedding in your web application. 
 
-cloud foundry integration
-- cf logs viewer
+For more details on the new syntax highlighting framework, checkout this recent <a href="http://planetorion.org/news/2014/02/orion-5-0-syntax-styling-revisited/">blog post</a> on Planet Orion.
 
-find file filtered on specific folders (424130)
+<h3 id="filter-folder-in-find">Filter by folder when searching for files</h3>
+When using the Orion <b>Find File</b> command, you can now filter the results list based on keywords in the directory path by specifying a second search term in the find box. This is very handy when there are a large number of duplicates of the same file name and you want to quickly narrow down to a particular match.
 
-cannot edit during compare with each other
+<p><img src="images/50m2-find-file-filter.png" alt="Filtering by folder in find file"/></p>
 
+<h3 id="edit-compare">Edit while comparing files</h3>
+When you select two files and pick <b>Compare with each other</b> from the context menu, the resulting compare page now allows you to edit both files directly within the compare editor. Unsaved changes are indicated by an asterisk next to the name, and <b>Save</b> buttons appear above each editor. Saving changes on either side will cause the comparisons to be updated immediately.
 
+<p><img src="images/50m2-edit-compare.png" alt="Edit in compare page"/></p>
 
-Gerrit support:
-change id in Orion commit for Gerrit (425272)
-git push without tags https://bugs.eclipse.org/bugs/show_bug.cgi?id=425242
-push to /refs/for
-
-Syntax highlighting in standalone editor (http://git.eclipse.org/c/orion/org.eclipse.orion.client.git/tree/bundles/org.eclipse.orion.client.editor/web/examples/editor/edit.html?id=e06ad033cf09495b71bef4f0255d397ede2b2971)
-
-
-pluggable syntax highlighting
- https://bugs.eclipse.org/bugs/show_bug.cgi?id=421274
-
-
-
+That's all for the current milestone! Make sure you also check out the <a href="http://planetorion.org/news/2013/12/orion-5-0-m1-new-and-noteworthy/">5.0 M1</a> news for other features added earlier in the 5.0 release.
 
 </body>
 </html>
