Status message

This proposal has been approved and the Eclipse Golo project has been created.


This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process) and is written to declare its intent and scope. We solicit additional participation and input from the community. Please login and add your feedback in the comments section.
Parent Project: 

Golo comes from the research activities of the Dynamid team of the CITI-INRIA Laboratory at INSA-Lyon. After experimentations in the JooFlux dynamic aspect and code injection toolkit, we realized that we could take advantage of the  invokedynamic / JSR 292 to design a small, efficient and easy to hack dynamically-typed programming language for the JVM. By "easy to hack", we mean that language and runtime experiments can be approached by students and hobbyists, not just programming language design experts.

We released the first preview of Golo at the Devoxx France conference in March 2013. The language was presented in various JUGs and conferences, including Devoxx 2013 in Belgium. A fair share of such presentations have been made by community members, including:

Golo 1.0.0 was released in July 2014 and follows semantic versioning. The current release is Golo 2.1.0 (March 2015) and development has shifted towards Golo 3.0.0, as we shift the platform requirements to Java 8 by introducing interoperability with Java functional interfaces.

We published a first academic research paper at the PPPJ 2013 conference. We have ongoing efforts for further research publications on Golo, including language derivative experiments such as ConGolo (context-oriented programming).

Golo is supported by a small and enthusiastic community that largely goes beyond academia. Many language and runtime contributions have been done by individuals with no prior experience on programming language implementation. The community has also helped with support for Golo in Netbeans, Eclipse, popular text editors and the Gradle build tool.

Applications have been found in lightweight (web) service-oriented frameworks, IoT programming and rapid prototyping.


Golo is a dynamically-typed programming language for the Java Virtual Machine.

  • Golo is largely interoperable with Java and other JVM languages.
  • Golo supports imperative and functional programming patterns.
  • Golo explicitly wants to serve as a foundation for programming and language derivative experiments.

Golo is a dynamically-typed programming language for the Java Virtual Machine. Golo is largely interoperable with Java and other JVM languages (e.g., numeric types are boxing classes from java.lang, and collection literals leverage java.util classes). Golo supports imperative and functional programming patterns. Golo is not a strictly object-oriented programming language: it very much resembles Go in the sense that methods are just functions applied to specific receiver types. Golo or Java defined types can be augmented in Golo, that is, new methods can be made available.

The language features have been initially designed around the abilities of invokedynamic / JSR 292 that appeared in Java SE 7. Golo uses ahead-of-time compilation of bytecode. While the bytecode remains stable over a program execution, the invokedynamic-based reconfigurable call sites support the adaptive dispatch mechanisms put in place for helping the HotSpot JIT to extract reasonable performance. Golo generally exhibits good performance in micro-benchmarks for a dynamically-typed language on the JVM.

Diving into the design and implementation of a programming language is an involving task, and existing JVM languages have large codebases with rich histories. Golo explicitly wants to serve as a foundation for programming and language derivative experiments. To this end, its codebase is expected to remain concise enough to remain of pedagogical value.

Golo uses a limited set of runtime dependencies: the JavaCC parser generator, the ASM bytecode engineering library and the json-simple library. Optional runtime dependencies include JCommanderfor the command-line interface and Txtmark to process API documentations written in Markdown.

Golo does not currently have collaborations with other Eclipse projects beyond a community-contributed XText-based Eclipse IDE plugin. By joining the Eclipse Foundation, we expect cross-pollinisation with the wider Eclipse ecosystem.

Why Here?: 

In short: we want to give the project a chance to outgrow us.

Golo has reached a point where a small yet enthusiastic community gathered around it. The community is providing not just code contributions, but also conference talks and posts on the Internet.

It now makes perfect sense for the research team behind the project to move the development of Golo to a proven, vendor-neutral organization.

Eclipse has the potential to be that catalyst, as its ecosystem provides Golo with many cross-pollinisation opportunities. We envision collaborations with many projects, including:

  • IDE/tooling:
    • XText,
    • Che,
    • Orion,
    • Sirius,
    • Code Recommander,
    • WebTools,
    • Ease,
    • DLTK,
  • the IoT projects,
  • the vert.x project.

Last but not least: the good IP management policies at the Eclipse Foundation are consistent with the policies that we already had in place. All contributions have been accepted under contributor license agreements with INSA-Lyon.

Project Scheduling: 

Our plan is to do an initial contribution within the 2 weeks of incubator acceptance.

We would appreciate if the Eclipse Foundation allowed us to enter the incubator with an initial contribution without org.eclipse.* package names. We have a number of pull-requests / features under development, and the fact that Git history is going to be reset is already a big enough issue for the development and completion of these works. We will move to org.eclipse.* packages at a later point while in the incubation. As an exception, we will not rename the gololang package which is a namespace for the Golo standard API.

We expect to develop what is currently planned for Golo 3.0.0 in the incubator, with regular milestone releases. We would ideally propose a graduation from the incubator once feature complete, and after having used the milestone releases to get up to speed with the Eclipse processes.

Future Work: 

The project is going to continue the efforts in growing its community, including proposing conference talks and disseminating articles. We expect the interactions with other Eclipse projects to be a fruitful growth factor, too.

The current items in development for the next release (that could be done in the Eclipse incubator) include:

  • the transparent support of Java functional interfaces (the foundation of Java 8 so-called lambdas),
  • the support of named arguments,
  • direct anonymous function calls,
  • previously deprecated APIs removal,
  • easier Java class adapter generation API,
  • changing a function arity using decorators,
  • extension of the closure interface implementation augmentation to functional interfaces.

In future versions, we have plans to make investigations in the following areas.

  • Easing embedding APIs.
  • Macros.
  • Lazy collections and generators.
  • Adaptive / context-dependent sandboxing of Golo code.
  • Exploration of opportunities on non-JVM runtimes (e.g., LLVM, CLR, JavaScript).
Project Leads: 
Interested Parties: 
  • Université de Lyon, INSA-Lyon, CITI-INRIA Laboratory
  • Julien Viet (vert.x, Red Hat)
  • Mark Little (Red Hat)
  • Henri Gomez
  • Emmanuel Feller
Source Code
Initial Contribution: 

http://golo-lang.org/ and https://github.com/golo-lang/golo-lang

All contributions have been accepted under a contributor-license agreement with INSA-Lyon.

Golo is using the following 3rd-party runtime dependencies (this excludes test and build dependencies).

  • JavaCC, 3-points BSD License.
  • ASM, 3-points BSD License.
  • JCommander, Apache License v2.0.
  • Txtmark, Apache License v2.0.
  • json-simple, Apache License v2.0.
Source Repository Type: 
Julien Viet's picture

Golo seems to be a very interesting project and I believe there is a good synergy with the Vert.x project .