<!DOCTYPE html>
<html>

  <head>
	<meta charset="UTF-8">
	<title>Xtend - Release Notes</title>
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<meta name="description"
		content="Xtend is a statically typed programming language sitting on top of Java.">
	<meta name="author" content="Sven Efftinge">
	<meta name="author" content="Miro Spoenemann">
	<!--  styles -->
	<!-- Le HTML5 shim, for IE6-8 support of HTML5 elements -->
	<!--[if lt IE 9]>
	  <script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
	<![endif]-->
	
	<!-- Le fav and touch icons -->
	
	<link rel="shortcut icon" href="/xtend/images/favicon.png">
	
	<link href="/xtend/css/bootstrap.css" rel="stylesheet" type='text/css'>
	<link href="/xtend/css/bootstrap-responsive.css" rel="stylesheet" type='text/css'>
	<link href="/xtend/css/shield-responsive.css" rel="stylesheet" type='text/css'>
	<link href='/xtend/css/fonts.css' rel='stylesheet' type='text/css'>
	<link href="/xtend/css/prettyPhoto.css" rel="stylesheet" media="screen" type='text/css'>
	<link href="/xtend/css/prettify.css" type="text/css" rel="stylesheet"/>
	<link href="/xtend/css/style.css" rel="stylesheet" type='text/css'>
	
	<!--[if lt IE 9]>
	<link href="css/iebugs.css" rel="stylesheet" type='text/css'>
	<![endif]-->

	<!-- BEGIN Cookie Consent
	<link rel="stylesheet" type="text/css" href="//cdnjs.cloudflare.com/ajax/libs/cookieconsent2/3.0.3/cookieconsent.min.css" />
	<script src="//cdnjs.cloudflare.com/ajax/libs/cookieconsent2/3.0.3/cookieconsent.min.js"></script>
	<script>
	window.addEventListener("load", function(){
	window.cookieconsent.initialise({
		"palette": {
		"popup": {
		  "background": "#000"
		},
		"button": {
		  "background": "#f1d600"
		}
		},
		"theme": "edgeless",
		"type": "opt-in",
		onInitialise: function (status) {
		  var type = this.options.type;
		  var didConsent = this.hasConsented();
		  if (type == 'opt-in' && didConsent) {
		    // TODO: enable cookies
		  }
		  if (type == 'opt-out' && !didConsent) {
		    // TODO: disable cookies
		  }
		},
		onStatusChange: function(status, chosenBefore) {
		  var type = this.options.type;
		  var didConsent = this.hasConsented();
		  if (type == 'opt-in' && didConsent) {
		    // TODO: enable cookies
		  }
		  if (type == 'opt-out' && !didConsent) {
		    // TODO: disable cookies
		  }
		}, 
		onRevokeChoice: function() {
		  var type = this.options.type;
		  if (type == 'opt-in') {
		    // TODO: disable cookies
		  }
		  if (type == 'opt-out') {
		    // TODO: enable cookies
		  }
		},
		"content": {
		"href": "http://www.eclipse.org/legal/privacy.php"
		}
	})});
	</script>
	END Cookie Consent -->
</head>


  <body>

    <!-- Navbar -->
  <div class="navbar navbar-fixed-top"
    style="border-bottom: 1px solid #000;">
    <div class="navbar-inner">
      <div class="container">
        <a class="btn btn-navbar" data-toggle="collapse"
          data-target=".nav-collapse"> <span class="icon-bar"></span> <span
          class="icon-bar"></span> <span class="icon-bar"></span>
        </a> <a class="brand" href="/xtend/index.html"></a>
        <div class="nav-collapse collapse" style="height: 0px;">
          <ul class="nav">
            <li ><a href="/xtend/download.html">Download</a></li>
            <li ><a href="/xtend/documentation/index.html">Documentation</a></li>
            <li ><a href="/xtend/community.html">Community</a></li>
            <li ><a href="http://xtext.org">Xtext</a></li>
            <li ><a href="http://www.eclipse.org">Eclipse.org</a></li>
          </ul>
              <!--div class="btn-group pull-right">
                <div class="g-plusone" data-href="http://www.xtend-lang.org"></div>
              </div-->
        </div>
        <!--/.nav-collapse -->
      </div>
    </div>
  </div>
  <!-- Navbar End -->


    <div id="page">  
	<div class="inner">
		<div class="container">
			<br/>
				<div> 
					<h3>Table of Contents</h3>
					<ul>
						
							<li><p><a href="#/releasenotes/2023/05/29/version-2-31-0">Xtend 2.31.0 Release Notes &mdash; May 29, 2023</a></p>
						
							<li><p><a href="#/releasenotes/2023/02/27/version-2-30-0">Xtend 2.30.0 Release Notes &mdash; Feb 27, 2023</a></p>
						
							<li><p><a href="#/releasenotes/2022/11/21/version-2-29-0">Xtend 2.29.0 Release Notes &mdash; Nov 21, 2022</a></p>
						
							<li><p><a href="#/releasenotes/2022/08/29/version-2-28-0">Xtend 2.28.0 Release Notes &mdash; Aug 29, 2022</a></p>
						
							<li><p><a href="#/releasenotes/2022/05/30/version-2-27-0">Xtend 2.27.0 Release Notes &mdash; May 30, 2022</a></p>
						
							<li><p><a href="#/releasenotes/2022/02/28/version-2-26-0">Xtend 2.26.0 Release Notes &mdash; Feb 28, 2022</a></p>
						
							<li><p><a href="#/releasenotes/2021/03/02/version-2-25-0">Xtend 2.25.0 Release Notes &mdash; Mar 2, 2021</a></p>
						
							<li><p><a href="#/releasenotes/2020/12/01/version-2-24-0">Xtend 2.24.0 Release Notes &mdash; Dec 1, 2020</a></p>
						
							<li><p><a href="#/releasenotes/2020/09/01/version-2-23-0">Xtend 2.23.0 Release Notes &mdash; Sep 1, 2020</a></p>
						
							<li><p><a href="#/releasenotes/2020/06/02/version-2-22-0">Xtend 2.22.0 Release Notes &mdash; Jun 2, 2020</a></p>
						
					</ul>
				</div>
				
				  <hr/>
				  <section id="/releasenotes/2023/05/29/version-2-31-0">
				  	<h1>Xtend 2.31.0 Release Notes<small>&nbsp;&nbsp;May 29, 2023</small></h1>
				    <br/>
				    <p>Xtend 2.31.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="xtext-monorepo">Xtext Monorepo</h2>

<p>Xtext is now built from the new Monorepo at https://github.com/eclipse/xtext and built with Maven only. Many thanks to Lorenzo Bettini for the great effort to make this possible.</p>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project as part of the Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<h2 id="credits-1">Credits</h2>

<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release.</p>

<ul>
  <li>Lorenzo Bettini (Università degli Studi di Firenze)</li>
  <li>Christian Dietrich (itemis)</li>
  <li>Hannes Wellmann (IILS mbH)</li>
  <li>Christian Schneider (TypeFox)</li>
  <li>Ed Merks</li>
  <li>Sebastian Zarnekow (independent)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.31+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.31+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.30&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.30&amp;query_format=advanced&amp;status_whiteboard=v2.30&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2023/02/27/version-2-30-0">
				  	<h1>Xtend 2.30.0 Release Notes<small>&nbsp;&nbsp;Feb 27, 2023</small></h1>
				    <br/>
				    <p>Xtend 2.30.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="changes--enhancements">Changes / Enhancements</h2>

<p>The performance of (overloaded) Xbase expressions was enhanced. This makes also Xtend profit.</p>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<p>Christian Dietrich (itemis)<br />
Lorenzo Bettini (Università degli Studi di Firenze)<br />
Sebastian Zarnekow (independent)</p>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.30+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.30+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.30&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.30&amp;query_format=advanced&amp;status_whiteboard=v2.30&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2022/11/21/version-2-29-0">
				  	<h1>Xtend 2.29.0 Release Notes<small>&nbsp;&nbsp;Nov 21, 2022</small></h1>
				    <br/>
				    <p>Xtend 2.29.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="xtend-and-java-17">Xtend and Java 17</h2>
<p>Xtend now supports Java 17 as source and target, too. This requires newer Eclipse platform and JDT versions that do no longer run on Java 8. That’s why the Xtend 2.29 compiler requires Java 11 as minimal Java version. While we were at it we also bumped the minimal tested Eclipse version to 2022-03 (2.28 was still compatible to and tested against Eclipse Oxygen).</p>

<p>Please Note: We did no special treatment for newer Java constructs in Xtend, so what works, works, what does not, does not - the latter being most likely intentional. Please engage by filing bugs or pull requests.</p>

<p>A feature that was removed in the course of the upgrade was the converter from Java code to Xtend code. It did not support new language features and in most cases we think it’s more<br />
suited to write Java instead of Xtend anyways. Xtend is great for code generators and our assumption is that most code generators couldn’t be automagically translated to Xtend anyways.</p>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.29+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.29+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.29&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.29&amp;query_format=advanced&amp;status_whiteboard=v2.29&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2022/08/29/version-2-28-0">
				  	<h1>Xtend 2.28.0 Release Notes<small>&nbsp;&nbsp;Aug 29, 2022</small></h1>
				    <br/>
				    <p>Xtend 2.28.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="changes--enhancements">Changes / Enhancements</h2>

<ul>
  <li>Xtend Supports M2E 2.x</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<p>Christian Dietrich (itemis)<br />
Hannes Wellmann (IILS mbH) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></p>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.28+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.28+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.28&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.28&amp;query_format=advanced&amp;status_whiteboard=v2.28&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2022/05/30/version-2-27-0">
				  	<h1>Xtend 2.27.0 Release Notes<small>&nbsp;&nbsp;May 30, 2022</small></h1>
				    <br/>
				    <p>Xtend 2.27.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="changes">Changes</h2>

<ul>
  <li>Avoid generation of <a href="(https://github.com/eclipse/xtext-extras/issues/772)">empty lines with spaces</a> in generated java code</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Lorenzo Bettini (Università degli Studi di Firenze)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.27+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.27+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.27&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.27&amp;query_format=advanced&amp;status_whiteboard=v2.27&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2022/02/28/version-2-26-0">
				  	<h1>Xtend 2.26.0 Release Notes<small>&nbsp;&nbsp;Feb 28, 2022</small></h1>
				    <br/>
				    <p>Xtend 2.26.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="xtend-and-java-17">Xtend and Java 17</h2>

<p>Xtend now supports running on Java 17 with Java 8 and 11 targets. Source and Target 17 are not supported yet and are planned for Xtext/Xtend 2.27.0. This will also require dropping Java 8 in the next release.</p>

<h2 id="deprecations">Deprecations</h2>

<ul>
  <li>We will drop support for GWT in a future release.</li>
  <li>The next Xtend version will likely no long support Java versions below Java 11.</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<p>Christian Dietrich (itemis)<br />
Karsten Thoms (Karakun)<br />
Arne Deutsch (itemis)<br />
Sebastian Zarnekow (independent)</p>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.26+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.26+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.26&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.26&amp;query_format=advanced&amp;status_whiteboard=v2.26&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2021/03/02/version-2-25-0">
				  	<h1>Xtend 2.25.0 Release Notes<small>&nbsp;&nbsp;Mar 2, 2021</small></h1>
				    <br/>
				    <p>Xtend 2.25.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="updates">Updates</h2>

<ul>
  <li>Xtend now makes use of Guava 30.1.</li>
</ul>

<h2 id="enhancements">Enhancements</h2>

<ul>
  <li><a href="https://github.com/eclipse/xtext-xtend/issues/1029">#1029</a>: Xtend now generates less unused imports (classes from the same package).</li>
  <li><a href="https://github.com/eclipse/xtext-xtend/issues/1147">#1147</a>: <code>serialVersionUID</code> is no longer flagged as unused.</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Harald Fassler <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Tamas Miklossy (itemis)</li>
  <li>Nico Prediger (itemis)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.25+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.25+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.25&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.25&amp;query_format=advanced&amp;status_whiteboard=v2.25&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2020/12/01/version-2-24-0">
				  	<h1>Xtend 2.24.0 Release Notes<small>&nbsp;&nbsp;Dec 1, 2020</small></h1>
				    <br/>
				    <p>Xtend 2.24.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="updates">Updates</h2>

<ul>
  <li>Xtend now uses ASM 9.</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Emmanuel Chebbi (INRIA) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.24+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.24+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.24&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.24&amp;query_format=advanced&amp;status_whiteboard=v2.24&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2020/09/01/version-2-23-0">
				  	<h1>Xtend 2.23.0 Release Notes<small>&nbsp;&nbsp;Sep 1, 2020</small></h1>
				    <br/>
				    <p>Xtend 2.23.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="xtext-xtend-eclipse-and-java-11">Xtext, Xtend, Eclipse, and Java 11</h2>

<p>The Eclipse Platform and Java Development Tools have decided to migrate to Java 11 with the new 2020-09 (4.17) release. Xtext and Xtend depend on these projects both for the integration into Eclipse as well as in the LSP and standalone mode. Xtext 2.23 still works with Java 8, but if you want to work with Xtext in Eclipse 2020-09 (4.17) you have to start your Tycho builds with Java 11 as well as launch your Runtime Eclipse Applications with Java 11.</p>

<p>We decided to follow suit to close a window of opportunity for hard to find bugs. Therefore, the version 2.24 of Xtext and Xtend which is due along with Eclipse 2020-12 will be the first release that depends on Java 11. Please feel encouraged to join the discussion in <a href="https://github.com/eclipse/xtext/issues/1804">https://github.com/eclipse/xtext/issues/1804</a> if you have any concerns, general comments or other suggestions.</p>

<h2 id="eclipse-integration">Eclipse Integration</h2>

<h3 id="quickfix-improvements">Quickfix improvements</h3>

<p>A quick fix was added to create a local variable or value in addition to the option to create class members.</p>

<p><img src="/xtend/images/releasenotes/2_23_xtend-quickfix-before0.png" alt="Quick Fix: Add local var/val" height="50%" width="50%" /><br />
<img src="/xtend/images/releasenotes/2_23_xtend-quickfix-after0.png" alt="Quick Fix: Add local var/val" height="50%" width="50%" /></p>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Lorenzo Addazi (Mälardalen University Sweden)</li>
  <li>Aaron R Miller <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Tamas Miklossy (itemis)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.23+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.23+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.23&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.23&amp;query_format=advanced&amp;status_whiteboard=v2.23&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2020/06/02/version-2-22-0">
				  	<h1>Xtend 2.22.0 Release Notes<small>&nbsp;&nbsp;Jun 2, 2020</small></h1>
				    <br/>
				    <p>Xtend 2.22.0 is mainly a maintenance release with a small number of usability improvements.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="documentation">Documentation</h2>

<p>The <a href="https://www.eclipse.org/xtend/community.html">Xtend community website</a> has been updated to list the recently published videos, presentations and blog posts around Xtend. The list is not yet complete, so feel free to contact us if you are also interested in listing your articles there.</p>

<h2 id="eclipse-integration">Eclipse Integration</h2>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Tamas Miklossy (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Mathias Rieder (Bachmann)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.22+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.22+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.22&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.22&amp;query_format=advanced&amp;status_whiteboard=v2.22&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
			
		</div>
  	</div>
</div>
    
    <footer class="site-footer">
  <div id="extra">
    <div class="container inner-footer">
      <div class="row">
        <div class="span6">
          <h3 class="footer-links-header">Quick Links</h3>
          <ul class="footer-links clearfix">
            <li><a href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a></li>
            <li><a href="http://www.eclipse.org/legal/termsofuse.php">Terms of Use</a></li>
            <li><a href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a></li>
            <li><a href="http://www.eclipse.org/legal/">Legal</a></li>
          </ul>
          <ul class="footer-links clearfix">
            <li><a href="http://www.eclipse.org">Eclipse Home</a></li>
            <li><a href="http://marketplace.eclipse.org/">Market Place</a></li>
            <li><a href="http://www.planeteclipse.org/">Eclipse Planet</a></li>
            <li><a href="https://www.eclipse.org/forums/index.php/f/27/">Xtext Forum</a></li>
          </ul>
        </div>
        <div class="span6">
            <!-- Social Media Links -->
            <h3 class="footer-links-header"">Social Media</h3>
            <ul class="footer-links clearfix">
              <li>
                <a href="https://twitter.com/xtendlang"><img src="/xtend/images/Twitter-bird-darkgray.png" class="img-responsive" style="margin-right: 5px;height: 1em;" alt="Twitter icon">@xtendlang on Twitter</a>
              </li>
            </ul>
          </div>

      </div>
    </div>
  </div>
  <a href="#" class="scrollup fadeOutRight animated" style="display: none;">ScrollUp</a>
  <a href="http://dryicons.com/">Icons by http://dryicons.com</a>
  <!-- Le javascript
      ================================================== -->
  <!-- Placed at the end of the document so the pages load faster -->
  <script src="/xtend/js/jquery-1.7.1.min.js" type="text/javascript"></script>
  <script src="/xtend/js/bootstrap.min.js" type="text/javascript"></script>
  
  <!-- include pretty-print files -->
  <script src="/xtend/js/prettify.js" type="text/javascript" ></script>
  <script src="/xtend/js/lang-xtend.js" type="text/javascript"></script>
  
  <!-- Include the plug-in -->
  <script src="/xtend/js/jquery.prettyPhoto.js" type="text/javascript"></script>
  <script src="/xtend/js/jquery.easing.1.3.js" type="text/javascript"></script>
  <script src="/xtend/js/custom.js" type="text/javascript"></script>
  <!--script src="https://apis.google.com/js/platform.js" async defer></script-->
  <!--script type="text/javascript">
    var _gaq = _gaq || [];  
      _gaq.push([ '_setAccount', 'UA-2429174-4' ]);
    _gaq.push([ '_trackPageview' ]);
    (function() {
      var ga = document.createElement('script');
      ga.type = 'text/javascript';
      ga.async = true;
      ga.src = ('https:' == document.location.protocol ? 'https://ssl'
          : 'http://www')
          + '.google-analytics.com/ga.js';
      var s = document.getElementsByTagName('script')[0];
      s.parentNode.insertBefore(ga, s);
    })();
  </script-->
</footer>

  </body>

</html>
