This page was a RFC for the GSoC 2014.
We assume you already know what Google Summer of Code is, if not, please check out the Google Summer of Code site for general information.
For students, we recommend to read up on what libGDX is, then proceed to the Information For Students section.
Mentors must read the Information for Mentors section, add themselves to existing ideas in the list below, and optionally create and add new ideas.
What is libGDX?
libGDX is a cross-platform game development framework. You write your game in Java, and have it working instantly on Windows, Linux, Mac, Steam, Android, iOS, Facebook and HTML/WebGL. The entire Java code base is shared across all these platforms. You can find more information on libGDX’s feature set here.
libGDX was born 3 years ago, out of a desire to target multiple platforms with a single code base. It has since grown into a big OSS project with over 100 professional and amateur contributors, and is used by thousands of developers to create the games of their dreams. From entries for the 48 hour Ludum Dare challenge, to top grossing mobile games to augmented reality experiments like Google’s Ingress.
libGDX has achieved wide adoption, especially on Android where it is powering 3.2% of all installed applications, with numerous top-grossing games. On that platform it can already compete with Unity3D.
Our Community as well as the entire libGDX development team are looking forward to welcome you among us. Contribute to powering thousands of applications and bringing joy to millions of users!
Information for Students
As a student you may ask yourself why you should take part in libGDX’s Google Summer of Code effort. Here we try to give you some food for thought that may help you decide whether you want to apply for our project.
libGDX offers students to explore a wide range of technologies:
- Different operating systems, platforms and hardware (desktop, Android, iOS, HTML5/WebGL)
- Different fields of software development (data structures, 2D & 3D graphics, audio, peripheral communication, etc.)
Such broad environments are usually rare to find in many university settings.
You will work in a globally distributed team, a setup that is becoming more common. You’ll learn how to deal with the difficulties that arise in communication in such environments. Different time zones, different language skills (English is our lingua franca, but not everyone is a native speaker), miscommunication arising from limited expressiveness of text and so shapes how the team functions.
libGDX is an industrial strength framework used in production. It is employed in thousands of games that are played by millions of users every day. Modifying libgdx’s code means taking responsibility, and considering the impact it has on all the applications that are build on top of it. Big changes need to be discussed with the team, learning how to put forward a solid argument is crucial.
Finally, and maybe most importantly, libGDX means games. Many of the libGDX team members got into programming due to a desire to write games. If you want to improve your skillset while working within the game development field, then libGDX is for you.
The ideas below have been compiled by the libGDX contributors and community. If you want to pick any of those for your proposal, or come up with your own idea, it’s best to get to know libGDX and the backing technologies before starting with your proposal. That let’s you better estimate what is needed to finish a specific project. If you plan on applying for libGDX for your GSoC project you should follow these steps:
- Fork the project on Github.
- Get familiar on how to work with libgdx’s source.
- Register on the forums and introduce yourself. Drop by on IRC (#libgdx, irc.freenode.org), get to know the community. This forum thread is where most of the GSoC students introduced themselves so far, make sure to subscribe to it to receive notifications for new messages. The subscribe button is at the bottom of the page.
- Pick one of the project ideas below or come up with your own. Prepare your application using our [student application template] (FIXME (todo)). You’ll have to submit this application via the Google Summer of Code 2013 site, from April 22 - May 3, 2013. You’ll also need to sign the Student Participation Agreement. For more information on the process, read the GSoC FAQ. Reading it is mandatory!
- Get in contact with the mentors listed below, on IRC (irc.freenode.org, #libgdx) or the forums.
- Send a pull request for some issue or improvement you made to libGDX on Github, note that in your application. When selecting students, we’ll favor those that already demonstrated that they can interact with our community and read the docs on how to contribute
Information for Mentors
Since mentors have quite a bit of responsibility, I (badlogic) would want to limit potential mentors to the group of contributors. Exceptions to this rule may be made of course. Nex and I take on the project administrator role, which is different to that of a mentor.
Mentoring means commitment, once you agree to be a mentor, there’s no way back after we submit the application to GSoC.
- Drop me (badlogic) an e-mail
- Improve or add new ideas to the list below
- Read the GSoC FAQ, which explains all the obligations of a mentor.
- Read the GSoC Mentor Handbook which provides guidance on how to approach mentoring
- We organize our mentor activity on this thread. Subscribe to it, the subscription button is at the bottom of the page.
- Look out for students on the forum and on IRC, welcome them to the community and show them around
Idea List Guidelines
Please use the following format for ideas:
- Title use
### Project: Title ###
- Goals: keep it short, can be vague
- Required Skills: language, platforms, etc.
- Links: further information, forum threads, etc.
- Potential Mentors: contributors only
If you are not a contributor, post your idea in this thread (FIXME (todo))
---- after each idea as a separator.
Project: In-app Purchase Extension
Goals: create a libGDX extension that allows to incorporate in-app purchases across as many platforms as possible. iOS and Android are a must, GWT/desktop would be a nice to have.
Required Skills: Java, C#, basic iOS knowledge (bonus if you know Xamarin.iOS), basic Android knowledge (FIXME (xamarin -> robovm))
Links: https://github.com/libgdx/libgdx/pull/146 API draft by a core contributor
Project: Social Network Extension
Goals: create a libGDX extension that allows to incorporate social network interactions, e.g. get friend lists. Ideally this should work across all platforms (desktop, GWT, Android, IOS).
Required Skills: Java, C#, basic iOS knowledge (bonus if you know Xamarin.iOS), basic Android knowledge (FIXME (xamarin -> robovm))
Project: RoboVM/iOS backend
(FIXME done?) Goals: create a libGDX backend based on RoboVM for iOS.
Required Skills: Java, C/C++, OpenGL ES, iOS, maybe LLVM
Links: https://web.archive.org/web/20200426122040/https://www.badlogicgames.com/forum/viewtopic.php?f=23&t=7883 instructions on how to possibly approach this.
Project: Avian VM/iOS backend
Goals: create a libGDX backend based on Avian VM for iOS.
Required Skills: Java, C/C++, ObjectiveC, OpenGL ES, iOS
Links: https://web.archive.org/web/20200426122040/https://www.badlogicgames.com/forum/viewtopic.php?f=23&t=7883 instructions on how to possibly approach this for RoboVM, the same approach is applicable to Avian VM.
Project: Generic 2D Level Editor
Goals: create a 2D level editor, using libgdx’s scene2d for portability, that allows creating arbitrary level maps that can be loaded via the maps API. As a bonus point, make it extensible through plugins.
Required Skills: Java, basic graphics programming, bonus if you know scene2d, maybe OSGi
Links: https://docs.google.com/document/d/1iNo5yB39-iXV10I2bxPHpuk84EoEpU7_L9HSuPKN5tE quick draft of features/requirements we’d like to include.
Project: Oculus Rift backend
Goals: create a backend so libGDX supports Oculus Rift, a virtual reality headset with insanely low latency. We’ll probably have to provide the headset to the student. We’ll either buy it or ask the good folks at Oculus if they’d contribute one. We’d want to either extend an existing backend or write a new one specifically for the Oculus rift. This extension allows to expand libgdx’s domain to non-game related areas, like art installations, scientific visualizations and so on.
Required Skills: Java, C/C++, 3D programming, including GLSL shaders, linear algebra
Project: XBox Kinect extension
Goals: Create an extension that allows people to use the Kinect in their libGDX desktop projects. Kinect may have to be provided by us or sponsored in some way. The extension should also provide one or more demos that demonstrate how the extension works and what potential it has. This extension allows to expand libgdx’s domain to non-game related areas, like art installations, scientific visualizations and so on.
Required Skills: Java, C/C++, 3D programing, including GLSL shaders, linear algebra
Project: Leap Motion extension
Goals: Leap Motion is a new kind of controller that tracks your hand and finger movement and allows you to interact with digital media in a more natural way (think Minority Report). Creating an extension that gives libGDX users access to this device would be the goal for this project. On top of the extension, a set of demos should be created that demonstrate how to use the extension as well as its overall potential. This extension allows to expand libgdx’s domain to non-game related areas, like art installations, scientific visualizations and so on.
Devices would either have to be sponsored or bought by students/mentors. The devices are meant to ship in May, that may be too late.
This idea was orginally submitted by Fisherman on the forums.
Project: Experimental Features for new 3D API
Goals: libgdx’s 3D API is currently being worked on by a few of the core contributors. We’d like to explore some experimental features, including but not limited to: deferred rendering, different shadow mapping techniques, especially those suited for mobiles, CPU-side skinning (may require modifications to the API), mobile GPU specific optimizations for the default über-shader, using tools by GPU manufacturers to profile and improve the shader, dynamic lighting ala God of War 3. We are open for other more experimental features. Most of the above will not take a full 3 months, students are advised to pick at least two.
Required Skills: Java, 3D programming, including GLSL shaders, linear algebra
Links: Discussion by core developers on the new 3D API, for topic specific links see goals text above.
Project: Improve GDX Remote
Goals: Gdx remote allows you to run your application on the desktop, to which you can connect a device that sends input events to the application. This allows testing things like accelerometer controls in the desktop environment without having to deploy the application to the device. The current implementation is very primitive. Ideally, we’d like to also stream video from the desktop to the device, with minimal latency.
Required Skills: Java, network programming
Project: Websocket Support
Goals: libGDX currently only has rudimentary networking support (HTTP, TCP). We’d like to add Websocket support, allowing network programming with the HTML5 backend. This would allow us to do things like Chrome World Wide Maze or Browser Quest. Adding Websocket support would require a change in our current networking APIs, namely Socket#getInputStream needs to be changed.
Required Skills: Java, C#, network programming, GWT
Project: Simplified 3D Physics API and HTML5 implementation
Note that we already have Box2D fully working on all platforms, including HTML5. This was achieved by using JBox2D for the HTML5 backend. Doing this for bullet seems less feasible.
Required Skills: Java, GWT
Links: See links in goals above.
Project: Scripting Support
This project could be done in collaboration with the High-Level Game Engine project below.
Required Skills: Java, C/C++, familiarity with at least one potential scripting language
Links: see links in goals description
Project: High-level Game Engine
Goals: libGDX is a framework which can be overwhelming for people who do not have previous experience with game programming. A high-level game engine on top of libGDX could lower the barrier of entry. We propose to build a high-level 2D game engine on top of libGDX. Good API design, documentation and examples are part of the challenge. Inspiration can be found in projects such as Corona, Flixel, HaxePunk or Cocos2D. We do not rule out a 3D engine either, but think 2D would have more chances of success given the time frame of Google Summer of Code. Ideally, the engine would be based on the component/entity system pattern.
This project could be done in collaboration with the Scripting Support project above.
Links: see links in description above.
Project: Command Line Project Management
(FIXME done with Gradle?)
Goals: libGDX projects are usually done with Eclipse in mind. While we support Maven and other IDEs and development environments, integration isn’t as straight forward. Maven is problematic due to GWT and Android being somewhat second class citizens in that area. Also, IDE integration of Maven Android and GWT projects is lacking. In addition to IDE woes, packaging and deploying projects can be cumbersome. We’d like to develop a command line application that allows the creation of new libGDX projects, create project files for various IDEs, create POM and Gradle build files, can update dependencies automatically, can remove and add extensions, and package and deploy the application to connected devices. Loom Engine and Haxe NME provide similar tools.
Required Skills: Java, Maven, Gradle, Eclipse, Intellij, Netbeans Links: Google Doc with requirements
Project: Increase Robustness through Static Code Analysis Tools
Goals: libGDX is used in production, and as such requires high robustness. One way of increasing robustness is to use static analysis tools that uncover bad practices and bugs. Applying such analysis to a code base as big as libGDX’s is a challenge. Not only is the size an issue, but a gaming framework may have to rely on patterns for performance that are wrongly identified as issues by static analysis tools. For this idea, we’d like to see how static analysis tools can be exploited to increase libGDX’s quality and how we could integrate them into our everyday workflow. It is expected that whatever tool is used for analysis needs to be adapted with new rules that fit for the requirements of a gaming framework.
Required Skills: Java, Maven, Gradle, Eclipse, Intellij, Netbeans
Mentors: [https://code.google.com/p/libgdx/wiki/GoogleSummerOfCode2013Mentors?ts=1363700945&updated=GoogleSummerOfCode2013Mentors#Nate nate], [https://code.google.com/p/libgdx/wiki/GoogleSummerOfCode2013Mentors?ts=1363700945&updated=GoogleSummerOfCode2013Mentors#Badlogic badlogic]
(FIXME, maybe add the mentor list here… idk)