diff --git a/platform/4.4/final/default_style.css b/platform/4.4/final/default_style.css
new file mode 100644
index 0000000..e485725
--- /dev/null
+++ b/platform/4.4/final/default_style.css
@@ -0,0 +1,15 @@
+p, table, td, th {  font-family: verdana, arial, helvetica, geneva; font-size: 10pt}
+pre {  font-family: "Courier New", Courier, mono; font-size: 10pt}
+h2 { font-family: verdana, arial, helvetica, geneva; font-size: 18pt; font-weight: bold ; line-height: 14px}
+code {  font-family: "Courier New", Courier, mono; font-size: 10pt}
+sup {  font-family: verdana, arial, helvetica, geneva; font-size: 10px}
+h3 {  font-family: verdana, arial, helvetica, geneva; font-size: 14pt; font-weight: bold}
+li {  font-family: verdana, arial, helvetica, geneva; font-size: 10pt}
+h1 {  font-family: verdana, arial, helvetica, geneva; font-size: 24pt; font-weight: bold}
+body {  font-family: verdana, arial, helvetica, geneva; font-size: 10pt; margin-top: 5mm; margin-left: 3mm}
+.indextop { font-size: x-large; font-family: verdana, arial, helvetica, sans-serif; font-weight: bold}
+.indexsub { font-size: xx-small; font-family: verdana, arial, helvetica, sans-serif; color: #8080FF}
+a.bar:link {  text-decoration: none; color: #FFFFFF}
+a.bar:visited {  color: #FFFFFF; text-decoration: none}
+a.bar:hover {  color: #FFFFFF; text-decoration: underline}
+a.bar {  color: #FFFFFF}
diff --git a/platform/4.4/final/eclipse-news-part1.html b/platform/4.4/final/eclipse-news-part1.html
new file mode 100644
index 0000000..b759e12
--- /dev/null
+++ b/platform/4.4/final/eclipse-news-part1.html
@@ -0,0 +1,228 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta name="copyright" content="Copyright (c) Eclipse contributors and others 2014. This page is made available under license. For full details, see the LEGAL section in the documentation that contains this page."/>
+<meta http-equiv="Content-Language" content="en-us"/>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+<link rel="stylesheet" href="default_style.css" charset="ISO-8859-1" type="text/css"/>
+<style type="text/css">
+table.news td {border-top: solid thin black;}
+table.news tr {vertical-align: top;}
+table.news tr td.section {font-size: 20px; font-weight: bold;}
+table.news tr td.title {vertical-align: top; width: 30%; font-weight: bold;}
+table.news tr td.content {vertical-align: top; width: 70%;}
+</style>
+<title>Eclipse Project Luna - New and Noteworthy</title>
+</head>
+
+<body>
+<h2>Platform and Equinox</h2>
+
+<!-- ****************** START OF N&N TABLE ****************** -->
+<table class="news" cellpadding="10" cellspacing="0">
+<tbody>
+  <tr id="split-editors"> 
+    <td class="title">Split editors</td>
+    <td class="content">Do you ever find yourself working in a large file and need to view or edit multiple sections at once?
+     <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=8009">Finally</a>, Eclipse supports split editors!
+     You can now split / unsplit the currently active editor. Just use one of the new key bindings supplied in Luna:
+     <ul>
+     <li><b>Ctrl+_</b> splits the editor one above the other</li>
+     <li><b>Ctrl+{</b> splits the editor side by side</li>
+     <li>Re-applying the command to an already split editor reverts it to only have one pane.</li>
+     </ul>
+    <p><img src="images/split_editors.png" alt=""/></p>
+    <p>Try it out on <i>your</i> favorite editor!</p>
+    </td>
+  </tr>
+
+  <tr id="darktheme">
+    <td class="title">Dark theme</td>
+    <td class="content">
+      A new dark window theme has been introduced. This popular community theme demonstrates the power of the underlying 
+      Eclipse 4 styling engine. You can enable it from the <b>General &gt; Appearance</b> preference page. Plug-ins can contribute
+      extensions to this theme to style their own specific views and editors to match the window theme.
+      <p><img src="images/darktheme.png" alt=""/></p>
+    </td>
+  </tr>
+  
+  <tr id="quick-access">
+    <td class="title">Quick access as a popup</td>
+    <td class="content">
+      If you find the <b>Quick Access</b> field in the toolbar takes up too much space, you can now hide it.
+      From the context menu in the toolbar, select <b>Hide</b>.
+      <p><img src="images/quick-access-hide.png" alt="Hiding quick access"/></p>
+      <p>Once hidden, pressing <b>Ctrl+3</b> will instead show a popup dialog.</p>
+      <p><img src="images/quick-access-dialog.png" alt="Quick access dialog"/></p>
+    </td>
+  </tr>
+    
+  
+  <tr id="minimized-stack-option"> 
+    <td class="title">New layout for minimized views</td>
+    <td class="content">
+    Minimized views now have two different display modes:
+    <ul>
+    <li>Use Overlays: This is the current mode where showing a minimized view 
+    opens it in a 'fly out', overlaying part of the main window.</li>
+    <li>Show in the Original Location: This is a new mode that will temporarily put the
+    stack back into the perspective while one of its views is active. This
+    has the advantage that the minimized view won't overlay anything in the
+    current presentation (e.g. your editor...).</li>
+    </ul>
+    <p>
+    To access the new mode, right-click on the <b>Restore</b> button
+    of a minimized stack and select the <b>Show in the Original Location</b> menu item (see image
+    below). Note that this change is global, so once it's set, all minimized
+    views will use the selected mode.</p>
+    <p><img src="images/restore-btn.png" alt=""/></p>
+
+    <p>Here's what the current mode looks like:</p>
+    <p><img src="images/use-overlays.png" alt=""/></p>
+    <p>Here's what the new mode looks like. Note how the editor
+    has been pushed to the right rather than being obscured:</p>
+    <p><img src="images/no-overlays.png" alt=""/></p>
+    <p>
+    We're really interested in your feedback on this! The initial response
+    has been positive enough that we're considering making the non-overlay
+    mode the default. What do you think? (Post your comments <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=426556">here</a>).
+    </p>
+    </td>
+  </tr>
+
+  <tr id="reorder-perspectives"> 
+    <td class="title">Perspective re-ordering</td>
+    <td class="content">
+      You can now drag and drop the items in the perspective switcher to change the order of your open perspectives.
+    <p><img src="images/move-persp-items.png" alt="moveitems"/></p>
+    </td>
+  </tr>
+  
+  <tr id="protect-option">
+    <td class="title">New protection options for Eclipse</td>
+    <td class="content">
+     	A new launcher parameter named <b>-protect</b> has been introduced and it accepts the following values:
+		<ul>
+		<li><b>-protect root</b> can be used to prevent Eclipse from being started as a root user, 
+		either directly or via programs that run with administrative privileges like 'sudo'. 
+		This option is currently implemented only on Linux/UNIX based platforms.</li>
+		<li><b>-protect master</b> can be used to prevent starting of the master instance in a shared install configuration.
+		This option can be used on all platforms supported by Eclipse.</li>	
+		</ul>
+		<p>The above options can either be set in the launcher's <b>.ini</b> file or can be used directly from the command line (e.g eclipse -protect root).</p>
+    </td>
+  </tr>
+  
+  <tr id="signed-executables">
+    <td class="title">Signed SDK Executables (for Windows and Mac)</td>
+    <td class="content">We now provide signed Windows and Mac executables for the Eclipse SDK.
+      This gets rid of those operating system warnings about running untrusted software, and
+      saves you from having to disable "Gatekeeper" or other security measures to run Eclipse.
+    </td>
+  </tr>
+
+  <tr id="import-filter-conflicts"> 
+    <td class="title">Filter conflicting projects during import</td>
+    <td class="content">
+      When importing existing projects, you can now filter out any
+      conflicting projects (projects that are already present in your workspace).
+      <p><img src="images/import-filter-conflicts-before.png" alt="filter conflicting projects"/></p>
+    </td>
+  </tr>
+
+  <tr id="import-as-project">
+    <td class="title">Import as Project</td>
+    <td class="content">
+      In the <b>Project Explorer</b>, a folder that contains a <code>.project</code> file and whose related project
+      isn't already in the workspace now shows an <b>Import as Project</b> context menu entry that imports the folder
+      into the workspace as an existing project.
+      <p><img src="images/import-as-project.png" alt=""/></p>
+    </td>
+  </tr>
+  
+  <tr id="show-in-system-explorer">
+    <td class="title">Show In System Explorer</td>
+    <td class="content">
+      If you select a resource and right click, there is now a <b>Show In &gt; System Explorer</b> context menu entry
+      that will open the folder containing that resource in your system's file explorer. 
+      <p><img src="images/shown-in-system-explorer.png" alt="menu popup with Show In System Explorer"/></p>
+      The command for launching the system explorer can be configured on the 
+      <strong>General &gt; Workspace</strong>
+      preference page.
+    </td>
+  </tr>
+  
+   <tr id="launch-options">
+    <td class="title">Updated launch options</td>
+    <td class="content">
+      The default preference for the fall-back behavior of context-sensitive launching has been changed to launch the previous application.
+      <p>
+      <img src="images/launch-options.png" alt=""/>
+      </p>
+      <p>
+      Existing workspaces that use the "Always launch the previously launched application" option are not affected by this change.
+      </p>
+    </td>
+  </tr>
+  
+  <tr id="ant-view-collapse-all">
+    <td class="title">Collapse All in Ant view</td>
+    <td class="content">
+    	The Ant view now supports the <b>Collapse All</b> command:
+    	<p>
+    	<img src="images/ant-view.png" alt="The Ant view showing the collapse all action"/>
+    	</p>
+    </td>
+  </tr>
+
+  <tr id="ide-icons">
+    <td class="title">Platform icons converted to png files</td>
+    <td class="content">
+      Based on a community contribution, lots of of the existing GIF icons in the Eclipse platform have been replaced by PNG icons.
+      This makes Eclipse icons look better on a dark background, as for example the toolbar on Mac OS X or on a dark theme.
+      <p><img src="images/iconupdate.png" alt="New platform icons"/></p>
+    </td>
+  </tr>
+ 
+  <tr id="appmodel-perspective"> 
+    <td class="title">Support for dynamic icon changes</td>
+    <td class="content">
+      The workbench now supports dynamically changing icons at runtime. This means that workbench themes (such as the dark theme), can
+      introduce different icons, and these changes will take effect without requiring a restart.
+    </td>
+  </tr>
+  
+  <tr id="os-ubuntu"> 
+    <td class="title">Ubuntu menu integration </td>
+    <td class="content">
+       In cooperation with Canonical, the Eclipse Platform team has been working on improving the presentation of Eclipse menus in Ubuntu, which had
+       problems in Ubuntu 13.04 and 13.10. These problems are now resolved in Ubuntu 14.04, where Eclipse menus now display nicely.
+    </td>
+  </tr>
+  
+  <tr id="swt-xulrunner24"> 
+    <td class="title">SWT Browser now supports XULRunner 24.x</td>
+    <td class="content">
+        An SWT Browser created with style <code>SWT.MOZILLA</code> can now be used with the XULRunner 24.x runtime.
+    </td>
+  </tr>
+  
+  <tr id="set-gtk-version"> 
+    <td class="title">Set the GTK+ version to be used by Eclipse via the launcher</td>
+    <td class="content">
+        The launcher parameter <b>--launcher.GTK_version</b> can now be used to choose which version of GTK+ will be used by Eclipse on Linux. 
+        The acceptable values are:<ul>
+        <li><b>2</b> for GTK+ 2.x </li>
+        <li><b>3</b> for GTK+ 3.x </li></ul>
+        <p>Note that setting the GTK+ version via this parameter takes precedence over setting the SWT_GTK3 environment variable. 
+        See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=434619">bug 434619</a> for more details.</p>
+    </td>
+  </tr>
+ 
+  <!-- ****************** END OF N&N TABLE ****************** -->
+</tbody>
+</table>
+
+<p align="center"><font color="#808080">Previous</font>&nbsp;&nbsp;&nbsp;&nbsp; <a href="eclipse-news-part2.html">Next</a></p>
+</body>
+</html>
diff --git a/platform/4.4/final/eclipse-news-part2.html b/platform/4.4/final/eclipse-news-part2.html
new file mode 100644
index 0000000..c69f9cb
--- /dev/null
+++ b/platform/4.4/final/eclipse-news-part2.html
@@ -0,0 +1,382 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta name="copyright" content="Copyright (c) Eclipse contributors and others 2014. This page is made available under license. For full details see the LEGAL in the documentation that contains this page."/>
+<meta http-equiv="Content-Language" content="en-us"/>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+<link rel="stylesheet" href="default_style.css" charset="UTF-8" type="text/css"/>
+<style type="text/css">
+table.news td {border-top: solid thin black;}
+table.news tr {vertical-align: top;}
+table.news tr td.section {font-size: 20px; font-weight: bold;}
+table.news tr td.title {vertical-align: top; width: 30%; font-weight: bold;}
+table.news tr td.content {vertical-align: top; width: 70%;}
+ul {padding-left: 13px;}
+</style>
+<title>Eclipse Project Luna - New and Noteworthy</title>
+</head>
+
+<body>
+<h2>Java development tools</h2>
+<ul>
+	<li><a href="#JavaEditor">Java Editor</a></li>
+	<li><a href="#JavaFormatter">Java Formatter</a></li>
+	<li><a href="#JavaCompiler">Java Compiler</a></li>
+	<li><a href="#JavaViewsAndDialogs">Java Views and Dialogs</a></li>
+	<li><a href="#Debug">Debug</a></li>
+	<li><a href="#JUnit">JUnit</a></li>
+</ul>
+<!-- *************************************************** -->
+
+<table class="news" cellpadding="10" cellspacing="0" summary="New and noteworthy items">
+<tbody>
+
+  <!-- ******************* Java Editor ************************************* -->
+  <tr>
+    <td id="JavaEditor" class="section" colspan="2">
+    <h2>Java Editor </h2>
+    </td>
+  </tr>
+  
+  <tr id="convert-compliance-JRE-1.8">
+	<td class="title"><img src="images/java8.png" alt=""/> Quick fix to change project compliance and JRE to 1.8</td>
+	<td class="content">
+		A quick fix <b>Change project compliance and JRE to 1.8</b> is provided to quickly change the current project to be compatible with Java 8.
+		<p><img src="images/quickfix-change-compliance-1.8.png" alt=""/></p>
+	</td>
+  </tr>
+  
+  <tr id="migrate-anonymous-lambda">
+	<td class="title"><img src="images/java8.png" alt=""/> Migrate anonymous class creations to lambda expressions and back</td>
+	<td class="content">
+		You can convert anonymous class creations to lambda expressions (and back) by invoking the <b>Quick Assists (Ctrl+1)</b>:
+		<ul>
+		<li>Convert to lambda expression</li>
+      	<li>Convert to anonymous class creation</li>
+      	</ul>
+		<p>Before:</p>
+		<p><img src="images/convert-to-lambda-1.png" alt="anonymous class with a 1-line method body"/></p>
+		<p>After the Quick Assist (<b>Ctrl+1</b>), the 6 lines are condensed into 1:</p>
+		<p><img src="images/convert-to-lambda-2.png" alt="lambda expression -- everything on 1 line"/></p>
+		Or invoke <b>Source &gt; Clean Up...</b>, use a custom profile, and on the <b>Configure...</b> dialog select <b>Convert functional interface instances</b> 
+		and <b>Use lambda where possible</b> on the <b>Code Style</b> tab.
+	</td>
+  </tr>
+  
+  <tr id="change-body-block-to-expression">
+	<td class="title"><img src="images/java8.png" alt=""/> Change lambda expression body block to expression and back</td>
+	<td class="content">
+		You can convert the body of a lambda expression from block to expression (and back) by invoking the <b>Quick Assists (Ctrl+1)</b>:
+		<ul>
+      	<li>Change body expression to block
+		<p><img src="images/expression-to-block.png" alt="Change body expression to block"/></p></li>
+		<li>Change body block to expression 
+		<p><img src="images/block-to-expression.png" alt="Change body block to expression"/></p></li>
+      	</ul>
+	</td>
+  </tr>
+  
+  <tr id="view-method-implemented">
+	<td class="title"><img src="images/java8.png" alt=""/> View the method implemented by the functional interface instances</td>
+	<td class="content">
+		To view the method implemented by the functional interface instances, you can hover on:
+		<ul>
+			<li>'<code>-&gt;</code>' in a lambda expression</li>
+		</ul>
+		<p><img src="images/hover-on-lambda.png" alt="Hover on '->' in lambda to show functional method"/></p>
+		<ul>
+      		<li>'<code>::</code>' in a method reference</li>
+      	</ul>
+      	<p><img src="images/hover-on-method-reference.png" alt="Hover on '::' in method reference to view functional method"/></p>
+	</td>
+  </tr>
+  
+  <tr id="navigate-method-declaration">
+	<td class="title"><img src="images/java8.png" alt=""/> Navigate to the functional method declaration</td>
+	<td class="content">
+		To navigate to the functional method declaration, hold <b>Ctrl</b>, 
+		move the mouse pointer over '<code>-&gt;</code>' or '<code>::</code>', and click the hyperlink.
+		<ul>
+			<li>'<code>-&gt;</code>' in a lambda expression:</li>
+		</ul>
+		<p><img src="images/navigate-from-lambda.png" alt=""/></p>
+		<ul>
+      		<li>'<code>::</code>' in a method reference:</li>
+      	</ul>
+      	<p><img src="images/navigate-from-method-reference.png" alt=""/></p>
+	</td>
+  </tr>
+  
+  
+  <tr id="quickfix-create-for-loop">
+    <td class="title">Quick Fixes to create 'for' loops</td>
+    <td class="content">
+      A set of new quick fixes can create <code>for</code> loops that iterate over a given expression.
+      <p>
+      For arrays:
+      </p>
+      <ul>
+      <li>Create an enhanced <code>for</code> loop</li>
+      <li>Create a <code>for</code> loop using an index</li>
+      </ul>
+      <p><a href="images/quickfix-create-for-loop-array.txt"><img src="images/quickfix-create-for-loop-array.png" alt=""/></a></p>
+      For <code>Collection</code>s:
+      <ul>
+      <li>Create an enhanced <code>for</code> loop</li>
+      <li>Create a <code>for</code> loop using an <code>Iterator</code></li>
+      </ul>
+      For <code>List</code>s:
+      <ul>
+      <li>Create a <code>for</code> loop using an index and <code>get(i)</code></li>
+      </ul>
+      <p><a href="images/quickfix-create-for-loop-collection.txt"><img src="images/quickfix-create-for-loop-collection.png" alt=""/></a></p>
+    </td>
+  </tr>
+  
+  <tr id="syntax-color">
+    <td class="title">Enabled coloring of variables</td>
+    <td class="content">
+     Parameter variables and local variables are now colored by default:
+     <p><img src="images/variable-coloring.png" alt=""/></p>
+     This can be disabled or configured with different colors and styles on the <b>Java &gt; Editor &gt; Syntax Coloring</b> preference page.
+    </td>
+  </tr>
+  
+  <!-- ******************* Java Formatter ************************************* -->
+  <tr>
+    <td id="JavaFormatter" class="section" colspan="2">
+    <h2>Java Formatter </h2>
+    </td>
+  </tr>
+  
+  <tr id="formatter-for-lambda">
+    <td class="title"><img src="images/java8.png" alt=""/> Option to control lambda code formatting</td>
+    <td class="content">
+     New options are provided in the formatter page to configure the formatting of lambda expressions.
+     <ul>
+     <li>Configure the position of braces within lambda body:
+     <p><img src="images/formatter-braces-lambda.png" alt=""/></p></li>
+     <li>Configure whitespace before and after the arrow operator of lambda:
+     <p><img src="images/formatter-whitespace-lambda.png" alt=""/></p></li>
+     </ul>
+     <p>Formatter profiles can be configured on the <b>Java &gt; Code Style &gt; Formatter</b> preference page. </p>
+    </td>
+  </tr>
+  
+  
+  <!-- ******************* Java Compiler ************************************* -->
+  <tr>
+    <td id="JavaCompiler" class="section" colspan="2">
+    <h2>Java Compiler</h2>
+    </td>
+  </tr>
+  
+  <tr id="java-8">
+    <td class="title"><img src="images/java8.png" alt=""/> Java 8</td>
+    <td class="content">
+      <a href="http://docs.oracle.com/javase/8/">Java&trade; 8</a> is here, and JDT fully supports it.
+      The Eclipse compiler for Java (ECJ) implements all the new Java 8 
+			<a href="http://docs.oracle.com/javase/8/docs/technotes/guides/language/enhancements.html">language enhancements</a>.
+    </td>
+  </tr>
+  
+   <tr id="generate-methodparameters">
+    <td class="title"><img src="images/java8.png" alt=""/> Option to control generation of method parameter attributes in class files</td>
+    <td class="content">
+     In 1.8 compliance mode, you can enable the generation of method parameter attributes in class files:
+     <p><img src="images/store-method-parameters.png" alt="Option to store method parameters in class files"/></p>
+    </td>
+  </tr>
+  
+   <tr id="contrib-jres">
+    <td class="title">Contributed VMs are more recognizable</td>
+    <td class="content">
+    	You can't remove VMs that have been contributed to Eclipse via the <code>org.eclipse.jdt.launching.vmInstalls</code> extension point.This
+    	fact is now more recognizable:
+    	<p>
+    	<img src="images/contrib-vm.png" alt="The Installed JREs preference page showing a contributed VM install"/>
+    	</p>
+    </td>
+  </tr>
+  
+  <tr id="null-types-annotations">
+  	<td class="title"><img src="images/java8.png" alt=""/> Null type annotations</td>
+  	<td class="content">
+  		With the advent of "type annotations" as introduced in Java 8 via JSR 308, JDT takes null pointer analysis to the next level.
+  		<p>
+  		This feature requires a set of nullness annotations declared with <code>@Target({TYPE_USE})</code>,
+  		which JDT ships as version 2.0.0 of the 
+  		<a href="http://help.eclipse.org/luna/topic/org.eclipse.jdt.doc.isv/reference/api/org/eclipse/jdt/annotation/package-summary.html"
+  			><code>org.eclipse.jdt.annotation</code></a> bundle.
+  		</p>
+  		<p>
+  		With these annotations, nullness can be considered as an intrinsic part of the type system,
+  		allowing the compiler to perform null type checking along with each task of type checking.
+  		This is a major step towards systematically detecting all possible NullPointerExceptions
+  		in a program.
+  		</p>
+  		<p>
+  			The most obvious benefit is in annotating type arguments of generic types:
+  		</p>
+  		<p>
+  			<a href="images/generics_unsafeSingleton.txt"><img src="images/generics_unsafeSingleton.png" alt="null annotated generics (1)"/></a>
+  		</p>
+  		<p>
+  			The example shows diverse usage of null-annotated type arguments.
+  			While most of the code has been checked to be safe, the compiler directly points out
+  			one obvious bug: <code>in</code> is declared with a nullable type, and hence cannot be
+		 	passed into <code>add()</code> of a list of nonnull elements.
+  		</p>
+  		<p>
+  			<a href="images/generics_unsafePredicateCall.txt"><img src="images/generics_unsafePredicateCall.png" alt="null annotated generics (2)"/></a>
+  		</p>
+  		<p>
+  			In this variant an error is detected by recognizing that <code>string</code> has been extracted
+  			from a list that may contain nulls, hence passing this value into a Predicate expecting a
+  			nonnull argument is wrong.
+ 		</p>
+  		<p>
+  		For a comprehensive description of type annotation based null analysis see the <a href="http://help.eclipse.org/luna/topic/org.eclipse.jdt.doc.user/tasks/task-using_null_type_annotations.htm">online help</a>.
+  		</p>
+  		<p>
+  		While potentially, the new approach could lead to an explosion of the number of annotations,
+  		also <a href="http://help.eclipse.org/luna/topic/org.eclipse.jdt.doc.isv/reference/api/org/eclipse/jdt/annotation/NonNullByDefault.html"
+  			><code>@NonNullByDefault</code></a> has become much more powerful, such that programs not using
+  		any null values can be fully checked with just a single annotation:
+  		</p>
+  		<p>
+  			<a href="images/generics_defaults.txt"><img src="images/generics_defaults.png" alt="null annotated generics (2)"/></a>
+  		</p>
+  		<p>
+  			The <code>@NonNullByDefault</code> annotation in line 7 affects most types in the example
+  			(with the exception of local variables, which are inferred using flow analysis).
+  			The compiler directly points out the single bug in the <code>safe_</code> methods:
+  			the type argument of list <code>result</code> defaults to '<code>@NonNull String</code>',
+  			hence passing null to its <code>add()</code> method is now wrong.
+  		</p>
+  		<p>
+  			In line 27 all null-defaults are canceled for the scope of method <code>unprotectedClient()</code>.
+  			Here we simulate the interface between un-annotated (legacy) code and code governed
+  			by <code>@NonNullByDefault</code>. We can observe that all arguments and local variables
+  			from the legacy code require unchecked conversions when being passed into the annotated code.
+  			In particular note that <code>myStrings</code> lacks two annotations required by the method
+  			<code>safeFilter()</code>: the List should be nonnull, and so should be its type argument.  			
+  		</p>
+  	</td>
+  </tr>
+
+  <tr id="migrating-null-annotations"> 
+    <td class="title"><img src="images/java8.png" alt=""/> Migrating projects using null annotations for use in Luna</td>
+    <td class="content">
+  		The switch from declaration annotations (Java 5) to null type annotations (Java 8)
+  		brings a few unavoidable incompatibilities. Developers already using null annotations
+  		are advised to carefully read the <a href="http://help.eclipse.org/luna/topic/org.eclipse.jdt.doc.user/tasks/task-using_null_type_annotations.htm#compatibility">compatibility notes</a>.
+  		<p>
+  		Main points to observe:
+  		</p>
+  		<dl>
+  		<dt><a href="http://help.eclipse.org/luna/topic/org.eclipse.jdt.doc.user/tasks/task-using_null_type_annotations.htm#compatibility_configuration">Project configuration</a></dt>
+  		<dd>No matter if you are adopting null type annotations or continue to use old-style null annotations:
+  			always refer to the <code>org.eclipse.jdt.annotation</code> bundle using a suitable version range, 
+  			either <code>[1.1.0,2.0.0)</code> for declaration annotations or <code>[2.0.0,3.0.0)</code> for type annotations.
+  			This is important, because Eclipse now ships with both versions of the annotation bundle.<br/>
+  			As an alternative, OSGi/plug-in projects may use a 
+  			<a href="http://help.eclipse.org/luna/topic/org.eclipse.pde.doc.user/guide/tools/file_wizards/new_target_definition.htm">target definition</a>
+  			 for explicitly selecting the appropriate version of the annotation bundle.</dd>
+  		<dt><a href="http://help.eclipse.org/luna/topic/org.eclipse.jdt.doc.user/tasks/task-using_null_type_annotations.htm#compatibility_syntax">Syntax changes</a></dt>
+  		<dd>When migrating to null type annotations, your code may need to be changed if you have null annotations
+  			attached to an array type or to a qualified type reference. The latter may simply create a new
+  			compile error, while the former implicitly changes its meaning.</dd>
+  		</dl>
+  	</td>
+  </tr>
+
+  <tr id="ecj-needs-1.5"> 
+    <td class="title">ECJ requires 1.6 JRE</td>
+    <td class="content">
+     The JDT Core project has moved to Java 1.6 compliance level. This means the command line compiler now requires JRE 1.6 or above to run.
+    </td>
+  </tr>
+  
+   <tr id="man-page-batch-compiler">
+    <td class="title">A man page is available for ECJ batch compiler</td>
+    <td class="content">
+    	A UNIX like man page is available for the batch compiler. This man page essentially lists down the options and the corresponding usage information as found in this 
+    	<a href="http://help.eclipse.org/luna/topic/org.eclipse.jdt.doc.user/tasks/task-using_batch_compiler.htm">section</a>.
+    	<p>Information in the man file can be read by the command "man &lt;path_to_ecj.1&gt;"  in command prompt mode.</p>
+    </td>
+  </tr>
+ 
+  <!-- ******************* Java Views and Dialogs ************************************* -->
+  <tr>
+    <td id="JavaViewsAndDialogs" class="section" colspan="2">
+    <h2>Java Views and Dialogs</h2>
+    </td>
+  </tr>
+  
+  <tr id="search-limit-method-reference-expressions">
+    <td class="title"><img src="images/java8.png" alt=""/> Option to fine-grain Java search to limit to method reference expressions</td>
+    <td class="content">
+     The Java search for method and constructor can now be limited to method reference expressions.
+     <p>This option can be configured by clicking the hyperlink next to <b>Search &gt; Java Search &gt; Limit To &gt; Match locations</b>:</p>
+     <p><img src="images/search-limitto-method-reference-expression.png" alt=""/></p>
+    </td>
+  </tr>
+  
+    
+  <!-- *********************** Debug ******************************** -->
+  <tr>
+    <td id="Debug" class="section" colspan="2">
+    <h2>Debug</h2>
+    </td>
+  </tr>  
+  
+   <tr id="java8-debug-support">
+  	<td class="title"><img src="images/java8.png" alt=""/> Java 8 debug support</td>  	
+  	<td class="content">
+  		Java Debugger has been enhanced to support Java 8 key features like:
+  		<ul>
+  		<li>Evaluating expressions and variables from the context of interface methods</li>
+  		<li>Java Application can now be executed from the static main method in interface (without <b>public</b> modifier also)</li>
+  		<li>Breakpoints can be added inside lambda expressions</li>  		
+  		</ul>
+  		See <a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;classification=Eclipse&amp;component=Debug&amp;list_id=9280044&amp;product=JDT&amp;query_format=advanced&amp;resolution=FIXED&amp;short_desc=[1.8]&amp;short_desc_type=allwordssubstr">
+  		here </a>for details on debugger enhancements.
+  	</td>
+  </tr>
+  
+  <tr id="improved-hcr">
+  	<td class="title">Improved HCR for member types</td>  	
+  	<td class="content">
+  		Hot Code Replace (HCR) has been improved in the Java debugger to ensure the correct method is dropped to
+  		in member types (inner / anonymous / local classes).
+  		<p>
+  		For more information see the <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=409023">bugzilla entry</a>.
+  		</p>
+  	</td>
+  </tr>
+     
+  
+ 
+  <!-- ******************* JUnit ************************************* -->
+  <tr>
+    <td id="JUnit" class="section" colspan="2">
+    <h2>JUnit</h2>
+    </td>
+  </tr>
+    
+  <tr id="junit-failure-trace-font">
+    <td class="title">Failure trace font for the JUnit view</td>
+    <td class="content">
+     The font for the failure trace in the JUnit view is now configurable on the <b>General &gt; Appearance &gt; Colors and Fonts</b> preference page.
+     <p><img src="images/junit-failure-trace-font.png" alt=""/></p>
+    </td>
+  </tr>
+ 
+    <!-- ****************** END OF N&N TABLE ****************** -->
+</tbody>
+</table>
+
+<p align="center"><a href="eclipse-news-part1.html">Previous</a>&nbsp;&nbsp;&nbsp;&nbsp; <a href="eclipse-news-part3.html">Next</a></p>
+</body>
+</html>
\ No newline at end of file
diff --git a/platform/4.4/final/eclipse-news-part3.html b/platform/4.4/final/eclipse-news-part3.html
new file mode 100644
index 0000000..7fe7f4d
--- /dev/null
+++ b/platform/4.4/final/eclipse-news-part3.html
@@ -0,0 +1,569 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta name="copyright" content="Copyright (c) Eclipse contributors and others 2014. This page is made available under license. For full details, see the LEGAL section in the documentation that contains this page."/>
+<meta http-equiv="Content-Language" content="en-us"/>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+<link rel="stylesheet" href="default_style.css" charset="UTF-8" type="text/css"/>
+<style type="text/css">
+table.news td {border-top: solid thin black;}
+table.news tr {vertical-align: top;}
+table.news tr td.section {font-size: 20px; font-weight: bold;}
+table.news tr td.title {vertical-align: top; width: 30%; font-weight: bold;}
+table.news tr td.content {vertical-align: top; width: 70%;}
+</style>
+<title>Eclipse Project Luna - New and Noteworthy</title>
+</head>
+
+<body>
+<h2>Platform and Equinox API</h2>
+<ul>
+	<li><a href="#Platform">Platform Changes</a></li>
+	<li><a href="#Equinox">Equinox Changes</a></li>
+	<li><a href="#SWT">SWT Changes</a></li>
+</ul>
+
+<!-- ****************** START OF N&N TABLE ****************** -->
+<table class="news" cellpadding="10" cellspacing="0">
+<tbody>
+  <!-- ******************** Platform ********************** -->
+  <tr>
+    <td id="Platform" class="section" colspan="2"><h2>Platform Changes</h2></td>
+  </tr>
+  
+   <tr id="e4-views-1">
+    <td class="title">Contribute e4 Views into the IDE</td>
+    <td class="content">
+      Native e4 views can now be contributed to the Eclipse workbench via extension point.
+      The <code>org.eclipse.ui.views</code> extension point now supports an <code>e4view</code>
+      element for declaring a new view for the IDE whose implementation
+      is done in the e4 style (i.e. an annotated POJO).
+      <p>
+        <img src="images/new-e4view-extension.png" alt="new extension"/>
+      </p><p>
+        The new type of extension is identical to the original 'view' except for relaxing the
+        requirement that the 'class' implement IViewPart.
+      </p><p>
+        For those that are unaware of the e4 way of coding, here's what the implementation of an e4 view
+        looks like:
+      </p>
+      <pre>
+import javax.annotation.PostConstruct;
+import org.eclipse.e4.ui.di.Focus;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+
+public class RealE4View {
+	Label label;
+
+	@PostConstruct
+	void createView(Composite parent) {
+		label = new Label(parent, SWT.BORDER);	
+		label.setText("Testing");
+	}
+
+	@Focus
+	void setFocus() {
+		label.setFocus();
+	}
+}
+      </pre>
+      <p>
+        Note how it's a simple Java object (POJO) and how few dependencies it has; this has 
+        already proven itself as a far more convenient way to write the code and has great 
+        advantages in testing (because of its few dependencies).
+      </p>
+    </td>
+  </tr>
+      
+  <tr id="css-bridge"> 
+    <td class="title">CSS bridge</td>
+    <td class="content">
+      The Eclipse 4 CSS-based styling engine has been connected to the classic Eclipse platform theme APIs through a new
+      mechanism called the <i>CSS bridge</i>. This support enables a number of new user cases:
+	 <ul>
+		<li>
+		  Accessing legacy platform <b>Color and Font</b> definitions from within a CSS style sheet:
+			<p>
+				<img src="images/css-bridge/using-definitions.png" alt=""/>
+			</p>
+		</li>
+		<li>
+			Overriding <b>Color and Font</b> definitions in a CSS style sheet:
+			<p>
+				<img src="images/css-bridge/overriding-definitions.png" alt=""/>
+			</p>
+		</li>
+		<li>
+		  Adding new style definitions within your CSS that will be surfaced for user customization on the <b>Color and Font</b>
+		  preference page:
+			<p>
+				<img src="images/css-bridge/new-definitions.png" alt=""/>
+			</p>
+		</li>
+	 </ul>
+	 This bridging has a number of nice properties:
+	 <ul>
+	 	<li>The legacy color theme definitions overridden or added in the CSS style sheet are merged with the current theme.</li>
+	 	<li>When switching themes, overridden values are re-merged with the new theme.</li>
+	 	<li>The new definitions added with the CSS file (the last use case) are available in the CSS theme that provides it.</li>
+	 </ul>
+	 Note that after switching CSS themes, the definitions can be unavailable in the theme registries when the new theme doesn't re-define it.
+	 This means when using theme definitions out of CSS files, you must be prepared for such situations and use proper default values in 
+	 the case when some definitions are missing.
+    </td>
+  </tr>
+  
+  <tr id="theme-association"> 
+    <td class="title">New 'themeAssociation' element of the 'org.eclipse.e4.ui.css.swt.theme' extension&nbsp;point</td>
+    <td class="content">
+      An Eclipse platform CSS theme can now register an association with a legacy platform <b>Color and Font</b> theme. After defining 
+      the proper association between themes, changing themes in the <b>Appearance</b> preference page will automatically set the 
+      associated <b>Color and Font</b> theme.
+	 <p>
+		<img src="images/theme-association.png" alt=""/>
+	</p>
+	</td>
+  </tr>
+
+  <tr id="recenter-command">
+    <td class="title">Improved Recenter command</td>
+    <td class="content">
+        Like in Emacs, the <b>Recenter</b> command in textual editors now cycles between center, bottom and top.
+    </td>
+  </tr>
+  
+  <tr id="ant-1.9.2-update">
+    <td class="title">Ant 1.9.2</td>
+    <td class="content">
+    	The platform has been updated to use the latest version of Apache Ant (1.9.2). For
+    more information on what is new in Ant 1.9.2, see the official <a href="http://mirror.olnevhost.net/pub/apache//ant/README.html">what's new</a>.
+    </td>
+  </tr>
+    
+   <tr id="ant-bree-update">
+    <td class="title">Platform Ant BREE update</td>
+    <td class="content">
+    	Platform Ant has had a BREE update to require a Java 1.6 compatible execution environment (or newer).
+    </td>
+  </tr>
+    
+  <tr>
+    <td class="title">Platform Debug BREE update</td>
+    <td class="content">
+    	Platform Debug has had a BREE update to require a Java 1.6 compatible execution environment (or newer).
+    </td>
+  </tr>
+
+  <tr id="debug-examples"> 
+    <td class="title">New debugger examples</td>
+    <td class="content"> 
+      New examples have been added to the Platform Debug git repository. The <code>org.eclipse.debug.examples.mixedmode</code> project demonstrates
+      how to use Debug's mixed-mode launching support. The <code>org.eclipse.debug.examples.memory</code> project provides sample content to display
+      in the <b>Memory</b> and <b>Registers</b> views.
+    </td>
+  </tr>
+  
+  <tr id="batik-1-7">
+    <td class="title">Updated to Batik 1.7</td>
+    <td class="content">The Platform now includes a newer version of Apache Batik, version 1.7.0. 
+    This new version is being used for CSS parsing in the declarative styling engine, and is 
+    notably faster than the previous version.
+    </td>
+  </tr>
+
+  <tr id="workspaceLock">
+    <td class="title">Removed WorkspaceLock API</td>
+    <td class="content">
+      The <code>WorkspaceLock</code> API allowed a special client (usually Platform UI) to
+      hook into the locking protocols used by the workspace implementation. This hook
+      was used to mitigate deadlocks due to interaction with synchronous SWT events,
+      and was never intended to be used by other clients. In the 3.0 release this API
+      was deprecated in favor of a more general API provided by the <code>org.eclipse.core.jobs</code>
+      bundle. Invoking this API has had no effect since the 3.0 release. The specific API
+      being removed includes:
+      <ul>
+        <li>The <code>org.eclipse.core.resources.WorkspaceLock</code> class.</li>
+        <li>The method <code>org.eclipse.core.resources.IWorkspace#setWorkspaceLock</code></li>
+      </ul>
+      Clients that directly use an API listed above should remove any references to it.
+    </td>
+  </tr>
+  
+  <tr id="incrementalProjectBuilder-getRule">
+    <td class="title">Removed IncrementalProjectBuilder#getRule() API</td>
+    <td class="content">
+      The <code>IncrementalProjectBuilder#getRule()</code> method returned a scheduling rule 
+      that was required for building the project by the builder. This method was intended to be used by the builder framework only.
+      In the 3.6 release this method was deprecated in favor of a more general method <code>IncrementalProjectBuilder#getRule(int, Map)</code>. 
+      The specific API being removed includes:
+      <ul>
+        <li>The method <code>org.eclipse.core.resources.IncrementalProjectBuilder#getRule()</code></li>
+      </ul>
+      Clients that directly call the API listed above should remove any references to it
+      or replace them with calls to <code>IncrementalProjectBuilder#getRule(int, Map)</code>. Clients that implement the API listed
+      above should implement <code>IncrementalProjectBuilder#getRule(int, Map)</code> instead.
+    </td>
+  </tr>
+   
+  <tr id="eclipse-api"> 
+    <td class="title">EMenuService released as API</td>
+    <td class="content">
+        The <code>EMenuService</code> service has been released as API. RCP clients must adjust their package imports to <code>org.eclipse.e4.ui.services</code>.  
+    </td>
+  </tr>
+
+  <tr id="MLocalizable">
+    <td class="title">MLocalizable mixin interface</td>
+    <td class="content">
+      The mechanism for localizing strings in the application model has been changed. Previously, EOperations (methods) were used to get
+	  a localized value. Now, volatile, transient, derived, unchangeable EStructuralFeatures are used. This enables 
+	  notifications if a localizable value has changed. To mark EClasses who hold localizable informations and to inform them
+	  externally about a changed Locale, the <code>MLocalizable</code> mixin interface is introduced, which contains the single method 
+	  <code>updateLocalization()</code>. This enables the platform to generically search the model for model elements affected by a 
+	  Locale change and force them to update.
+    </td>
+  </tr>
+  
+  <tr id="Locale_Change_Propagation">
+    <td class="title">Locale change propagation</td>
+    <td class="content">
+      A new service called <code>ILocaleChangeService</code> has been introduced, which supports changing Locale at runtime. Using this service will:
+	  <ol>
+	    <li>Update the Locale in the application context.</li>
+	    <li>Inform all model elements of an application that implement <code>MLocalization</code> about the change.</li>
+	    <li>Post an event via event broker.</li>
+	  </ol>
+    </td>
+  </tr>
+  
+  <tr id="Locale_Change_Consumption">
+    <td class="title">Locale change consumption</td>
+    <td class="content">
+      There are now three ways to be informed about a Locale change:
+	  <ol>
+	    <li>Via event broker by listening to the topic <i>org/eclipse/e4/core/NLS/LOCALE_CHANGE</i></li>
+	    <li>Via dependency injection by getting the value for <code>TranslationService.LOCALE</code> injected (e.g. via method injection)</li>
+	    <li>Via attaching to the model events listening to the newly introduced LOCALIZED-Features</li>
+	  </ol>
+	  <b>Note:</b> The renderers need to be modified to listen to the LOCALIZED-Features, otherwise the Locale change at runtime isn't supported!
+    </td>
+  </tr>
+  
+  <tr id="ResourceBundleProvider">
+    <td class="title">ResourceBundleProvider</td>
+    <td class="content">
+      A new <code>ResourceBundleProvider</code> service has been introduced to abstract out the reference to the <code>BundleLocalization</code> OSGi service.
+	  This enables application authors to change how ResourceBundles should be looked up within their Eclipse application, e.g. using class-based 
+	  ResourceBundles, loading translations out of a database, loading ResourceBundles from a server by using a different ResourceBundle.Control.
+	  The default implementation <code>DefaultResourceBundleProvider</code> is internally using <code>BundleLocalization</code> to keep the
+	  known default behaviour.
+    </td>
+  </tr>
+  
+  <tr id="TranslationService">
+    <td class="title">TranslationService update</td>
+    <td class="content">
+      The <code>TranslationService</code>, that is used to localize the application model, had several downsides regarding extensibility.
+	  A lot of code needed to be copied in order to create a custom <code>TranslationService</code> that retrieves translations from a different location 
+	  than the OSGi-ResourceBundle. To make it easier for users to implement a custom <code>TranslationService</code>, the API was modified. The method 
+	  <code>getResourceString(String, ResourceBundle)</code> is moved from <code>BundleTranslationProvider</code> to <code>TranslationService</code> with 
+	  protected visibility, as it contains the logic to retrieve and transform the translation key that is set in the application model. The default
+	  implementation <code>BundleTranslationProvider</code> is now using the <code>ResourceBundleHelper</code> in combination with the 
+	  <code>ResourceBundleProvider</code>. This way the localization of the application model and the localization via new message extension are using 
+	  the same mechanisms. As a small enhancement, this also enables the usage of dot separated keys for translating the application model.
+	  <p>
+	  As part of this work, the previously internal package <code>org.eclipse.e4.core.services.translation</code> has been released as API.
+	  </p>
+    </td>
+  </tr>
+  
+  <tr id="CSSIncludes">
+    <td class="title">CSS includes </td>
+    <td class="content">
+      CSS files for Eclipse can now include other CSS files via the 
+      <code>@import url("platform:/plugin/Bundle-Symbolic-Name/path/file.extension");</code> statement. This allows easy reuse of 
+      existing style sheets.
+    </td>
+  </tr>
+  
+  <tr id="osgi-integration"> 
+    <td class="title">Improved OSGi integration</td>
+    <td class="content">
+        Eclipse implementations can retrieve the OSGI <code>BundleContext</code> via an extended object supplier and the <code>@Inject @OSGiBundle</code> annotations. 
+    </td>
+  </tr>
+  
+  <tr id="code-cleanup"> 
+    <td class="title">Platform code improvements</td>
+    <td class="content">
+       During the last milestones, the platform team has invested in cleaning up the existing codes basis to simplify contributions by new and existing contributors. 
+       For more details, see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=420779">bug 420779</a>.
+       During this update, several plug-ins have been upgraded to require Java 1.6 instead of Java 1.4 or Java 1.5.
+    </td>
+  </tr>
+    
+  <tr id="java7-filesystem-fragment">
+    <td class="title">New filesystem fragment for Java 7 API</td>
+    <td class="content">
+      A new filesystem fragment supporting Java 7 file API has been added. The
+      new fragment named <code>org.eclipse.core.filesystem.java7</code> allows
+      to retrieve information about files such as permissions, link targets,
+      etc. using Java 7 API rather than native code. This enables full filesystem capabilities
+      on platforms with no native Eclipse filesystem fragment. There are three
+      different types of filesystems supported:
+      <ul>
+        <li>DOS/Windows filesystems,</li>
+        <li>POSIX compliant filesystems, and</li>
+        <li>filesystems that are neither DOS/Windows nor POSIX compliant.</li>
+      </ul>
+      The new fragment will be loaded and used automatically when you run
+      Eclipse with JRE 7 or newer and no native filesystem fragment applicable
+      for your operating system can be found (such as Solaris, ARM, and s390).
+    </td>
+  </tr>
+    
+  
+  <!-- ******************** Equinox ********************** -->
+  <tr>
+    <td id="Equinox" class="section" colspan="2"><h2>Equinox Changes</h2></td>
+  </tr>
+  
+  <tr id="framework-update-1">
+    <td class="title">Equinox OSGi framework update</td>
+    <td class="content">
+      The Equinox Framework implementation has been updated to implement the latest
+      API OSGi R6 Framework specification.  The OSGi
+      R6 Core Framework specification (finalized in March 2014) contain
+      enhancements in the following areas:
+      <ul>
+         <li> Introduction of Service Scopes to the OSGi Service Registry
+             (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0195">RFC 195</a>)
+         </li>
+         <li> Improvements of Weaving Hooks
+             (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0191">RFC 191</a>)
+         </li>
+         <li> Clarification of hooks on the system bundle
+             (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0198">RFC 198</a>)
+         </li>
+         <li> Native environment namespace
+             (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0188">RFC 188</a>)
+         </li>
+         <li> Data Transfer Objects
+             (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0185">RFC 185</a>)
+         </li>
+         <li> Extension Bundle Activators
+             (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0204">RFC 204</a>)
+         </li>
+         <li> Addition of FrameworkWiring.findProviders - no RFC
+         </li>
+      </ul>
+      From an Equinox perspective these are considered incremental enhancements.
+      A majority of the development effort during this release cycle is focused on refactoring and, in
+      many cases, rewriting the core Equinox Framework implementation to be based on
+      the OSGi generic dependency model.
+      <p>
+      For most consumers and developers this change should not be noticed.  But, as
+      documented in the <a href="http://wiki.eclipse.org/Equinox/Luna_Framework">wiki</a>,
+      there are four main areas of concern that the community should be aware of:
+      </p>
+      <ul>
+         <li>The Framework no longer uses the old Equinox resolver API
+             org.eclipse.osgi.service.resolver internally to resolve bundles.</li>
+         <li>All Equinox Framework specific hook implementations are broken and will
+             need to migrate.</li>
+         <li>Removal of old style plug-in support. A compatibility fragment is available to add the support back.</li>
+         <li>Removal of PlatformAdmin Service Implementation. A compatibility fragment is available to add support back.</li>
+      </ul>
+    </td>
+  </tr>
+  <tr id="cm-update">
+    <td class="title">Equinox Configuration Admin update</td>
+    <td class="content">
+      The Equinox Configuration Admin implementation has been updated to implement
+      the OSGi Configuration Admin Service Specification version 1.5.  The previous
+      release of Equinox Configuration Admin implemented version 1.3.
+    </td>
+  </tr>
+  
+  <tr id="region-update-1">
+    <td class="title">Equinox Regions update</td>
+    <td class="content">
+      The Equinox Regions implementation has been updated to take advantage
+      of Extension Bundle Activators
+      (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0204">RFC 204</a>)
+       coming in the OSGi R6 specification.
+      This allows Equinox Regions to insert its isolation model before
+      the framework is launched so that proper region behavior can be
+      established before any bundles are loaded in the framework.
+      <p>
+      The Equinox Regions has added a new namespace for sharing bundle lifecycle 
+      operations between regions.  In previous versions of Equinox regions the only way 
+      to share bundle lifecycle operations across different regions was to share complete
+      bundles which also shared all capabilities provided by the bundle.  Now it is
+      possible to use the org.eclipse.equinox.allow.bundle.lifecycle namespace to share
+      only the bundle lifecycle operations between different regions.
+      (see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=418224">bug 418224</a>)
+      </p>
+    </td>
+  </tr>
+ 
+  
+  <tr id="metatype-update">
+    <td class="title">Equinox Metatype update</td>
+    <td class="content">
+      The Equinox Metatype API has been updated to add the methods to
+      get the minimum and maximum values of an attribute definition.
+      (see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=416640">bug 416640</a>)
+    </td>
+  </tr>
+ 
+ <tr> 
+    <td class="title">Framework Trace Options</td>
+    <td class="content">
+      The new OSGi framework implementation now supports many of the 
+      previously supported trace options and adds a few more trace options
+      to help debug issues with the framework.  The following trace options 
+      are now implemented:
+      <dl>
+         <dt>debug/bundleTime</dt>
+           <dd>Prints out timing information for bundle activation</dd>
+         <dt>debug/cachedmanifest</dt>
+           <dd>Debug the caching of bundle headers</dd>
+         <dt>debug/location</dt>
+           <dd>Prints out location service debug information</dd>
+         <dt>debug/startlevel</dt>
+           <dd>Prints out start level service debug information</dd>
+         <dt>monitor/activation</dt>
+           <dd>Monitor persistent bundle activation</dd>
+         <dt>resolver/providers</dt>
+           <dd>Prints out information about matching capabilities returned to the resolver and why any were filtered out</dd>
+         <dt>resolver/hooks</dt>
+           <dd>Prints out information about capabilities or resources that were filtered by resolver hooks</dd>
+         <dt>resolver/uses</dt>
+           <dd>Prints out information about uses constraint violations</dd>
+         <dt>resolver/wiring</dt>
+           <dd>Prints out wiring information after the resolve process completes</dd>
+         <dt>resolver/report</dt>
+           <dd>Prints out the resolution report information</dd>
+         <dt>resolver</dt>
+           <dd>enables all resolver trace options</dd>
+      </dl>
+    </td>
+  </tr>
+
+
+  <!-- *********************** SWT *********************** -->
+  <tr>
+    <td id="SWT" class="section" colspan="2"><h2>SWT Changes</h2></td>
+  </tr>
+  
+  <tr id="swt-needs-1.5"> 
+    <td class="title">SWT requires JRE 1.5</td>
+    <td class="content">
+      The SWT project has moved to Java 1.5 compliance level. SWT applications will now require JRE 1.5 or higher to run.
+    </td>
+  </tr>
+   
+  <tr id="timing-api"> 
+    <td class="title">Added UI timing API</td>
+    <td class="content"> 
+      SWT has added two new events, <tt>SWT.PreEvent</tt> and <tt>SWT.PostEvent</tt>,
+      which are sent before and after all events and async runnables. These events can
+      be used to measure the time spent on processing any events. This 
+      can be useful for detecting slow event listeners. Because of its pervasive effect
+      on all events, this listener should be used with <b>extreme</b> caution.
+      For an example of how this can be used, take a look at the 
+      <a href="http://git.eclipse.org/c/platform/eclipse.platform.swt.git/tree/examples/org.eclipse.swt.examples.watchdog">
+      Watchdog</a> plugin in SWT examples.
+    </td>
+  </tr>
+
+  <tr id="bidi-segments">
+    <td class="title">BIDI segments support for Combo on Windows</td>
+    <td class="content">
+      The <code>Combo</code> widget now supports the same <code>SegmentListener</code> API as <code>Text</code>.
+      This allows an application to specify
+      segment boundaries and Unicode Control Characters to use in the segment boundaries.
+      <p>
+      <a href="http://git.eclipse.org/c/platform/eclipse.platform.swt.git/tree/examples/org.eclipse.swt.snippets/src/org/eclipse/swt/snippets/Snippet332.java"> 
+      Snippet332</a> shows how to accomplish RTL override in a Combo.
+      </p>
+      <p><img src="images/combo-bidi-segments.png" alt=""/></p>
+      <p>JFace clients can use <code>BidiUtils#applyBidiProcessing(...)</code> to set pre-defined text types.</p>
+    </td>
+  </tr>
+
+  <tr id="styled-text-api"> 
+    <td class="title">Added new API in StyledText to get text selection state</td>
+    <td class="content">
+      <code>StyledText.isTextSelected()</code> can be used to quickly determine whether any text
+      in the widget is selected or not.
+    </td>
+  </tr>
+  
+  <tr id="sleep-monitor-api"> 
+    <td class="title">Added API for sleep monitoring</td>
+    <td class="content">
+        SWT has added two new events, <code>SWT.Sleep</code> and <code>SWT.Wakeup</code>,
+        which are sent before the <code>Display</code> event loop goes into sleep and after
+        it wakes up from sleep respectively. These events can e.g. be used to monitor the duration
+        of sleep time in SWT applications.
+    </td>
+  </tr>
+  
+  <tr id="styledtext-bidi">
+    <td class="title">Set text direction for the <code>StyledText</code> widget on Windows</td>
+    <td class="content">
+      The <code>StyledText</code> widget now supports setting the text direction via the 
+      <code>setTextDirection(int)</code> API on the Windows platform. The <code>setTextDirection 
+      (int)</code> and <code>getTextDirection ()</code> APIs are also added to <code>TextLayout</code> 
+      (implemented only on Windows currently).
+    </td>
+  </tr>
+     
+  <tr id="gtk3-as-default"> 
+    <td class="title">GTK+ 3 used by default on Linux distributions (when installed and available)</td>
+    <td class="content">
+      Linux builds come with GTK+ 3 support enabled by default on GTK+ 3 versions prior to 3.10, 
+      versions newer than that will fall back to GTK+ 2.x by default for maximum stability. 
+      The GTK+ 3 support can however still be enabled either by setting the environment variable 
+      <code>SWT_GTK3</code> to <code>1</code> or by adding the launcher parameters <code>--launcher.GTK_version 3</code>.
+    </td>
+  </tr>
+  
+  <tr id="swt-webkit">
+    <td class="title">Experimental support for WebKit2 added to the SWT Browser</td>
+    <td class="content">
+      The SWT Browser now has preliminary support for WebKit2. To try it out, create a browser
+      widget with style <code>SWT.WEBKIT</code>, and set the environment variable SWT_WEBKIT2
+      to 1. This is only supported with GTK+ 3.x; if GTK+ 3 is disabled the browser will 
+      fallback to WebKit1.
+    </td>
+  </tr>
+  
+  <tr id="windows-taskbar-grouping">
+    <td class="title">SWT applications will not be grouped together in the Windows taskbar by default</td>
+    <td class="content">
+      SWT does not initialize the <b>AppUserModelID</b> (which is used by Windows for taskbar grouping) 
+      to "SWT" by default anymore. SWT applications which desire to be grouped together in the
+      Windows taskbar should set an appropriate application name before creating the
+      <code>Display</code> object as shown below:
+      <pre>
+		Display.setAppName("APP_NAME"); // APP_NAME will used as AppUserModelID
+		Display display = new Display();
+	  </pre> 
+    </td>
+  </tr>
+  
+  
+
+  </tbody>
+<!-- ****************** END OF N&N TABLE ****************** -->
+</table>
+
+<p align="center"><a href="eclipse-news-part2.html">Previous</a>&nbsp;&nbsp;&nbsp;&nbsp; <a href="eclipse-news-part4.html">Next</a></p>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/platform/4.4/final/eclipse-news-part4.html b/platform/4.4/final/eclipse-news-part4.html
new file mode 100644
index 0000000..9b31d91
--- /dev/null
+++ b/platform/4.4/final/eclipse-news-part4.html
@@ -0,0 +1,282 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+<meta name="copyright" content="Copyright (c) Eclipse contributors and others 2014. This page is made available under license. For full details, see the LEGAL section in the documentation that contains this page."/>
+<meta http-equiv="Content-Language" content="en-us" />
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+<link rel="stylesheet" href="default_style.css" charset="UTF-8" type="text/css"/>
+<style type="text/css">
+table.news td {border-top: solid thin black;}
+table.news tr {vertical-align: top;}
+table.news tr td.section {font-size: 20px; font-weight: bold;}
+table.news tr td.title {vertical-align: top; width: 30%; font-weight: bold;}
+table.news tr td.content {vertical-align: top; width: 70%;}
+</style>
+<title>Eclipse Project Kepler - New and Noteworthy</title>
+</head>
+
+<body>
+<h2>Plug-in Development Environment</h2>
+
+<ul>
+  <li>
+    <a href="#APITools">API Tools</a>
+  </li>
+  <li>
+    <a href="#ViewsAndEditors">Views and Editors</a>
+  </li>
+  <li>
+    <a href="#Misc">Misc</a>
+  </li>
+</ul>
+
+<!-- ****************** START OF N&N TABLE ****************** -->
+
+<table class="news" cellpadding="10" cellspacing="0">
+  <tbody>
+  
+  <!-- ******************** APITools ********************** -->
+  <tr>
+    <td id="APITools" class="section" colspan="2"><h2>API Tools</h2></td>
+  </tr>
+  
+  <tr id="api-tag-visibility">
+    <td class="title">API Tools Javadoc tag visibility matches Java Language Specification</td>
+    <td class="content">
+     API Tools supports API restrictions using <a href="http://wiki.eclipse.org/PDE/API_Tools/Javadoc_Tags">Javadoc tags</a> such as 
+     @noextend and @noreference. The API Tools builder has an option to add problem markers for invalid use of the tags. The
+     logic to check whether a tag is valid has been upgraded and now follows the visibility rules in the 
+     <a href="http://docs.oracle.com/javase/specs/">Java Language Specification (JLS)</a>.
+     <p><img src="images/tag-visibility.png" alt="Example tag visibility problem"/></p>
+    </td>
+  </tr>
+  
+  <tr id="api-tools-bree">
+    <td class="title">API Tools moved to JavaSE-1.6</td>
+    <td class="content">
+     All API Tools plug-ins now have a bundle required execution environment (BREE) of JavaSE-1.6.
+    </td>
+  </tr>
+  
+  <tr id="api-tools-annotations">
+    <td class="title">Annotation support in API Tools</td>
+    <td class="content">
+          API Tools now provides support for using annotations to describe your API usage. Prior to the new annotation support you would have, for example,
+          used the <code>@noreference</code> Javadoc tag to indicate noone should use the tagged type / member. Now you can add the <code>@NoReference</code>
+          annotation (in Java 1.5+ source) to the member directly without the need for Javadoc.
+      <p><img src="images/annotation-example.png" alt="The @NoExtend annotation being used on a class"/></p>
+      <p>
+        To make the transition from Javadoc tags to the new annotation support, API Tools provides a conversion wizard that is found 
+        using the <strong>Plug-in Tools &gt; Convert API Tools Javadoc tags...</strong> command for a selected project. The wizard can convert all existing Javadoc tags to their annotation
+        equivalent, update the <code>build.properties</code> file and optionally remove all of the old Javadoc tags.
+      </p>
+      <img src="images/javadoc-conversion.png" alt="The Javadoc conversion wizard"/>
+    </td>
+  </tr>
+  
+  <tr id="ApiToolsJava8"> 
+    <td class="title">Java 8 support for API Tools complete</td>
+    <td class="content">
+       API Tools now has full support for Java 8.  This includes illegal use, binary comparisons, restriction validation (for both
+       javadoc tags and annotations), and completion proposals.  Support has been added for the following code structures:
+       <ul>
+       <li>Default Methods</li>
+       <li>Type Annotations</li>
+       <li>Lambda Expressions</li>
+       <li>Method References</li>
+       </ul>
+       <p>There is also a new <b>JavaSE-1.8</b> execution environment fragment available. Update the <b>API Tools Execution 
+       Environment Descriptions</b> feature.  API tools now uses the 5.0.1 release of ASM to read Java 8 class files.</p>
+    </td>       
+  </tr>
+  
+  
+  <!-- ******************** Views and Editors ********************** -->
+  <tr>
+    <td id="ViewsAndEditors" class="section" colspan="2"><h2>Views and Editors</h2></td>
+  </tr>
+  
+  <tr id="target-statusbar">
+    <td class="title">Display target platform in the status bar</td>
+    <td class="content">
+     You can now have target platform information displayed in the workbench status bar. The active target
+     name is shown, and the icon reveals problems with the target platform (if any).
+     Double-clicking on it will open the <b>Target Platform</b> preference page.
+     
+     <p>This feature can be enabled on the
+     <b>General &gt; Plug-in Development</b> preference page.</p>
+     <p><img src="images/target-status.png" alt="The target platform state in the status bar showing an error"/></p>
+    </td>
+  </tr>
+  
+  <tr id="pde-tracing">
+    <td class="title">PDE UI tracing options available</td>
+    <td class="content">
+     The tracing options provided by PDE UI can now be enabled from the <b>General &gt; Tracing</b> preference page:
+     <p><img src="images/pde-tracing.png" alt="PDE tracing options"/></p>
+     You can choose to have the output of debug trace statements being written to a file or
+     sent to the standard output stream.
+    </td>
+  </tr>
+  
+  <tr id="feature-dialog-contains-plugins">
+    <td class="title">Feature selection dialog filters by plug-ins</td>
+    <td class="content">
+     When entering text into the filter field of the feature selection dialog, features that contain a plug-in matching
+     the filter will be returned. This provides a quick way to add the correct feature to include in a product.
+     <p><img src="images/feature-selection.png" alt="The feature selection dialog"/></p>
+    </td>
+  </tr>
+  
+  <tr id="bundle-exceptions-in-editor">
+    <td class="title">OSGi bundle exceptions are displayed in the manifest editor</td>
+    <td class="content">
+     Certain syntax errors, such as missing a comma between entries in the <code>Require-Bundle</code> header, cause bundle exceptions
+     when PDE tries to add the bundle to an OSGi State. The exceptions are now logged and displayed in the manifest editor.   
+     <p><img src="images/bundle-exception.png" alt="Bundle exception displayed in the manifest editor"/></p>
+    </td>
+  </tr>
+  
+  <tr id="os-arch-system-props">
+    <td class="title">Products can specify OS/arch system properties</td>
+    <td class="content">
+      In the <b>Product Editor</b> you can now add system properties that will only apply to a single OS, a single architecture or a 
+      an OS/architecture combination.
+      <p>
+      <img src="images/osarch-systemprops.png" alt="The product editor showing os/arch system properties"/>
+      </p>
+    </td>
+  </tr>
+  
+  <tr id="os-arch-vm-args">
+    <td class="title">Products can specify OS/arch launch arguments</td>
+    <td class="content">
+      In the <b>Product Editor</b> you can now add program and VM arguments to all platforms, a specific operating system or
+      a specific OS/architecture combination. A preview area shows the complete list of arguments that will apply to the selected
+      OS and architecture.
+      <p>
+      <img src="images/osarch-args.png" alt="The product editor showing os/arch vm arguments"/>
+      </p>
+    </td>
+  </tr>
+  
+  <tr id="product-add-update-sites"> 
+    <td class="title">Product can add p2 update sites</td>
+    <td class="content">
+      A new page has been added to the <b>Product Editor</b> where you can add p2 repository update sites.  When your product
+      is exported, the list of update sites will be added to the repository list that p2 uses to check for updates.  You can
+      set a site as disabled to have it visible on the <b>Install/Update > Available Software Sites</b> preference page, but it
+      will not be used during install/update operations unless the user enables it first.
+      <p>
+      <img src="images/updatePage.png" alt="Update page in the product editor"/>
+      </p>
+    </td>
+  </tr>
+  
+  <tr id="product-custom-start-levels"> 
+    <td class="title">Product can define custom default start levels</td>
+    <td class="content">
+      On the <b>Configuration</b> page of the <b>Product Editor</b>, there is a new button: <b>Add Recommended...</b>.  When pressed,
+      a dialog will open offering to add a list of recommended custom start levels to your product definition. This is helpful
+      for new product developers as they may not be aware that some plug-ins require custom start levels to function correctly. The 
+      operation will not overwrite any existing custom start levels you have set previously. 
+      <p>
+      <img src="images/startLevels.png" alt="Product editor start levels with add recommended button"/>
+      </p>
+      <p>
+      This is the list of recommended start levels currently provided:
+      </p>
+<pre>org.eclipse.core.runtime@start
+org.eclipse.equinox.common@2:start
+org.eclipse.equinox.ds@2:start
+org.eclipse.equinox.event@2:start
+org.eclipse.equinox.simpleconfigurator@1:start
+org.eclipse.equinox.p2.reconciler.dropins@start</pre>
+    </td>
+  </tr>
+  
+    <tr id="pdeDeprecatedExtensions"> 
+    <td class="title">Plug-in editor indicates deprecated extension elements</td>
+    <td class="content">
+       When editing the extensions of a plug-in, you now have a visual indication that an extension element or attribute
+       has been deprecated.
+       <ul>
+         <li>Icons in the tree are marked with a warning decoration:
+         <p><img src="images/deprecatedExtension1.png" alt="Deprecated extension in tree"/></p>
+         </li>
+         <li>Menu items are marked with <i>(deprecated)</i>:
+         <p><img src="images/deprecatedExtension2.png" alt="Deprecated extension in menu"/></p>
+         </li>
+         <li>Details of elements include deprecation information and deprecated attributes are marked with <i>(!)</i>:
+         <p><img src="images/deprecatedExtension3.png" alt="Deprecated extension in details"/></p>
+         </li>
+       </ul>
+    </td>
+  </tr>
+  
+  
+  <!-- ******************** Misc ********************** -->
+  <tr>
+    <td id="Misc" class="section" colspan="2"><h2>Misc</h2></td>
+  </tr>
+  
+  <tr id="warn-platformadmin-unavailable">
+    <td class="title">Warning if PlatformAdmin is unavailable</td>
+    <td class="content">
+     PDE requires the PlatformAdmin service to function. The Equinox Framework has moved this service to the <b>org.eclipse.osgi.compatibility.state</b>
+     compatibility fragment.  If the fragment is not installed, PDE will write an error to the log and will not function correctly. The fragment
+     is included in the Eclipse SDK, so most users will be unaffected.
+     <p><img src="images/platformadmin-message.png" alt="Error message for PlatformAdmin unavailable"/></p>
+    </td>
+  </tr>
+  
+  <tr id="pde-build-6">
+    <td class="title">PDE Build moved to JavaSE-1.6</td>
+    <td class="content">
+     The org.eclipse.pde.build bundle now has a bundle required execution environment (BREE) of JavaSE-1.6, matching the Platform Ant bundles.
+    </td>
+  </tr>
+  
+  <tr id="target-no-preferences">
+    <td class="title">Target platform content is no longer stored in preferences</td>
+    <td class="content">
+     The target platform specified on the <b>Target Platform</b> preference page uses flexible target definitions, stored in .target files,
+     to specify the set of plug-ins PDE should build against and use to launch applications. However, the content of the target platform 
+     was previously stored in preferences. This could lead to inconsistencies between what you expect to exist in the target platform and 
+     what is actually available. This problem was more noticeable when using a complex target definition containing feature or software 
+     site locations.
+     
+     <p>In Luna, the target platform information is always created from the target definition chosen on the preference
+     page. In addition to reducing inconsistencies in the target, there are performance improvements when interacting with the 
+     target.</p>
+    </td>
+  </tr>
+  
+  <tr id="pdeNoUnboundEE"> 
+    <td class="title">Launch configurations don't select unbound execution environment</td>
+    <td class="content">
+       When creating a new launch configuration, PDE examines the list of plug-ins to be launched and selects the lowest
+       execution environment (EE) that supports each plug-in's required EE.  However, this could lead to selecting an EE
+       that no installed JRE matches.  With no bound JRE, launching with that execution environment would always fail. 
+       Now, when choosing an execution environment, any plug-in that requires an unbound EE will be ignored.
+    </td>
+  </tr>
+  
+  <tr id="pdeBuildConfigurator"> 
+    <td class="title">PDE Build depends on org.eclipse.update.configurator</td>
+    <td class="content">
+       PDE Build now has a non-optional dependency on <code>org.eclipse.update.configurator [3.1.0,4.0.0)</code>.  Functionality
+       from that bundle is required by PDE Build and previously was added via an optional dependency on <code>org.eclipse.core.runtime.compatibility</code>.
+       If this optional dependency was missing, PDE Build or PDE UI operations could fail with cryptic errors.
+    </td>
+  </tr>
+  
+  
+  <!-- ****************** END OF N&N TABLE ****************** -->
+  </tbody>
+</table>
+
+<p align="center"><a href="eclipse-news-part3.html">Previous</a>&nbsp;&nbsp;&nbsp;&nbsp; <font color="#808080">Next</font></p>
+
+</body>
+</html>
diff --git a/platform/4.4/final/images/annotation-example.png b/platform/4.4/final/images/annotation-example.png
new file mode 100644
index 0000000..cf0f4e9
--- /dev/null
+++ b/platform/4.4/final/images/annotation-example.png
Binary files differ
diff --git a/platform/4.4/final/images/ant-view.png b/platform/4.4/final/images/ant-view.png
new file mode 100644
index 0000000..e0cecc4
--- /dev/null
+++ b/platform/4.4/final/images/ant-view.png
Binary files differ
diff --git a/platform/4.4/final/images/block-to-expression.png b/platform/4.4/final/images/block-to-expression.png
new file mode 100644
index 0000000..cfa7d31
--- /dev/null
+++ b/platform/4.4/final/images/block-to-expression.png
Binary files differ
diff --git a/platform/4.4/final/images/bundle-exception.png b/platform/4.4/final/images/bundle-exception.png
new file mode 100644
index 0000000..e97fa09
--- /dev/null
+++ b/platform/4.4/final/images/bundle-exception.png
Binary files differ
diff --git a/platform/4.4/final/images/combo-bidi-segments.png b/platform/4.4/final/images/combo-bidi-segments.png
new file mode 100644
index 0000000..326962f
--- /dev/null
+++ b/platform/4.4/final/images/combo-bidi-segments.png
Binary files differ
diff --git a/platform/4.4/final/images/contrib-vm.png b/platform/4.4/final/images/contrib-vm.png
new file mode 100644
index 0000000..5d5118d
--- /dev/null
+++ b/platform/4.4/final/images/contrib-vm.png
Binary files differ
diff --git a/platform/4.4/final/images/convert-to-lambda-1.png b/platform/4.4/final/images/convert-to-lambda-1.png
new file mode 100644
index 0000000..004e135
--- /dev/null
+++ b/platform/4.4/final/images/convert-to-lambda-1.png
Binary files differ
diff --git a/platform/4.4/final/images/convert-to-lambda-2.png b/platform/4.4/final/images/convert-to-lambda-2.png
new file mode 100644
index 0000000..1d1f3f3
--- /dev/null
+++ b/platform/4.4/final/images/convert-to-lambda-2.png
Binary files differ
diff --git a/platform/4.4/final/images/css-bridge/new-definitions.png b/platform/4.4/final/images/css-bridge/new-definitions.png
new file mode 100644
index 0000000..e5522d3
--- /dev/null
+++ b/platform/4.4/final/images/css-bridge/new-definitions.png
Binary files differ
diff --git a/platform/4.4/final/images/css-bridge/overriding-definitions.png b/platform/4.4/final/images/css-bridge/overriding-definitions.png
new file mode 100644
index 0000000..35133cb
--- /dev/null
+++ b/platform/4.4/final/images/css-bridge/overriding-definitions.png
Binary files differ
diff --git a/platform/4.4/final/images/css-bridge/using-definitions.png b/platform/4.4/final/images/css-bridge/using-definitions.png
new file mode 100644
index 0000000..f6a9693
--- /dev/null
+++ b/platform/4.4/final/images/css-bridge/using-definitions.png
Binary files differ
diff --git a/platform/4.4/final/images/darktheme-full.png b/platform/4.4/final/images/darktheme-full.png
new file mode 100644
index 0000000..8208c69
--- /dev/null
+++ b/platform/4.4/final/images/darktheme-full.png
Binary files differ
diff --git a/platform/4.4/final/images/darktheme.png b/platform/4.4/final/images/darktheme.png
new file mode 100644
index 0000000..c7ac142
--- /dev/null
+++ b/platform/4.4/final/images/darktheme.png
Binary files differ
diff --git a/platform/4.4/final/images/deprecatedExtension1.png b/platform/4.4/final/images/deprecatedExtension1.png
new file mode 100644
index 0000000..54b783d
--- /dev/null
+++ b/platform/4.4/final/images/deprecatedExtension1.png
Binary files differ
diff --git a/platform/4.4/final/images/deprecatedExtension2.png b/platform/4.4/final/images/deprecatedExtension2.png
new file mode 100644
index 0000000..b5fa0fd
--- /dev/null
+++ b/platform/4.4/final/images/deprecatedExtension2.png
Binary files differ
diff --git a/platform/4.4/final/images/deprecatedExtension3.png b/platform/4.4/final/images/deprecatedExtension3.png
new file mode 100644
index 0000000..7a5c14e
--- /dev/null
+++ b/platform/4.4/final/images/deprecatedExtension3.png
Binary files differ
diff --git a/platform/4.4/final/images/expression-to-block.png b/platform/4.4/final/images/expression-to-block.png
new file mode 100644
index 0000000..9e57646
--- /dev/null
+++ b/platform/4.4/final/images/expression-to-block.png
Binary files differ
diff --git a/platform/4.4/final/images/feature-selection.png b/platform/4.4/final/images/feature-selection.png
new file mode 100644
index 0000000..ef123a6
--- /dev/null
+++ b/platform/4.4/final/images/feature-selection.png
Binary files differ
diff --git a/platform/4.4/final/images/formatter-braces-lambda.png b/platform/4.4/final/images/formatter-braces-lambda.png
new file mode 100644
index 0000000..0b14822
--- /dev/null
+++ b/platform/4.4/final/images/formatter-braces-lambda.png
Binary files differ
diff --git a/platform/4.4/final/images/formatter-whitespace-lambda.png b/platform/4.4/final/images/formatter-whitespace-lambda.png
new file mode 100644
index 0000000..93af625
--- /dev/null
+++ b/platform/4.4/final/images/formatter-whitespace-lambda.png
Binary files differ
diff --git a/platform/4.4/final/images/generics_defaults.png b/platform/4.4/final/images/generics_defaults.png
new file mode 100644
index 0000000..c113871
--- /dev/null
+++ b/platform/4.4/final/images/generics_defaults.png
Binary files differ
diff --git a/platform/4.4/final/images/generics_defaults.txt b/platform/4.4/final/images/generics_defaults.txt
new file mode 100644
index 0000000..21ff412
--- /dev/null
+++ b/platform/4.4/final/images/generics_defaults.txt
@@ -0,0 +1,33 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Predicate;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+
+@NonNullByDefault
+public class Defaults {
+
+    List<String> safeFilter(List<String> in, Predicate<String> pred) {
+        List<String> result = new ArrayList<>();
+        for (String string : in) {
+            if (pred.test(string))
+                result.add(string);
+            else
+                result.add(null);
+        }
+        return result;
+    }
+
+    List<String> safeSingleton(String in) {
+        List<String> result = new ArrayList<>();
+        result.add(in);
+        return result;
+    }
+    
+    @NonNullByDefault({})
+    // default is canceled for this method
+    void unprotectedClient(Predicate<String> myPred, String myString) {
+        List<String> myStrings = safeSingleton(myString);
+        safeFilter(myStrings, myPred);    
+    }
+}
\ No newline at end of file
diff --git a/platform/4.4/final/images/generics_unsafePredicateCall.png b/platform/4.4/final/images/generics_unsafePredicateCall.png
new file mode 100644
index 0000000..f6b7fb2
--- /dev/null
+++ b/platform/4.4/final/images/generics_unsafePredicateCall.png
Binary files differ
diff --git a/platform/4.4/final/images/generics_unsafePredicateCall.txt b/platform/4.4/final/images/generics_unsafePredicateCall.txt
new file mode 100644
index 0000000..c1415ac
--- /dev/null
+++ b/platform/4.4/final/images/generics_unsafePredicateCall.txt
@@ -0,0 +1,29 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Predicate;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+
+public class Generics {
+
+    List<@Nullable String> safeFilter(List<@NonNull String> in,
+                                Predicate<@NonNull String> pred) {
+        List<@Nullable String> result = new ArrayList<>();
+        for (String string : in) {
+            if (pred.test(string))
+                result.add(string);
+            else
+                result.add(null);
+        }
+        return result;
+    }
+    boolean unsafePredicateCall(List<@Nullable String> in,
+                                Predicate<@NonNull String> pred) {
+        for (String string : in) {
+            if (pred.test(string))
+                return true;
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/platform/4.4/final/images/generics_unsafeSingleton.png b/platform/4.4/final/images/generics_unsafeSingleton.png
new file mode 100644
index 0000000..61e6b08
--- /dev/null
+++ b/platform/4.4/final/images/generics_unsafeSingleton.png
Binary files differ
diff --git a/platform/4.4/final/images/generics_unsafeSingleton.txt b/platform/4.4/final/images/generics_unsafeSingleton.txt
new file mode 100644
index 0000000..f6da426
--- /dev/null
+++ b/platform/4.4/final/images/generics_unsafeSingleton.txt
@@ -0,0 +1,26 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Predicate;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+
+public class Generics {
+
+    List<@Nullable String> safeFilter(List<@NonNull String> in,
+                                Predicate<@NonNull String> pred) {
+        List<@Nullable String> result = new ArrayList<>();
+        for (String string : in) {
+            if (pred.test(string))
+                result.add(string);
+            else
+                result.add(null);
+        }
+        return result;
+    }
+    List<@NonNull String> unsafeSingleton(@Nullable String in) {
+        List<@NonNull String> result = new ArrayList<>();
+        result.add(in);
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/platform/4.4/final/images/hover-on-lambda.png b/platform/4.4/final/images/hover-on-lambda.png
new file mode 100644
index 0000000..8c65086
--- /dev/null
+++ b/platform/4.4/final/images/hover-on-lambda.png
Binary files differ
diff --git a/platform/4.4/final/images/hover-on-method-reference.png b/platform/4.4/final/images/hover-on-method-reference.png
new file mode 100644
index 0000000..ab6211e
--- /dev/null
+++ b/platform/4.4/final/images/hover-on-method-reference.png
Binary files differ
diff --git a/platform/4.4/final/images/iconupdate.png b/platform/4.4/final/images/iconupdate.png
new file mode 100644
index 0000000..c6e9938
--- /dev/null
+++ b/platform/4.4/final/images/iconupdate.png
Binary files differ
diff --git a/platform/4.4/final/images/import-as-project.png b/platform/4.4/final/images/import-as-project.png
new file mode 100644
index 0000000..c758e01
--- /dev/null
+++ b/platform/4.4/final/images/import-as-project.png
Binary files differ
diff --git a/platform/4.4/final/images/import-filter-conflicts-before.png b/platform/4.4/final/images/import-filter-conflicts-before.png
new file mode 100644
index 0000000..c61f61c
--- /dev/null
+++ b/platform/4.4/final/images/import-filter-conflicts-before.png
Binary files differ
diff --git a/platform/4.4/final/images/java8.png b/platform/4.4/final/images/java8.png
new file mode 100644
index 0000000..379b9a9
--- /dev/null
+++ b/platform/4.4/final/images/java8.png
Binary files differ
diff --git a/platform/4.4/final/images/javadoc-conversion.png b/platform/4.4/final/images/javadoc-conversion.png
new file mode 100644
index 0000000..972cec3
--- /dev/null
+++ b/platform/4.4/final/images/javadoc-conversion.png
Binary files differ
diff --git a/platform/4.4/final/images/junit-failure-trace-font.png b/platform/4.4/final/images/junit-failure-trace-font.png
new file mode 100644
index 0000000..6041bd9
--- /dev/null
+++ b/platform/4.4/final/images/junit-failure-trace-font.png
Binary files differ
diff --git a/platform/4.4/final/images/launch-options.png b/platform/4.4/final/images/launch-options.png
new file mode 100644
index 0000000..0ce3a5a
--- /dev/null
+++ b/platform/4.4/final/images/launch-options.png
Binary files differ
diff --git a/platform/4.4/final/images/move-persp-items.png b/platform/4.4/final/images/move-persp-items.png
new file mode 100644
index 0000000..3798341
--- /dev/null
+++ b/platform/4.4/final/images/move-persp-items.png
Binary files differ
diff --git a/platform/4.4/final/images/navigate-from-lambda.png b/platform/4.4/final/images/navigate-from-lambda.png
new file mode 100644
index 0000000..2cd95ff
--- /dev/null
+++ b/platform/4.4/final/images/navigate-from-lambda.png
Binary files differ
diff --git a/platform/4.4/final/images/navigate-from-method-reference.png b/platform/4.4/final/images/navigate-from-method-reference.png
new file mode 100644
index 0000000..2938dd7
--- /dev/null
+++ b/platform/4.4/final/images/navigate-from-method-reference.png
Binary files differ
diff --git a/platform/4.4/final/images/new-e4view-extension.png b/platform/4.4/final/images/new-e4view-extension.png
new file mode 100644
index 0000000..7118a3b
--- /dev/null
+++ b/platform/4.4/final/images/new-e4view-extension.png
Binary files differ
diff --git a/platform/4.4/final/images/no-overlays.png b/platform/4.4/final/images/no-overlays.png
new file mode 100644
index 0000000..a2e8c37
--- /dev/null
+++ b/platform/4.4/final/images/no-overlays.png
Binary files differ
diff --git a/platform/4.4/final/images/osarch-args.png b/platform/4.4/final/images/osarch-args.png
new file mode 100644
index 0000000..0bcd586
--- /dev/null
+++ b/platform/4.4/final/images/osarch-args.png
Binary files differ
diff --git a/platform/4.4/final/images/osarch-systemprops.png b/platform/4.4/final/images/osarch-systemprops.png
new file mode 100644
index 0000000..d9b885a
--- /dev/null
+++ b/platform/4.4/final/images/osarch-systemprops.png
Binary files differ
diff --git a/platform/4.4/final/images/pde-tracing.png b/platform/4.4/final/images/pde-tracing.png
new file mode 100644
index 0000000..d7fe1a3
--- /dev/null
+++ b/platform/4.4/final/images/pde-tracing.png
Binary files differ
diff --git a/platform/4.4/final/images/platformadmin-message.png b/platform/4.4/final/images/platformadmin-message.png
new file mode 100644
index 0000000..bbb3227
--- /dev/null
+++ b/platform/4.4/final/images/platformadmin-message.png
Binary files differ
diff --git a/platform/4.4/final/images/quick-access-dialog.png b/platform/4.4/final/images/quick-access-dialog.png
new file mode 100644
index 0000000..4475ce0
--- /dev/null
+++ b/platform/4.4/final/images/quick-access-dialog.png
Binary files differ
diff --git a/platform/4.4/final/images/quick-access-hide.png b/platform/4.4/final/images/quick-access-hide.png
new file mode 100644
index 0000000..fdf2641
--- /dev/null
+++ b/platform/4.4/final/images/quick-access-hide.png
Binary files differ
diff --git a/platform/4.4/final/images/quickfix-change-compliance-1.8.png b/platform/4.4/final/images/quickfix-change-compliance-1.8.png
new file mode 100644
index 0000000..9290154
--- /dev/null
+++ b/platform/4.4/final/images/quickfix-change-compliance-1.8.png
Binary files differ
diff --git a/platform/4.4/final/images/quickfix-create-for-loop-array.png b/platform/4.4/final/images/quickfix-create-for-loop-array.png
new file mode 100644
index 0000000..2c26bdf
--- /dev/null
+++ b/platform/4.4/final/images/quickfix-create-for-loop-array.png
Binary files differ
diff --git a/platform/4.4/final/images/quickfix-create-for-loop-array.txt b/platform/4.4/final/images/quickfix-create-for-loop-array.txt
new file mode 100644
index 0000000..ab9b415
--- /dev/null
+++ b/platform/4.4/final/images/quickfix-create-for-loop-array.txt
@@ -0,0 +1,3 @@
+	void foo(int[] offsets) {
+		offsets
+	}
\ No newline at end of file
diff --git a/platform/4.4/final/images/quickfix-create-for-loop-collection.png b/platform/4.4/final/images/quickfix-create-for-loop-collection.png
new file mode 100644
index 0000000..e13ba28
--- /dev/null
+++ b/platform/4.4/final/images/quickfix-create-for-loop-collection.png
Binary files differ
diff --git a/platform/4.4/final/images/quickfix-create-for-loop-collection.txt b/platform/4.4/final/images/quickfix-create-for-loop-collection.txt
new file mode 100644
index 0000000..63af85c
--- /dev/null
+++ b/platform/4.4/final/images/quickfix-create-for-loop-collection.txt
@@ -0,0 +1,3 @@
+	void foo(Map<String, Integer> map) {
+		map.keySet()
+	}
\ No newline at end of file
diff --git a/platform/4.4/final/images/restore-btn.png b/platform/4.4/final/images/restore-btn.png
new file mode 100644
index 0000000..332b58c
--- /dev/null
+++ b/platform/4.4/final/images/restore-btn.png
Binary files differ
diff --git a/platform/4.4/final/images/search-limitto-method-reference-expression.png b/platform/4.4/final/images/search-limitto-method-reference-expression.png
new file mode 100644
index 0000000..1739b84
--- /dev/null
+++ b/platform/4.4/final/images/search-limitto-method-reference-expression.png
Binary files differ
diff --git a/platform/4.4/final/images/shown-in-system-explorer.png b/platform/4.4/final/images/shown-in-system-explorer.png
new file mode 100644
index 0000000..9c42df0
--- /dev/null
+++ b/platform/4.4/final/images/shown-in-system-explorer.png
Binary files differ
diff --git a/platform/4.4/final/images/split_editors.png b/platform/4.4/final/images/split_editors.png
new file mode 100644
index 0000000..995d433
--- /dev/null
+++ b/platform/4.4/final/images/split_editors.png
Binary files differ
diff --git a/platform/4.4/final/images/startLevels.png b/platform/4.4/final/images/startLevels.png
new file mode 100644
index 0000000..0af5232
--- /dev/null
+++ b/platform/4.4/final/images/startLevels.png
Binary files differ
diff --git a/platform/4.4/final/images/store-method-parameters.png b/platform/4.4/final/images/store-method-parameters.png
new file mode 100644
index 0000000..58c8fa8
--- /dev/null
+++ b/platform/4.4/final/images/store-method-parameters.png
Binary files differ
diff --git a/platform/4.4/final/images/tag-visibility.png b/platform/4.4/final/images/tag-visibility.png
new file mode 100644
index 0000000..a888968
--- /dev/null
+++ b/platform/4.4/final/images/tag-visibility.png
Binary files differ
diff --git a/platform/4.4/final/images/target-status.png b/platform/4.4/final/images/target-status.png
new file mode 100644
index 0000000..8e0b6c2
--- /dev/null
+++ b/platform/4.4/final/images/target-status.png
Binary files differ
diff --git a/platform/4.4/final/images/theme-association.png b/platform/4.4/final/images/theme-association.png
new file mode 100644
index 0000000..ef91b54
--- /dev/null
+++ b/platform/4.4/final/images/theme-association.png
Binary files differ
diff --git a/platform/4.4/final/images/updatePage.png b/platform/4.4/final/images/updatePage.png
new file mode 100644
index 0000000..26bd083
--- /dev/null
+++ b/platform/4.4/final/images/updatePage.png
Binary files differ
diff --git a/platform/4.4/final/images/use-overlays.png b/platform/4.4/final/images/use-overlays.png
new file mode 100644
index 0000000..64d370a
--- /dev/null
+++ b/platform/4.4/final/images/use-overlays.png
Binary files differ
diff --git a/platform/4.4/final/images/variable-coloring.png b/platform/4.4/final/images/variable-coloring.png
new file mode 100644
index 0000000..6c3a559
--- /dev/null
+++ b/platform/4.4/final/images/variable-coloring.png
Binary files differ
diff --git a/platform/4.4/final/index.html b/platform/4.4/final/index.html
new file mode 100644
index 0000000..16bddff
--- /dev/null
+++ b/platform/4.4/final/index.html
@@ -0,0 +1,34 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<html>
+<head>
+<meta name="copyright" content="Copyright (c) IBM Corporation and others 2014. This page is made available under license. For full details see: http://www.eclipse.org/legal/notice.html" >
+<meta http-equiv="Content-Language" content="en-us">
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<link rel="stylesheet" href="default_style.css" charset="ISO-8859-1" type="text/css">
+<title>Eclipse Luna - New and Noteworthy</title>
+</head>
+<body>
+
+<h1>Eclipse Luna - New and Noteworthy</h1>
+
+<div align="right"><i>
+With freedom, books, flowers, and the moon, who could not be happy?<br>
+</i> <strong>Oscar Wilde</strong>
+</div>
+
+<p>Welcome to Luna, the simultaneous Eclipse release for 2014, including
+content from seventy-six Eclipse projects. The Eclipse platform and related resources
+can be downloaded from the <a href="http://download.eclipse.org/eclipse/downloads/" target="_top">Eclipse Project downloads page</a>.
+Here are some of the more noteworthy things available in the fourteenth annual release of the Eclipse project SDK.</p>
+
+<blockquote>
+  <ul>
+    <li><a href="eclipse-news-part1.html">New features in the Platform and Equinox</a></li>
+    <li><a href="eclipse-news-part2.html">New features for Java developers</a></li>
+    <li><a href="eclipse-news-part3.html">New APIs in the Platform and Equinox</a></li>
+    <li><a href="eclipse-news-part4.html">New features for plug-in developers</a></li>
+  </ul>
+</blockquote>
+
+</body>
+</html>
