<!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 2018, 2021."/>
<meta http-equiv="Content-Language" content="en-us"/>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<link rel="stylesheet" href="news.css" type="text/css"/>
<title>StatET News</title>

</head>
<body>

<h1>News</h1>

<p>Subscribe to the <a href="https://accounts.eclipse.org/mailing-list/statet-users" title="Mailing List: statet-users"
>mailing list</a> to keep up to date!</p>

<div class="message">
<p class="message-info" id="statet-4.4.1-r">
	<a href="https://www.eclipse.org/lists/statet-users/msg00125.html" class="message-stamp">2021-08-19
			| &#x1F4E7;[statet-users]:</a>
	<a href="https://accounts.eclipse.org/users/stwahlbrin" class="message-author">(sw)</a>
</p>
<div class="message-content">
<h3>[Ann] StatET 4.4.1 Release</h3>

<p>I am pleased to announce <a href="https://projects.eclipse.org/projects/science.statet/releases/4.4.1"
title="StatET 4.4.1 - Release Record">StatET 4.4.1</a>, the Eclipse-based IDE for the R language.</p>

<p>This is a maintenance release of <a href="#statet-4.4.0-r">StatET 4.4</a> providing bug fixes and
minor enhancements.</p>

<h5>Download / Installation</h5>

<p>To install the new version, you can use the following update site:<br/>
<code>https://download.eclipse.org/statet/releases/4.4/E202106</code><br/>
For other download options, please check the <a href="/statet/downloads/4.4.php" title="StatET 4.4 - Downloads"
>download page</a>.</p>

<p>If you use the R packages of <a href="https://gitlab.com/walware/de.walware.rj-server.gr"
title="RJSrv for GNU R">RJSrv4GR</a>, I recommend to also update these packages to the latest
release 4.0.5.</p>

<p>Thanks to everyone who has contributed to this release.</p>
</div></div>

<div class="message">
<p class="message-info" id="statet-4.4.0-r">
	<a href="https://www.eclipse.org/lists/statet-users/msg00122.html" class="message-stamp">2021-07-08
			| &#x1F4E7;[statet-users]:</a>
	<a href="https://accounts.eclipse.org/users/stwahlbrin" class="message-author">(sw)</a>
</p>
<div class="message-content">
<h3>[Ann] StatET 4.4.0 Release</h3>

<p>I am pleased to announce <a href="https://projects.eclipse.org/projects/science.statet/releases/4.4.0"
title="StatET 4.4.0 - Release Record">StatET 4.4.0</a>, the Eclipse-based IDE for the R language.</p>

<p>This release provides support for the features added in R language 4.1, in particular the forward
pipe operator and the shorthand notation for function definition, as well as several other
improvements. Details about these improvements and more noteworthy changes and features can be found
here: <a href="noteworthy-4.4.php" title="StatET 4.4 - New and Noteworthy">here</a>.</p>

<p>The new version is available for <a href="https://www.eclipse.org/downloads/packages/release/2021-06/r"
title="Eclipse IDE 2021-06 - Downloads">Eclipse IDE 2021-06</a>.
StatET 4.4 officially supports R 3.6 - 4.1, but other versions of R may work too.</p>

<h5>Download / Installation</h5>

<p>To install the new version, you can use the following update site:<br/>
<code>https://download.eclipse.org/statet/releases/4.4/E202106</code><br/>
For other download options, please check the <a href="/statet/downloads/4.4.php" title="StatET 4.4 - Downloads"
>download page</a>.</p>

<p>If you want to use the advanced console (RJ) with R, you need the R package 'rj' for your R
version as before. The packages for GNU R (<a href="https://gitlab.com/walware/de.walware.rj-server.gr"
title="RJSrv for GNU R">RJSrv4GR</a>) are not part of the Eclipse StatET project, for installation
see the <a href="https://gitlab.com/walware/de.walware.rj-server.gr/wikis/Installation" title="RJSrv for GNU R - Installation"
>instructions at the project site at GitLab</a>.<br/>
The R packages with version numbers 4.0.x (for RJ 4.0) are also compatible with StatET 4.4. I
recommend to update to the latest release 4.0.4, if not yet done, especially when using R 4.1.</p>

<p>Thanks to everyone who has contributed to this release.</p>
</div></div>

<div class="message">
<p class="message-info" id="statet-4.2.4-r">
	<a href="https://www.eclipse.org/lists/statet-users/msg00120.html" class="message-stamp">2021-03-25
			| &#x1F4E7;[statet-users]:</a>
	<a href="https://accounts.eclipse.org/users/stwahlbrin" class="message-author">(sw)</a>
</p>
<div class="message-content">
<h3>[Ann] StatET 4.2.4 Release</h3>

<p>I am pleased to announce <a href="https://projects.eclipse.org/projects/science.statet/releases/4.2.4"
title="StatET 4.2.4 - Release Record">StatET 4.2.4</a>, the Eclipse-based IDE for the R language.</p>

<p>This is a maintenance release of <a href="#statet-4.2.0-r">StatET 4.2</a> providing bug fixes and
minor enhancements.</p>

<h5>Download / Installation</h5>

<p>To install the new version, you can use the following update site:<br/>
<code>https://download.eclipse.org/statet/releases/4.2/E202006</code><br/>
For other download options, please check the <a href="/statet/downloads/4.2.php" title="StatET 4.2 - Downloads"
>download page</a>.</p>

<p>Thanks to everyone who has contributed to this release.</p>
</div></div>

<div class="message">
<p class="message-info" id="statet-4.3.0-r">
	<a href="https://www.eclipse.org/lists/statet-users/msg00112.html" class="message-stamp">2021-02-18
			| &#x1F4E7;[statet-users]:</a>
	<a href="https://accounts.eclipse.org/users/stwahlbrin" class="message-author">(sw)</a>
</p>
<div class="message-content">
<h3>[Ann] StatET 4.3.0 Release</h3>

<p>I am pleased to announce <a href="https://projects.eclipse.org/projects/science.statet/releases/4.3.0"
title="StatET 4.3.0 - Release Record">StatET 4.3.0</a>, the Eclipse-based IDE for the R language.</p>

<p>This release focus on improvements in the RJ library and full support of Java 11. Please note
that Java version 10 and lower is no longer supported by Eclipse IDE 2020-12 and StatET 4.3, see
also <a href="noteworthy-4.3.php" title="StatET 4.3 - New and Noteworthy">here</a>.</p>

<p>The new version is available for <a href="https://www.eclipse.org/downloads/packages/release/2020-12/r"
title="Eclipse IDE 2020-12 - Downloads">Eclipse IDE 2020-12</a>.
StatET 4.3 officially supports R 3.5 - 4.0, but other versions of R may work too.</p>

<h5>Download / Installation</h5>

<p>To install the new version, you can use the following update site:<br/>
<code>https://download.eclipse.org/statet/releases/4.3/E202012</code><br/>
For other download options, please check the <a href="/statet/downloads/4.3.php" title="StatET 4.3 - Downloads"
>download page</a>.</p>

<p>If you want to use the advanced console (RJ) with R, you need the R package 'rj' for your R
version as before. The packages for GNU R (<a href="https://gitlab.com/walware/de.walware.rj-server.gr"
title="RJSrv for GNU R">RJSrv4GR</a>) are not part of the Eclipse StatET project, for installation
see the <a href="https://gitlab.com/walware/de.walware.rj-server.gr/wikis/Installation" title="RJSrv for GNU R - Installation"
>instructions at the project site at GitLab</a>.<br/>
The R packages with version numbers 4.0.x (for RJ 4.0) are also compatible with StatET 4.3. I
recommend to update to the latest release 4.0.2, if not yet done. </p>

<p>Thanks to everyone who has contributed to this release.</p>
</div></div>

<div class="message">
<p class="message-info" id="statet-4.2.3-r">
	<a href="https://www.eclipse.org/lists/statet-users/msg00111.html" class="message-stamp">2021-02-11
			| &#x1F4E7;[statet-users]:</a>
	<a href="https://accounts.eclipse.org/users/stwahlbrin" class="message-author">(sw)</a>
</p>
<div class="message-content">
<h3>[Ann] StatET 4.2.3 Release</h3>

<p>I am pleased to announce <a href="https://projects.eclipse.org/projects/science.statet/releases/4.2.3"
title="StatET 4.2.3 - Release Record">StatET 4.2.3</a>, the Eclipse-based IDE for the R language.</p>

<p>This is a maintenance release of <a href="#statet-4.2.0-r">StatET 4.2</a> providing bug fixes and
minor enhancements.</p>

<h5>Download / Installation</h5>

<p>To install the new version, you can use the following update site:<br/>
<code>https://download.eclipse.org/statet/releases/4.2/E202006</code><br/>
For other download options, please check the <a href="/statet/downloads/4.2.php" title="StatET 4.2 - Downloads"
>download page</a>.</p>

<p>Thanks to everyone who has contributed to this release.</p>
</div></div>

<div class="message">
<p class="message-info" id="statet-4.2.2-r">
	<a href="https://www.eclipse.org/lists/statet-users/msg00097.html" class="message-stamp">2020-12-31
			| &#x1F4E7;[statet-users]:</a>
	<a href="https://accounts.eclipse.org/users/stwahlbrin" class="message-author">(sw)</a>
</p>
<div class="message-content">
<h3>[Ann] StatET 4.2.2 Release</h3>

<p>I am pleased to announce <a href="https://projects.eclipse.org/projects/science.statet/releases/4.2.2"
title="StatET 4.2.2 - Release Record">StatET 4.2.2</a>, the Eclipse-based IDE for the R language.</p>

<p>This is a maintenance release of <a href="#statet-4.2.0-r">StatET 4.2</a> providing bug fixes and
minor enhancements.</p>

<h5>Download / Installation</h5>

<p>To install the new version, you can use the following update site:<br/>
<code>https://download.eclipse.org/statet/releases/4.2/E202006</code><br/>
For other download options, please check the <a href="/statet/downloads/4.2.php" title="StatET 4.2 - Downloads"
>download page</a>.</p>

<p>Thanks to everyone who has contributed to this release.</p>
</div></div>

<div class="message">
<p class="message-info" id="statet-4.2.1-r">
	<a href="https://www.eclipse.org/lists/statet-users/msg00095.html" class="message-stamp">2020-11-12
			| &#x1F4E7;[statet-users]:</a>
	<a href="https://accounts.eclipse.org/users/stwahlbrin" class="message-author">(sw)</a>
</p>
<div class="message-content">
<h3>[Ann] StatET 4.2.1 Release</h3>

<p>I am pleased to announce <a href="https://projects.eclipse.org/projects/science.statet/releases/4.2.1"
title="StatET 4.2.1 - Release Record">StatET 4.2.1</a>, the Eclipse-based IDE for the R language.</p>

<p>This is a maintenance release of <a href="#statet-4.2.0-r">StatET 4.2</a> providing bug fixes and
minor enhancements.</p>

<h5>Download / Installation</h5>

<p>To install the new version, you can use the following update site:<br/>
<code>https://download.eclipse.org/statet/releases/4.2/E202006</code><br/>
For other download options, please check the <a href="/statet/downloads/4.2.php" title="StatET 4.2 - Downloads"
>download page</a>.</p>

<p>Thanks to everyone who has contributed to this release.</p>
</div></div>

<div class="message">
<p class="message-info" id="statet-4.2.0-r">
	<a href="https://www.eclipse.org/lists/statet-users/msg00094.html" class="message-stamp">2020-10-01
			| &#x1F4E7;[statet-users]:</a>
	<a href="https://accounts.eclipse.org/users/stwahlbrin" class="message-author">(sw)</a>
</p>
<div class="message-content">
<h3>[Ann] StatET 4.2.0 Release</h3>

<p>I am pleased to announce <a href="https://projects.eclipse.org/projects/science.statet/releases/4.2.0"
title="StatET 4.2.0 - Release Record">StatET 4.2.0</a>, the Eclipse-based IDE for the R language.</p>

<p>This release provides full support for R 4.0, especially support for the newly added raw string
literals in the R language. Details about these improvements and more noteworthy changes
and features are presented <a href="noteworthy-4.2.php" title="StatET 4.2 - New and Noteworthy">here</a>.</p>

<p>The new version is available for <a href="https://www.eclipse.org/downloads/packages/release/2020-06/r"
title="Eclipse IDE 2020-06 - Downloads">Eclipse IDE 2020-06</a>;
it is not compatible with Eclipse IDE 2020-09.
StatET 4.2 officially supports R 3.5 - 4.0, but other versions of R may work too.</p>

<h5>Download / Installation</h5>

<p>To install the new version, you can use the following update site:<br/>
<code>https://download.eclipse.org/statet/releases/4.2/E202006</code><br/>
For other download options, please check the <a href="/statet/downloads/4.2.php" title="StatET 4.2 - Downloads"
>download page</a>.</p>

<p>If you want to use the advanced console (RJ) with R, you need the R package 'rj' for your R
version as before. The packages for GNU R (<a href="https://gitlab.com/walware/de.walware.rj-server.gr"
title="RJSrv for GNU R">RJSrv4GR</a>) are not part of the Eclipse StatET project, for installation
see the <a href="https://gitlab.com/walware/de.walware.rj-server.gr/wikis/Installation" title="RJSrv for GNU R - Installation"
>instructions at the project site at GitLab</a>.<br/>
The R packages with version numbers 4.0.x (for RJ 4.0) are also compatible with StatET 4.2. There is
no separate version for StatET/RJ 4.2.</p>

<p>Thanks to everyone who has contributed to this release.</p>
</div></div>

<div class="message" id="statet-4.1.0-r">
<p class="message-info">
	<a href="https://www.eclipse.org/lists/statet-users/msg00067.html" class="message-stamp">2020-03-05
			| &#x1F4E7;[statet-users]:</a>
	<a href="https://accounts.eclipse.org/users/stwahlbrin" class="message-author">(sw)</a>
</p>
<div class="message-content">
<h3>[Ann] StatET 4.1.0 Release</h3>

<p>I am pleased to announce <a href="https://projects.eclipse.org/projects/science.statet/releases/4.1.0"
title="StatET 4.1.0 - Release Record">StatET 4.1.0</a>, the Eclipse-based IDE for the R language.</p>

<p>This release focus on improvements of the content and context information assistants in the
source editors and console of StatET. Details about these improvements and more noteworthy changes
and features are presented <a href="noteworthy-4.1.php" title="StatET 4.1 - New and Noteworthy">here</a>.</p>

<p>The new version is available for <a href="https://www.eclipse.org/downloads/packages/release/2019-12/r"
title="Eclipse IDE 2019-12 - Downloads">Eclipse IDE 2019-12</a>.
It officially supports R 3.5 - 3.6, but other versions of R may work too.</p>

<h5>Download / Installation</h5>

<p>To install the new version, you can use the following update site:<br/>
<code>https://download.eclipse.org/statet/releases/4.1/E201912</code><br/>
For other download options, please check the <a href="/statet/downloads/4.1.php" title="StatET 4.1 - Downloads"
>download page</a>.</p>

<p>If you want to use the advanced console (RJ) with R, you need the R package 'rj' for your R
version as before. The packages for GNU R (<a href="https://gitlab.com/walware/de.walware.rj-server.gr"
title="RJSrv for GNU R">RJSrv4GR</a>) are not part of the Eclipse StatET project, for installation
see the <a href="https://gitlab.com/walware/de.walware.rj-server.gr/wikis/Installation" title="RJSrv for GNU R - Installation"
>instructions at the project site at GitLab</a>.<br/>
The R packages with version numbers 4.0.x (for RJ 4.0) are also compatible with StatET 4.1. There is
no separate version for StatET/RJ 4.1.</p>
</div></div>

<div class="message">
</div>

</body>
</html>
