<?xml version="1.0" encoding="UTF-8"?>
<!-- The structure of the news items are
    
    <news>
    <item title="" date="YYYY-MM-DDThh:mm:ss">
    News content
    </item>*
    </news>
    
    Add your item to the top of the list.  Do not delete or move any items.  We generate permalinks by inverse file position.
    Please post in UTC.  The correct current time can be found at: http://www.time.gov/timezone.cgi?UTC/s/0/java
    All links must be absolute!  If you do not specify a link, a link to your entry on the Web Tools News page will be
    generated for you.

    For announcements about releases, the release page is used because the download site will change after archival.
-->
<news>
    <item
		date="2017-06-28"
        title="Papyrus 3.0.0 Oxygen Released"
        link="http://projects.eclipse.org/projects/modeling.mdt.papyrus/releases/3.0.0">
        <p>
            The Eclipse Papyrus 3.0.0 Neon release is now available!
            You'll be able to install it using the <a href="http://download.eclipse.org/modeling/mdt/papyrus/updates/releases/oxygen/">Oxygen update site</a>.
        </p>
    </item>
    <item
		date="2017-03-23"
        title="Papyrus 2.0.3 Neon.3 Released"
        link="http://projects.eclipse.org/projects/modeling.mdt.papyrus/releases/2.0.3">
        <p>
            The Eclipse Papyrus 2.0.3 Neon release is now available!
            You'll be able to install it using the <a href="http://download.eclipse.org/modeling/mdt/papyrus/updates/releases/neon/">Neon update site</a>.
        </p>
    </item>
    <item
		date="2017-01-10"
        title="Papyrus 2.0.2 Neon.2 Released"
        link="http://projects.eclipse.org/projects/modeling.mdt.papyrus/releases/2.0.2">
        <p>
            The Eclipse Papyrus 2.0.2 Neon release is now available!
            Go to the <a href="https://www.eclipse.org/papyrus/download.html">Download page</a> to install Papyrus.
        </p>
    </item>
    <item
		date="2016-10-06"
        title="Papyrus 2.0.1 Neon.1 Released"
        link="http://projects.eclipse.org/projects/modeling.mdt.papyrus/releases/2.0.1">
        <p>
            The Eclipse Papyrus 2.0.1 Neon release is now available!
            Go to the <a href="https://www.eclipse.org/papyrus/download.html">Download page</a> to install Papyrus.
        </p>
    </item>
	<item
		date="2016-07-01"
        title="Papyrus Use Case Story"
        link="/papyrus/testimonials.html">
        <p>
            A new Papyrus Use Case Story entitled "Designing freedom of flight" from Airbus is <a href="/papyrus/resources/airbus-usecasestory.pdf" target="_blank">available here</a>.
        </p>
    </item>
    <item
		date="2016-06-24"
        title="Papyrus 2.0.0 Neon Released"
        link="http://projects.eclipse.org/projects/modeling.mdt.papyrus/releases/2.0.0">
        <p>
            The Eclipse Papyrus 2.0.0 Neon release is now available!
            Go to the <a href="https://www.eclipse.org/papyrus/download.html">Download page</a> to install Papyrus.
        </p>
    </item>
    <item
		date="2016-06-23"
		title="New videos in Papyrus youtube channel"
		link="https://www.youtube.com/channel/UCxyPoBlZc_rKLS7_K2dtwYA">
		<p>
            <ul>
                <li><a href="https://youtu.be/eW1qut4NO_k">"Papyrus Information Modeling Preview"</a></li>
                <li><a href="https://youtu.be/-k1xWJr4wg0">"Modeling and Safety Analysis of Nao Robot"</a></li>
			</ul>
        </p>
	</item>
    <item
		date="2016-06-18"
		title="Papyrus at Incose Edinburgh 2016"
		link="http://www.incose.org/symp2016/">
		<p>Papyrus will be present in the Polarsys booth : 
            <ul>
                <li><a href="https://www.polarsys.org/polarsys-incose-international-symposium-2016">"Polarsys announcement"</a></li>
			</ul>
        </p>
	</item>
    <item
		date="2016-04-26"
		title="Talks at EclipseCon France 2016"
		link="https://www.eclipsecon.org/france2016/">
		<p>Some presentations about or related to Papyrus will be given during EclipseCon France 2016 : 
            <ul>
                <li><a href="https://www.eclipsecon.org/france2016/session/lessons-learned-migrating-industrial-development-proprietary-commercial-tool-papyrus">"Lessons Learned from Migrating Industrial Development from Proprietary Commercial Tool to Papyrus"</a></li>
                <li><a href="https://www.eclipsecon.org/france2016/session/close-encounters-requirements-sysml">"Close Encounters of Requirements with SysML"</a></li>
			</ul>
        </p>
	</item>
	<item
		date="2016-04-21"
		title="Eclipse Newsletter on Model-Based Engineering"
		link="https://www.eclipse.org/community/eclipse_newsletter/2016/april/">
		<p>This month, the Eclipse Newsletter focuses on Model-Based Engineering. Some applications of Papyrus for MBE and the last developments of Papyrus are presented in four detailed articles. <a href="https://www.eclipse.org/community/eclipse_newsletter/2016/april/">Details here.</a>
        </p>
	</item>
    <item
		date="2016-03-08"
		title="Papyrus, a full-fledged framework for empowering model-based engineering for better complex systems"
		link="http://www.cea-tech.fr/cea-tech/english/Pages/news/latest-news/model-based-engineering-for-better-complex-systems-systems-engineering.aspx">
		<p>Thanks to Papyrus, engineers from various industrial domains can put model-based engineering to work for their systems and software engineering projects. <a href="http://www.cea-tech.fr/cea-tech/english/Pages/news/latest-news/model-based-engineering-for-better-complex-systems-systems-engineering.aspx">Details here.</a>
        </p>
	</item>
    <item
		date="2016-03-04"
		title="Papyrus used to simplify distribution of computing tasks in complex systems"
		link="http://www.cea-tech.fr/cea-tech/english/Pages/news/latest-news/simpler-distribution-of-computing-tasks-in-complex-systems-advanced-manufacturing.aspx">
		<p>Researchers at List, a CEA Tech institute, have developed a technique and related tools based on Papyrus for distributing software across machines in complex systems. This novel technique is faster and more efficient than the traditional method. <a href="http://www.cea-tech.fr/cea-tech/english/Pages/news/latest-news/simpler-distribution-of-computing-tasks-in-complex-systems-advanced-manufacturing.aspx">Details here.</a>
        </p>
	</item>
    <item
		date="2015-12-21"
		title="EclipseCon NA 2016"
		link="https://www.eclipsecon.org/na2016/">
		<p>Some presentations about or related to Papyrus will be given during EclipseCon NA 2016 : 
            <ul>
			<li><a href="https://www.eclipsecon.org/na2016/session/uml-gone-wild-lego-experience">"UML gone wild: the Lego experience"</a></li>
			<li><a href="https://www.eclipsecon.org/na2016/session/papyrus-real-time-executable-modeling-eclipse">"Papyrus for Real Time: Executable modeling on Eclipse"</a></li>
			<li><a href="https://www.eclipsecon.org/na2016/session/tailor-made-model-comparison-how-customize-emf-compare-your-modeling-language">"Tailor-made model comparison: how to customize EMF Compare for your modeling language"</a></li>
			</ul>
        </p>
	</item>
    <item
		date="2015-12-01"
		title="Papyrus 1.1.3 Released"
		link="https://www.eclipse.org/papyrus/download.html">
		<p>The Eclipse Papyrus 1.1.3 release is now available! </p>
		<p>Go to <a href="https://www.eclipse.org/papyrus/download.html">Download page</a> to install Papyrus. </p>
	</item>
	<item
		date="2015-11-03"
		title="2nd Papyrus Summit and EclipseCon Europe 2015"
		link="https://www.eclipsecon.org/europe2015/">
		<p>The <a href="https://wiki.eclipse.org/Papyrus/SummitEclipseConEurope2015">2nd Papyrus Summit</a> will be held Tuesday November 3, 2015 in Ludwigsburg, Germany. </p>
		<p>The Papyrus Team will also give a couple of presentations during EclipseCon Europe 2015 : <a href="https://www.eclipsecon.org/europe2015/session/papyrus4java-uml-diagrams-ordinary-java-developers">"Papyrus4Java - UML diagrams for ordinary java developers"</a> and <a href="https://www.eclipsecon.org/europe2015/session/mde-papyrus-novelties-and-beyond-sponsored-cea-list">"MDE with Papyrus, novelties and beyond"</a></p>
	</item>
	<item
		date="2015-06-24"
		title="Papyrus 1.1.0 Released"
		link="https://www.eclipse.org/papyrus/download.html">
		<p>The Eclipse Papyrus 1.1.0 release is now available! Check the new features on the <a href="https://wiki.eclipse.org/Papyrus/NewAndNoteworthy/Mars">what's new?</a> page.</p>
		<p>You can install Papyrus from the <a href="https://www.eclipse.org/mars/">Mars packages</a> or use the <a href="https://www.eclipse.org/papyrus/downloads/">Papyrus Downloads page</a></p>
	</item>
	<item
        date="2014-12-12T08:30:00"
        title="Save the date!"
        link="http://www.eclipse.org/papyrus/news/save_the_date_CEA breakfast.pdf">
        <p><b>INVITATION BUSINESS BREAKFAST CEA TECH (WITH THE PARTICIPATION OF ERICSSON)</b></p>
			<p>Your system design needs modeling: Papyrus, the MDE open-source cutting-edge solution
			<ul><li>Thursday, January 29th 2015, at hotel Napoleon Paris</li></ul>
			</p>
			<p>If you cannot come to Paris, we invite you to join a web-conference on the same subject
			Friday, January 30th 2015 at 10 am
			</p>
			<p>
			Why participate? 
			<ul>
			<li>You will understand the strategic value of Papyrus modeling tool</li>
			<li>You will understand how to leverage both standard modeling languages (e.g., UML and SysML) and domain-specific modeling languages.</li>
			<li>You will listen and exchange around the feedback from the company ERICSSON</li>
			</ul>
			Send us an email to register (dils -at- cea.fr) 
			</p>
    </item>
	<item
        date="2014-06-25T14:30:00"
        title="Papyrus 1.0.0 Released"
        link="http://projects.eclipse.org/projects/modeling.mdt.papyrus/releases/1.0.0">
       The Eclipse Papyrus 1.0.0 release is now available! For a short listing of the new features available in this release, check
        <a href="https://wiki.eclipse.org/Papyrus/NewAndNoteworthy/Luna">the release plan</a>.
        You can easily install Papyrus from 
        <a href="http://www.eclipse.org/luna/">Luna packages</a> or use the <a href="https://www.eclipse.org/papyrus/downloads/">Papyrus Downloads page</a>.
    </item>    
</news>