{"id":15029272,"url":"https://github.com/luontola/retrolambda","last_synced_at":"2025-05-14T14:08:09.168Z","repository":{"id":9617443,"uuid":"11543691","full_name":"luontola/retrolambda","owner":"luontola","description":"Backport of Java 8's lambda expressions to Java 7, 6 and 5","archived":false,"fork":false,"pushed_at":"2023-09-26T15:12:04.000Z","size":1063,"stargazers_count":3535,"open_issues_count":28,"forks_count":225,"subscribers_count":136,"default_branch":"master","last_synced_at":"2025-04-12T13:57:33.928Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/luontola.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE.txt","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null}},"created_at":"2013-07-20T07:25:22.000Z","updated_at":"2025-04-11T05:59:46.000Z","dependencies_parsed_at":"2022-07-13T13:50:54.696Z","dependency_job_id":"2b078676-7fa4-474d-8a53-1cc1bab212bd","html_url":"https://github.com/luontola/retrolambda","commit_stats":null,"previous_names":["orfjackal/retrolambda"],"tags_count":38,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/luontola%2Fretrolambda","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/luontola%2Fretrolambda/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/luontola%2Fretrolambda/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/luontola%2Fretrolambda/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/luontola","download_url":"https://codeload.github.com/luontola/retrolambda/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":254159689,"owners_count":22024564,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-09-24T20:10:10.552Z","updated_at":"2025-05-14T14:08:09.146Z","avatar_url":"https://github.com/luontola.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"\nRetrolambda: Use Lambdas on Java 7\n==================================\n\n[![Retrolambda presentation video](resources/presentation-preview.png)](https://www.youtube.com/watch?v=DUdhfPh9V_s)\n\nJust as there was *Retroweaver* et al. for running Java 5 code with\ngenerics on Java 1.4, *Retrolambda* lets you run Java 8 code with **lambda\nexpressions**, **method references** and **try-with-resources statements**\non Java 7, 6 or 5. It does this by transforming your Java 8 compiled\nbytecode so that it can run on an older Java runtime. After the\ntransformation they are just a bunch of normal .class files, without any\nadditional runtime dependencies.\n[Read more details](#backported-language-features).\n\nThere is also [limited support](#known-limitations) for backporting\n**default methods** and **static methods on interfaces**. This feature is\ndisabled by default.\n\nRetrolambda supports backporting to Java 7, Java 6 and Java 5 runtimes. And\nfor adventurous developers there are [other backporting\ntools](http://en.wikipedia.org/wiki/Java_backporting_tools) that may let\nyou go from Java 5 down to Java 1.4.\n\nNowadays Android Studio has [built-in support for Java 8 features](https://developer.android.com/studio/write/java8-support),\nso that is probably the first thing to try out. Otherwise, Retrolambda\nworks also for Android: Serge Zaitsev has written [an article about\nit](https://zserge.com/posts/android-lambda/) and there is a [Gradle\nplugin](#gradle-plugin) which makes it easy.\n\nRetrolambda does not backport the new Java 8 APIs, but there are other\nprojects that have backported some of them:\n\n* [streamsupport](http://sourceforge.net/projects/streamsupport/) backports the `java.util.stream` API\n* [ThreeTen](http://www.threeten.org/) backports the `java.time` API\n\nAdditionally [Animal Sniffer](http://www.mojohaus.org/animal-sniffer/) and \n[IntelliJ IDEA](https://www.jetbrains.com/idea/) can warn about the use of\nJava 8 APIs.\n\n\nUser Guide\n----------\n\nRetrolambda can be run as a [Maven plugin](#maven-plugin),\n[Gradle plugin](#gradle-plugin) or\n[command line application](#command-line-application). Also have a look at\n[some tips for using Retrolambda effectively](#tips).\n\n\n### Maven Plugin\n\nTo run Retrolambda using Maven, add the following to your pom.xml:\n\n```xml\n\u003cplugin\u003e\n    \u003cgroupId\u003enet.orfjackal.retrolambda\u003c/groupId\u003e\n    \u003cartifactId\u003eretrolambda-maven-plugin\u003c/artifactId\u003e\n    \u003cversion\u003e2.5.7\u003c/version\u003e\n    \u003cexecutions\u003e\n        \u003cexecution\u003e\n            \u003cgoals\u003e\n                \u003cgoal\u003eprocess-main\u003c/goal\u003e\n                \u003cgoal\u003eprocess-test\u003c/goal\u003e\n            \u003c/goals\u003e\n        \u003c/execution\u003e\n    \u003c/executions\u003e\n\u003c/plugin\u003e\n```\n\nSee the [plugin documentation](https://luontola.github.io/retrolambda/retrolambda-maven-plugin/plugin-info.html)\nfor all possible parameters. There is also a usage example in [end-to-end-tests/pom.xml](https://github.com/luontola/retrolambda/blob/master/end-to-end-tests/pom.xml)\n\n\n### Gradle Plugin\n\n[Gradle Retrolamba Plugin](https://github.com/evant/gradle-retrolambda) is developed by Evan Tatarka. See its site for usage instructions.\n\n\n### Command Line Application\n\n[Download](https://oss.sonatype.org/content/groups/public/net/orfjackal/retrolambda/retrolambda/)\nthe latest `retrolambda.jar` from Maven Central.\n\nUse JDK 8 to compile your source code.\n\nRun Retrolambda, using Java 8, on the class files produced by JDK 8. Run\n`java -jar retrolambda.jar` without any additional options to see the\ninstructions (for your convenience they are also shown below).\n\nYour class files should now run on Java 7 or older.\n\n```\nUsage: java -Dretrolambda.inputDir=? -Dretrolambda.classpath=? [-javaagent:retrolambda.jar] -jar retrolambda.jar\n\nRetrolambda takes Java 8 classes and backports lambda expressions and\nsome other language features to work on Java 7, 6 or 5.\nWeb site: https://github.com/luontola/retrolambda\n\nCopyright (c) 2013-2017  Esko Luontola and other Retrolambda contributors\nThis software is released under the Apache License 2.0.\nThe license text is at http://www.apache.org/licenses/LICENSE-2.0\n\nConfigurable system properties:\n\n  retrolambda.bytecodeVersion\n      Major version number for the generated bytecode. For a list, see\n      offset 7 at http://en.wikipedia.org/wiki/Java_class_file#General_layout\n      Default value is 51 (i.e. Java 7)\n\n  retrolambda.defaultMethods\n      Whether to backport default methods and static methods on interfaces.\n      LIMITATIONS: All backported interfaces and all classes which implement\n      them or call their static methods must be backported together,\n      with one execution of Retrolambda.\n      Disabled by default. Enable by setting to \"true\"\n\n  retrolambda.inputDir (required)\n      Input directory from where the original class files are read.\n\n  retrolambda.outputDir\n      Output directory into where the generated class files are written.\n      Defaults to same as retrolambda.inputDir\n\n  retrolambda.classpath (required)\n      Classpath containing the original class files and their dependencies.\n      Uses ; or : as the path separator, see java.io.File#pathSeparatorChar\n\n  retrolambda.classpathFile (alternative)\n      File listing the classpath entries.\n      Alternative to retrolambda.classpath for avoiding the command line\n      length limit. The file must list one file per line with UTF-8 encoding.\n\n  retrolambda.includedFiles\n      List of files to process, instead of processing all files.\n      This is useful for a build tool to support incremental compilation.\n      Uses ; or : as the path separator, see java.io.File#pathSeparatorChar\n\n  retrolambda.includedFilesFile (alternative)\n      File listing the files to process, instead of processing all files.\n      Alternative to retrolambda.includedFiles for avoiding the command line\n      length limit. The file must list one file per line with UTF-8 encoding.\n\n  retrolambda.javacHacks\n      Attempts to fix javac bugs (type-annotation emission for local variables).\n      Disabled by default. Enable by setting to \"true\"\n\n  retrolambda.quiet\n      Reduces the amount of logging.\n      Disabled by default. Enable by setting to \"true\"\n\nIf the Java agent is used, then Retrolambda will use it to capture the\nlambda classes generated by Java. Otherwise Retrolambda will hook into\nJava's internal lambda dumping API, which is more susceptible to suddenly\nstopping to work between Java releases.\n```\n\n\n### Tips\n\nBe sure to run comprehensive tests on your target JVM version (e.g. Java\n7), in case the code accidentally uses Java 8 APIs or language features\nthat Retrolambda doesn't backport.\n\nDuring development, inside an IDE, it's the easiest to use Java 8, without\nRetrolamba, to compile and run tests. But in your continuous integration\nand release builds you should run all tests using the target Java version.\nFor example, you can configure Maven Surefire Plugin to run tests\n[using a different JVM](http://maven.apache.org/surefire/maven-surefire-plugin/test-mojo.html#jvm).\n\nI recommend setting up environment variables JAVA8_HOME, JAVA7_HOME etc. and\nreferring to those variables in the build configuration, instead of relying on\nwhat happens to be the default Java version in JAVA_HOME.\n\nYou will need Java 8 for compiling and also for generating Javadocs.\nJDK 7's Javadoc tool will fail for some valid Java 8 code.\n\n\nBackported Language Features\n----------------------------\n\n**Lambda expressions** are backported by converting them to anonymous inner\nclasses. This includes the optimization of using a singleton instance for\nstateless lambda expressions to avoid repeated object allocation.\n\n**Method references** are basically just syntax sugar for lambda\nexpressions and they are backported in the same way.\n\n**Try-with-resources statements** are backported by removing calls to\n`Throwable.addSuppressed` if the target bytecode version is below Java 7.\nIf you would like the suppressed exceptions to be logged instead of\nswallowed, please create a feature request and we'll make it configurable.\n\n**Objects.requireNonNull calls** are replaced with calls to `Object.getClass`\nif the target bytecode version is below Java 7. The synthetic null checks\ngenerated by JDK 9 use `Objects.requireNonNull`, whereas earlier JDK versions\nused `Object.getClass`.\n\n\n*Optionally also:*\n\n**Default methods** are backported by copying the default methods to a\ncompanion class (interface name + \"$\") as static methods, replacing the\ndefault methods in the interface with abstract methods, and by adding the\nnecessary method implementations to all classes which implement that\ninterface.\n\n**Static methods on interfaces** are backported by moving the static\nmethods to a companion class (interface name + \"$\"), and by changing all\nmethods calls to call the new method location.\u003csup\u003e[1]\u003c/sup\u003e\n\n\u003csup\u003e[1]\u003c/sup\u003e *The static methods are moved to a companion class even with\ndefault method support disabled, because some of them may be lambda\nimplementation methods, but the method calls to static methods are not\nupdated. This may cause weird error messages if static methods on\ninterfaces are accidentally used without enabling default method support.*\n\n\nKnown Limitations\n-----------------\n\nDoes not backport Java 8 APIs.\n\nBackporting default methods and static methods on interfaces requires all\nbackported interfaces and all classes which implement them or call their\nstatic methods to be backported together, with one execution of\nRetrolambda. In other words, you must *always do a clean build*. Also,\nbackporting default methods won't work across module or dependency\nboundaries.\n\nMay break if a future JDK 8 build stops generating a new class for each\n`invokedynamic` call. Retrolambda works so that it captures the bytecode\nthat `java.lang.invoke.LambdaMetafactory` generates dynamically, so\noptimizations to that mechanism may break Retrolambda.\n\nJava 9 and higher are not supported; just build your project with Java 8. The\nnew JDKs mostly just add new APIs, which you anyways wouldn't be able to use on\non older JREs. To backport new language features, create a new tool for it\nyourself or pay someone to do it, if you think it's worth the effort. ;)\n\n\nVersion History\n---------------\n\n### Retrolambda 2.5.7 (2020-01-23)\n\n- Improved error messages for Java 12 and newer, which have been confirmed\n  to not work without the Java agent\n  ([Issue #154](https://github.com/luontola/retrolambda/issues/154))\n- Upgraded the ASM library to improve compatibility with Java 13\n  ([Issue #154](https://github.com/luontola/retrolambda/issues/154))\n\n### Retrolambda 2.5.6 (2018-11-30)\n\n- Fix a `NullPointerException` crash in the Maven plugin on Java 10 \u0026 11\n- Fix Java agent to work on Java 9+\n  ([Pull request #148](https://github.com/luontola/retrolambda/pull/148))\n\n### Retrolambda 2.5.5 (2018-08-14)\n\n- Fix an `ArrayIndexOutOfBoundsException` crash in ASM due to incorrect bytecode \n  produced by `javac` under some circumstances. See [JDK-8073658](https://bugs.openjdk.java.net/browse/JDK-8073658)\n  and [ASM-317845](https://gitlab.ow2.org/asm/asm/issues/317845).\n  Enable the `javacHacks` parameter for a workaround to this issue.\n  ([Pull request #143](https://github.com/luontola/retrolambda/pull/143))\n\n### Retrolambda 2.5.4 (2018-05-30)\n\n- Fix regression in Maven plugin; use classpathFile\n  ([Issue #141](https://github.com/luontola/retrolambda/issues/141))\n\n### Retrolambda 2.5.3 (2017-12-28)\n\n- Copy the `SourceFile` attribute of the enclosing class into the lambda class\n  ([Issue #131](https://github.com/luontola/retrolambda/issues/131))\n\n### Retrolambda 2.5.2 (2017-12-28)\n\n- Fixed running Retrolambda under Java 9\n  ([Issue #137](https://github.com/luontola/retrolambda/issues/137))\n- Consider `module-info.class` as a resource and do not try backporting it\n  ([Issue #122](https://github.com/luontola/retrolambda/issues/122))\n\n### Retrolambda 2.5.1 (2017-02-23)\n\n- Fixed the enclosing method attribute of anonymous classes declared inside\n  lambda expressions\n  ([Issue #121](https://github.com/luontola/retrolambda/issues/121))\n\n### Retrolambda 2.5.0 (2017-01-22)\n\n- Fixed lambda expressions in subclasses accidentally overriding lambda\n  expressions in their parent. If you are using version 2.2.0 or greater,\n  it is strongly recommended to upgrade to this version.\n  ([Issue #109](https://github.com/luontola/retrolambda/issues/109))\n\n### Retrolambda 2.4.0 (2017-01-11)\n\n- Added an option to reduce the amount of logging\n  ([Issue #103](https://github.com/luontola/retrolambda/issues/103))\n- Removes `java/lang/invoke/LambdaForm$Hidden` annotations from the generated \n  lambda classes to avoid issues with ProGuard \n  ([Pull request #118](https://github.com/luontola/retrolambda/pull/118))\n- Fixed backporting classes in the default package\n  ([Issue #105](https://github.com/luontola/retrolambda/issues/105))\n- Fixed backporting `java.lang.Object` itself\n  ([Pull request #113](https://github.com/luontola/retrolambda/pull/113))\n\n### Retrolambda 2.3.0 (2016-04-30)\n\n- Optimize generated code to reduce method count\n  ([Issue #81](https://github.com/luontola/retrolambda/issues/81))\n    - Alter when accessor methods are generated\n      ([Pull request #84](https://github.com/luontola/retrolambda/pull/84))\n    - Remove NEW, DUP instructions when changing NEWINVOKESPECIAL to INVOKESTATIC\n      ([Pull request #85](https://github.com/luontola/retrolambda/pull/85))\n    - Skip access method when lambda body method can be promoted\n      ([Pull request #86](https://github.com/luontola/retrolambda/pull/86))\n- Fix method reference to protected method in base class in other package\n  failing with IllegalAccessError\n  ([Issue #89](https://github.com/luontola/retrolambda/issues/89))\n\n### Retrolambda 2.2.0 (2016-04-29)\n\n- Backports calls to `Objects.requireNonNull`, improving JDK 9 support\n  ([Issue #75](https://github.com/luontola/retrolambda/issues/75))\n- Optimize generated code to reduce method count\n  ([Issue #81](https://github.com/luontola/retrolambda/issues/81))\n    - Detect and omit the JVM's lambda factory method\n      ([Pull request #82](https://github.com/luontola/retrolambda/pull/82))\n\n\n### Retrolambda 2.1.0 (2015-12-19)\n\n- Added the `-Dretrolambda.classpathFile` parameter to avoid\n  the command line length limit\n  ([Issue #70](https://github.com/luontola/retrolambda/issues/70))\n- Added the `-Dretrolambda.includedFilesFile` parameter to avoid\n  the command line length limit\n  ([Pull request #74](https://github.com/luontola/retrolambda/pull/74))\n- Made it easier to invoke Retrolambda as a library. Made `Config`\n  an interface and fixed an assumption of using the default file system\n  ([Pull request #71](https://github.com/luontola/retrolambda/pull/71))\n- Don't create a companion class when an interface has just\n  a static initialization block because of constant fields\n  ([Issue #66](https://github.com/luontola/retrolambda/issues/66))\n- Improved error messages: report the name of the class or lambda method which\n  crashed Retrolambda\n  ([Issue #69](https://github.com/luontola/retrolambda/issues/69))\n\n### Retrolambda 2.0.6 (2015-09-06)\n\n- Fixed method references to constructors causing VerifyError on Android\n  ([Issue #67](https://github.com/luontola/retrolambda/issues/67))\n\n### Retrolambda 2.0.5 (2015-07-19)\n\n- Support for lambdas with marker interfaces\n  ([Issue #62](https://github.com/luontola/retrolambda/issues/62))\n\n### Retrolambda 2.0.4 (2015-07-08)\n\n- Fixed a compile error when calling default methods from another module\n  ([Issue #56](https://github.com/luontola/retrolambda/issues/56))\n- Fixed method references to constructors of the current class\n  ([Issue #60](https://github.com/luontola/retrolambda/issues/60))\n- Removes bytecode references to `java.lang.invoke.MethodHandles.Lookup` on\n  Java 6 and older\n  ([Issue #61](https://github.com/luontola/retrolambda/issues/61))\n- Copies non-class files from input to output directory\n  ([Issue #54](https://github.com/luontola/retrolambda/issues/54))\n\n### Retrolambda 2.0.3 (2015-06-07)\n\n- Fixed Retrolambda generating stack map frames for Java 5 bytecode,\n  causing some bytecode tools to fail\n  ([Issue #55](https://github.com/luontola/retrolambda/issues/55))\n\n### Retrolambda 2.0.2 (2015-04-14)\n\n- Fixed a hack which caused lambdas in interfaces to be backported twice,\n  possibly producing broken method calls in the bytecode\n  ([Issue #48](https://github.com/luontola/retrolambda/issues/48))\n- Fixed the handling of non-static lambda implementation methods in\n  interfaces, i.e. lambdas which capture `this`\n  ([Issue #48](https://github.com/luontola/retrolambda/issues/48))\n- Removes generic method signatures from the default method implementation\n  methods which are placed in the interface's companion class, to avoid\n  them getting out of sync with their erased method descriptors\n  ([Issue #48](https://github.com/luontola/retrolambda/issues/48))\n\n### Retrolambda 2.0.1 (2015-04-06)\n\n- Fixed not backporting lambda expressions in default methods and static\n  methods on interfaces\n  ([Issue #48](https://github.com/luontola/retrolambda/issues/48))\n\n### Retrolambda 2.0.0 (2015-03-28)\n\n- Backports default methods and static methods on interfaces\n  ([Issue #31](https://github.com/luontola/retrolambda/issues/31))\n\n### Retrolambda 1.8.1 (2015-01-06)\n\n- Backports lambda expressions in an interface's constant initializer\n  ([Issue #42](https://github.com/luontola/retrolambda/issues/42))\n\n### Retrolambda 1.8.0 (2014-11-16)\n\n- Backports try-with-resources statements to Java 6 and older by removing\n  calls to `Throwable.addSuppressed`\n  ([Issue #38](https://github.com/luontola/retrolambda/issues/38))\n\n### Retrolambda 1.7.0 (2014-10-21)\n\n- Support for serializable lambdas\n  ([Issue #35](https://github.com/luontola/retrolambda/issues/35))\n\n### Retrolambda 1.6.2 (2014-10-03)\n\n- Fixed a crash when trying to backport Android classes\n  ([Issue #34](https://github.com/luontola/retrolambda/issues/34))\n\n### Retrolambda 1.6.1 (2014-08-25)\n\n- Fixed a crash when trying backport classes which are nominally the same\n  as those included in the JRE, but which have different bytecode\n  ([Issue #29](https://github.com/luontola/retrolambda/issues/29))\n\n### Retrolambda 1.6.0 (2014-08-20)\n\n- Does not anymore require the use of a Java agent\n  ([Issue #27](https://github.com/luontola/retrolambda/issues/27))\n- Maven plugin: by default run Retrolambda in the same process as Maven,\n  making it a bit faster. If Maven is not running under Java 8, then will\n  fall back to forking the process and using the Java agent mechanism\n\n### Retrolambda 1.5.0 (2014-07-19)\n\n- Maven plugin: use the [JDK from Maven Toolchains](http://maven.apache.org/plugins/maven-toolchains-plugin/toolchains/jdk.html)\n  if available. The `java8home` configuration parameter overrides this\n  ([Issue #24](https://github.com/luontola/retrolambda/pull/24))\n\n### Retrolambda 1.4.0 (2014-07-04)\n\n- Added an optional `-Dretrolambda.includedFiles` parameter to support the\n  incremental compilers of build tools\n  ([Issue #23](https://github.com/luontola/retrolambda/pull/23))\n- Decides which lambda classes to save based on the current class being\n  processed, instead of the class loader that loaded the lambda class\n  ([Issue #21](https://github.com/luontola/retrolambda/issues/21))\n\n### Retrolambda 1.3.0 (2014-06-04)\n\n- Maven plugin: made the input and output directories configurable\n  ([Issue #20](https://github.com/luontola/retrolambda/issues/20))\n- Maven plugin: by default use the current JRE for running Retrolambda.\n  For the old behavior, add `\u003cjava8home\u003e${env.JAVA8_HOME}\u003c/java8home\u003e`\n  to the plugin configuration\n\n### Retrolambda 1.2.3 (2014-05-19)\n\n- Android: Fixed NoSuchMethodError when calling a private method to which\n  there is a method reference\n  ([Issue #18](https://github.com/luontola/retrolambda/issues/18))\n- Fixed the possibility of accidentally overriding private methods to which\n  there is method reference\n  ([Issue #19](https://github.com/luontola/retrolambda/issues/19))\n\n### Retrolambda 1.2.2 (2014-05-15)\n\n- Fixed method references to private methods; will now make them\n  package-private the same way as lambda implementation methods\n  ([Issue #17](https://github.com/luontola/retrolambda/issues/17))\n\n### Retrolambda 1.2.1 (2014-05-04)\n\n- Fixed the Retrolambda Maven plugin not using the project's classpath\n  ([Issue #16](https://github.com/luontola/retrolambda/issues/16))\n- Maven plugin: save `retrolambda.jar` under `target/retrolambda/`\n- Suppress false warning about class initializer methods on interfaces\n\n### Retrolambda 1.2.0 (2014-05-02)\n\n- Maven plugin for running Retrolambda\n  (thanks, [Dave Moten](https://github.com/davidmoten))\n\n### Retrolambda 1.1.4 (2014-03-29)\n\n- Removes from interfaces bridge methods which were generated by JDK 8 e.g.\n  when an interface overrides a method and refines its return type\n  ([Issue #13](https://github.com/luontola/retrolambda/issues/13))\n\n### Retrolambda 1.1.3 (2014-03-25)\n\n- Fixed incompatibility with the Eclipse JDT compiler, version Kepler SR2\n  with the Java 8 support patch 1.0.0.v20140317-1959\n  ([Issue #12](https://github.com/luontola/retrolambda/issues/12))\n\n### Retrolambda 1.1.2 (2014-01-08)\n\n- Updated to work with JDK 8 Early Access Build b121 (2013-12-19)\n  ([Issue #3](https://github.com/luontola/retrolambda/issues/3))\n\n### Retrolambda 1.1.1 (2013-11-27)\n\n- Show help if the `-javaagent` parameter is missing\n  ([Issue #2](https://github.com/luontola/retrolambda/issues/2))\n\n### Retrolambda 1.1.0 (2013-07-25)\n\n- Create only one instance of lambdas which do not capture arguments; i.e.\n  the same optimization as what JDK 8 does\n- Start the sequence number of lambda classes from one (e.g.\n  `com.example.Foo$$Lambda$1`) for each enclosing class\n\n### Retrolambda 1.0.0 (2013-07-23)\n\n- Backports lambda expressions and method references to Java 7 and older\n- Tested to work with JDK 8 Early Access Build b99 (2013-07-19)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fluontola%2Fretrolambda","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fluontola%2Fretrolambda","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fluontola%2Fretrolambda/lists"}