Groovy 2.0.4 released
The Groovy development team's just released Groovy 2.0.4, a bug fix for our Groovy 2.0 branch.
It fixes some important issues we've had with generics with the stub generator, as well as several fixes related to the static type checking and static compilation features. We also worked on the recompilation issues with the GroovyScriptEngine.
You can download Groovy 2.0.4 here:
The artifacts are not yet on Maven Central, but will shortly.
Also, the online JavaDoc and GroovyDoc are still being uploaded as I write this, but will hopefully be online in a few hours.
You can have a look at the issues fixed in this release on JIRA:
If you're curious why we've jumped from 2.0.2 to 2.0.4, skipping 2.0.3, it's because of some issues with the release of 2.0.3 which I had mistakenly built with JDK 6 instead of JDK 7, which ruled out all our invoke dynamic support. So we quickly moved to 2.0.4.
We'll certainly also release a 1.8.9 soon, especially for the stub generator fixes which might be useful for those affected with the issues we've fixed.
This is with great pleasure that the Groovy development team announces the releases of Groovy 2.0.2 and Groovy 1.8.8

Those two releases are essentially just bug fix releases, with only minor improvements. In particular, work has been done in the area of the static type checker and static compilation, in the GroovyScriptEngine, as well as further performance improvements for the "invoke dynamic" support as well as plain Groovy. We also upgraded the version of GPars of the distribution to use the newly released 1.0-beta-3.
For the details of both releases, please have a look at the JIRA changelog here: for Groovy 2.0.2:, and for Groovy 1.8.8:

As usual, you can download Groovy in our download area:
Thanks a lot to all those who contributed to those releases.

I'd also like to seize this opportunity to highlight our contribution page, to those who are interested in contributing to Groovy

Going forward, we're going to propose a list of JIRA issues you might have a look at, if you want to get started working on the Groovy project:

And on the contribution page mentioned above, at the bottom of the page, we feature a table containing wider goals or side projects that you might be interested in contributing to. 

So don't hesitate to come back to us with ideas or with questions regarding those possible areas of contributions, and we'll gladly welcome your help!
The Groovy development team is happy to announce the releases of Groovy 2.0.1, 1.8.7 and 1.7.11!

That's the first time we release three versions at the same time.

Those three versions are essentially just bug fix releases. 
The 1.8.7 release contains a lot of the bugfixes that were already integrated in Groovy 2.0.0, so it's just an alignment with the Groovy 2 branch. 
In the future, Groovy 1.8.x and Groovy 2.x will be maintained in parallel. But the Groovy 1.7 branch is now in end-of-life and won't be maintained further.

In terms of improvements, you might notice some performance gains with the "invoke dynamic" version, or you'll notice that you can use the Groovy Console in full-screen mode on Mac OS X.

A lot of attention has particularly been put into the bug fixes of the new features of Groovy 2.0.
In particular, the static type checking and static compilation features got the lion share of fixes.
We also restored the OSGi manifest information. 
So if you're using OSGi, please report back to us if you see any remaining quirk when using Groovy in an OSGi container.
However, there's still a known issue for the "invoke dynamic" JARs of Groovy, as neither the OSGi Gradle plugin nor the underlying bnd library have been updated to cope with the "invoke dynamic" bytecode instruction, so we'll have to wait for the releases of both before being able to get proper OSGi support in our "indy" deliverables.

You can download those latest Groovy versions from here:

And here are the JIRA release notes for 2.0.1 in particular (but you'll find the notes for 1.8.7 and 1.7.11 on the download page too):

Thanks a lot for your attention, and big thanks to all those who contributed to those releases!

Keep on groovying!
Groovy 2.0 released

Dear all,
The Groovy development team is very pleased to announce the release of Groovy 2.0, the highly popular dynamic language for the Java platform.
For the key highlights of this important milestone, Groovy 2.0 comes packed with:

  • a static type checker to let the compiler tell you about the correctness of your code,
  • static compilation for the performance of the critical parts of your application,
  • modularity, splitting the Groovy JAR into smaller feature-oriented JARs and letting you create your own extension modules,
  • JDK 7 Project Coin syntax enhancements, so that Groovy is still as friendly as possible with its Java cousin,
  • and JDK 7 Invoke Dynamic integration to benefit from the support of the JVM for dynamic languages.

To learn more about all those great key new features, please read the Groovy 2.0 article on InfoQ that I’ve written, detailing and explaining all those novelties.
To download Groovy 2.0, go to the download area of the Groovy website.
For further information on all the JIRA issues fixed in this release and the various betas and release candidates, you can have a look at the JIRA changelog.
We’d like to thank all our users, all the contributors and committers who made this important release a reality, thanks to their feedback, their support, and their contributions.
Have a Groovy day!
Guillaume Laforge, on the behalf of the Groovy team.

The Groovy development team is pleased to announce the release of the last beta version in the 2.0.0 release cycle!

This version introduces two major enhancements: the @CompileStatic annotation (which enables static compilation of Groovy code) and support for invokedynamic (known as indy)!

If you already gave a try to the static type checker available in previous beta releases of Groovy 2.0, static compilation is a step further. Basically, replacing the @TypeChecked annotation with @CompileStatic, your code will be statically compiled.

Support for the new "invokedynamic" JVM instructions is also bundled into this distribution. However, as we must maintain binary compatibility with previous versions of Groovy and JDKs (especially, support for JDK 5 and 6), the indy-enabled version of Groovy is available in a separate jar. If you use Maven, Ivy or Gradle, the jar is available using the "indy" classifier. If you use the distribution zip, you will find two jars in a separate directory ("indy"), corresponding to groovy.jar and groovy-all.jar (for embedded version).

We strongly encourage you to test both static compilation (and type checking) and invoke dynamic support because this release is the last beta: the next Groovy version will be an RC with modularisation included. More than ever, we need beta testers!

You can download Groovy 2.0.0-beta-3 at the regular place:

For those who are interested in bug fixes since beta 2, you can read the release notes:

Thanks to all our contributors and all your feedback!
Groovy 1.8.6 is out

The Groovy development team is pleased to announce the release of Groovy 1.8.6.

Groovy 1.8.6 is a maintenance release essentially, with a few minor improvements and new features.
You can see the details of the JIRA release notes here:

You can download Groovy 1.8.6 in the Download section of the Groovy website: 

Thanks a lot to all those who contributed to this release!

Next in line will a new beta of Groovy 2.0!

GR8Conf are conferences about all the great technologies based on or using Groovy in a way or another. So in other words, that's the grooviest conference you can find, where developers and leads of all the famous Groovy-based projects deliver the latest news and updates about their projects. So be sure to come, learn with them, engage with the community, tell about your usage of those technologies (Grails, Gradle, Griffon, Spock, Gaelyk, etc.)

GR8Conf Europe and GR8Conf US have their Call for Paper still open, for less than a week. So if you haven't yet submitted your proposals, please hurry up!

We're looking forward to having you here!

The Groovy development team is happy to deliver two new releases as early Christmas presents: Groovy 1.8.5 and 2.0-beta-2.
While we work hard on Invoke Dynamic support, Static Type Checking and some experimental Static Compilation, we also find time to fix a good load of bugs and some minor improvements, as those two releases here are essentially minor incremental versions.
You can have a look at the tickets closed here, for 1.8.5:
And here for 2.0-beta-2:
You can download both distributions at the usual place:
If you want to play with the experimental static compilation, you can do so by following the instructions from the GEP-10 page:
Look for the "testing" paragraph in the middle of the document, which contains a link to the experimental JAR, as well as some basic explanations.
And please continue reporting your findings on the static type checking as well.
Thanks a lot to all those who contributed to this release: developers, contributors, users, bug reporters.
On behalf of the Groovy development team, we'd like to wish you a Groovy Christmas and a very Happy New Year.

It is with great pleasure that we are announcing another joint release today! 

We have released Groovy 1.8.4, that includes fixes and minor improvements to correct problems the Grails web framework and the Gradle build automation tool were having with 1.8.3.

In addition, we are also pleased to announce the release of Groovy 2.0-beta-1!

Groovy's updated version numbering scheme

Yes, you heard it, a Groovy 2.0 beta! But what's going on, weren't we working on the 1.9 line? Yes, we were, but with the substantial number of new features coming up in the 1.9 release, we thought it was time to start using an updated numbering scheme. 

Historically, Groovy's "major" versions have always been "dot" versions, which is a bit uncommon in our industry, in the sense that major versions are expected to have a new major digit each time. So the Groovy version numbering scheme has always been a bit odd for strangers and newcomers -- furthermore, from a marketing perspective, if we ever decide to release a 1.10 version, it would be lexicographically backward (1.10 < 1.9 in math)! This isn't the first time a major change in version numbers has happened: Groovy went from 1.1 to 1.5 and recently Grails changed from 1.4 to 2.0 for its next major release. 

So instead of speaking of the mythical "2.0" version of Groovy that never seems to arrive, this next major release will be 2.0. For further versions, we'll probably release some 2.x versions as well, but we will also adopt the same strategy regarding major version numbers, releasing a major version more or less every year. Thus, given 2.0 final should be out in early 2012, the following major version will be released afterwards in 2013 and will become 3.0. But don't worry, we won't adopt the lightning fast numbering schemes of Google Chrome or Mozilla Firefox!

So what will be inside 2.0 that makes it so special?

Static type checking

We have been working on the static type checking support for Groovy

On several occasions, we have noticed that Groovy was used in Java projects as a simple yet powerful scripting language for Java APIs, in ways that don't particularly leverage the dynamic aspects of the language but instead as a better syntax for Java somehow. With this approach, developers often prefer a stricter approach to type checking, in the sense it should complain when you have typos in your method names, parameters or variables or when you make invalid assignments, etc. The compiler should complain at compile time, rather than having Groovy complain at execution time later on, thus giving you earlier feedback about those errors — particularly useful when you are using APIs that may change.

Static type checking has already been discussed on a few threads on the Groovy mailing-lists, and we appreciate your feedback on how it's being implemented, how it should behave, and so on. Please don't hesitate to come back to us with your thoughts and ideas on this topic.

We have also created a GEP (Groovy Extension Proposal) covering this new aspect:

And Cédric, who joined Jochen and myself at SpringSource/VMware and who's been working on this feature, wrote a very nice and detailed blog post about the current work-in-progress here:

Be sure to read those two documents, as they will guide you through some interesting samples showing how you can get started using static type checking with Groovy 2.0.0-beta-1! Please also note that this is still in beta, and that APIs are subject to change and evolve depending on your feedback.

Static compilation

With static type checking, type inference capabilities, sensitive flow typing, and so on, the Groovy compiler is now way smarter in figuring out what your code is actually doing. In the case of scripting Java APIs that we mentioned above, we could let the compiler generate direct method calls à la Java, instead of going through Groovy's Meta-Object Protocol, allowing the same performance as Java

We're going to investigate static compilation in 2.0, leveraging the new smarts of the compiler and its infrastructure, by creating a new git branch with initial support that you'll be able to monitor to watch our progress on that front.

But what about Groovy++?

Thanks to the great work of Alex Tkachman and Roshan Dawrani, the Groovy++ extension project definitely inspired us and ended up convincing us that it was important to support static type checking and compilation in Groovy. 
We couldn't simply integrate Groovy++ directly in Groovy 2.0, as it differed in spirit from our ideas for Groovy core, for example by covering more ground than we wanted and needed (persistent collections, new operators, traits, new map-style classes, etc.). We also wanted to evolve the Groovy compiler infrastructure so that it fits nicely with the primitive optimizations work, static type checking and compilation, as well as invoke dynamic support, and we would have needed to refactor Groovy++ heavily for our needs.  That said, we of course would welcome collaboration with the Groovy++ team to learn from their experiences building Groovy++.

We engaged the community to discuss various aspects of static type checking and inference so as to make it closer to the usual Groovy semantics as much as possible, without introducing new data structures or restricting existing features (like closures with non-final variables), so that Groovy developers feel at ease with static type checking and compilation, and are the least impacted by differences in semantics between this additional mode and the classical dynamic mode.

Invoke dynamic support

Lastly, we've started working on "invoke dynamic" support, the new JVM bytecode instruction and APIs of JDK 7 developed for dynamic languages, with the goal of improving the performance of all the dynamic aspects of Groovy in significant ways. This is still early days, and this first beta of 2.0 doesn't yet contain particular changes that you'd notice. We are working on the "indy" branch of Git (and mirrored on GitHub) for that support.

And beyond 2.0?

With static type checking and compilation, as well as invoke dynamic support, we thought that it was really worth a Groovy 2.0 moniker! But what's next?

Among the things we want to tackle for 2.x / 3.0 and beyond, we're interested in moving the Groovy grammar from Antlr 2.x to a newer version. Antlr 3 has been available for a while, but our summer attempt at migrating to it haven't been fruitful so far. But we will investigate this move once 2.0 is out, and decide if we go with Antlr 3 or Antlr 4 which should be available when we want to release 3.0.

In the past, we've mentioned several times a redesigned Meta-Object Protocol (MOP 2). With the lessons learned in the invoke dynamic support of Groovy 2.0 and with the ironing out of the invoke dynamic performance of the JIT, we should be able to have a better vision of how to rearchitect the MOP so that it fully takes advantage of invoke dynamic, for faster dynamic features.

There are many other things we'd like to have a look at, but it's still a bit too early to tell what's going to be in Groovy 3 and beyond, as of today. We have time to see what's interesting to add to Groovy to continue helping you being more productive developers, and we will continue to welcome and appreciate your feedback and what you'd like to have in Groovy in the future to simplify your life

Groovy is what it is today thanks to your ideas and contributions!

You can view the changelog on JIRA for the details:

And you can download the new releases from the usual download area on the Groovy website:

Thanks a lot to everybody involved, and we're looking forward to your feedback!

The Groovy development team

The now famous GR8Conf conference dedicated to all things Groovy, is now coming to Australia, as announced on the GR8Conf blog! It will take place in Canberra, side by side with the Open Source Developers Conference (OSDC), on November 15th.

The GR8Conf Australia website is already up and is running a Call for Papers. So if you have a presentation on Groovy, Grails, Griffon, Gradle, Spock, CodeNarc, Gaelyk, etc, with introductions, deep dives, case studies, and so on, feel free to submit a talk!

Groovy completed successfully its move to the Git SCM this summer, thanks to Matthew McCullough's help.
For helping everybody get up-to-speed with Git, I've added a page about Git on our wiki.

We now have a "groovy" organization on GitHub:

Our three main branches have been pushed there: master, GROOVY_1_8_X and GROOVY_1_7_X.

The GitHub repository serves as a mirror, and the Groovy despots will be able to regularly (manually for now) push the latest changes to GitHub, and deal with pull requests and such.

The Groovy website now features a new skin. Make sure to check it out.

In the coming months, we'll work on overhauling the documentation and the website, it's going to be a lot of work and will take a lot of time.
We'll work with a web designer to continue improving the look'n feel of the website, to make it look more profesionnal. We'll try to better organize the information so that it's even easier to search. And we'll look at the 1200 pages worth of documentation to update it where needed, to cover existing holes, etc.

This is with great pleasure that the Groovy development team announces the joint releases of Groovy 1.8.2 and 1.9-beta-3.

The big highlight of this release is the completion of the primitive type arithmetics performance optimizations. Microbenchmarks affictionados should be happy, and those wanting to do some number crunching should see better results with these improvements. Other than that, those two releases are essentially about bug fixes.

You can have a look at the release notes here:

And you can download Groovy 1.8.2 and 1.9-beta-3 on the download page:

In other news, thanks to Git expert Matthew McCullough, we completed our complex migration to Git.
You can learn about the details to access and clone the Git repo here:
Later on, we'll also provide a mirror on GitHub.

Small remark on the new beta of the 1.9 branch: due to a glitch a beta-2 was accidentally released in sync'ed with Maven Central, so we bumped the beta number to 3, rather than sticking with 2, as Central won't allow us to override an existing version.

Thank you everybody for your feedback and contributions to those two releases.

I'm very happy to announce the final release of Gaelyk 1.0, the lightweight Groovy toolkit for Google App Engine!

It took some time to get to 1.0, but it's now here, with the key feature I've been missing since the beginning of the project, in particular the Query DSL which allows you to write queries like this one:

If you want to learn more about this lightweight framework, head over to:

You can learn everything through the tutorial:

And download the JAR or the template project here:

Should you want to ask questions on the Google Groups, get involved in the community, participate in the development of this Open Source project, have a look at our community page:

This release wouldn't have been possible with all the great contributions of you all, your pull requests on GitHub, your Gradle plugins, your bug reports, your questions on the Google Group, etc. So I'd like to tell you all a big thank you for all your work and contributions. They were very much appreciated, and keep them coming!

The change log:

Thanks a lot for your attention, and enjoy developing Groovy applications on Google App Engine!

Hi all,

The Groovy development team is happy to announce the joint releases of Groovy 1.8.1 and 1.9-beta-1.

Both releases feature the following improvements and new features:

  • The performance optimizations for primitive type calculations are now covering all the primitive types
  • The builtin JSON support adds:
    • a streaming builder (StreamingJsonBuilder) for when you want to stream your JSON payload directly to a writer (when you don't need to modify the data structure before outputing)
    • and the two builders adds a simple serialization of POGOs/POJOs (just pass the object as a value)
  • The groovysh shell supports tab-completion for completing your variables and method names
  • Plus the usual GDK refinements that you can find on the release notes below.

And the first beta of the upcoming 1.9 line is adding on top of that:

  • Most of Java 7 Project Coin enhancements:
    • Use underscores in number literals: 1_000_000_000
    • Binary literals: 0b01010101
    • Catch multiple exceptions at once with multicatch: catch (IOException | NullPointerException e)

You can learn more about the tickets closed for these issues here:

And of course, you can download Groovy 1.8.1 and Groovy 1.9-beta-1 in our download area.

Keep on groovying!