In the world of game development, you will come across different set of programming languages: Lua, Unreal Script, Live Code, Boo etc. Some of these tools are a derivative or an extension of what is already available (mostly taken from Python) on other gaming platform, while some have been explicitly developed for mobile.

Adding to the list is a new cross platform game development programming language – Lobster. If you familiar with Python then you might find Lobster of interest as the syntax appears very similar. Lobster is designed and implemented by developer Wouter van Oortmerssen and uses C++ 11 features and built on top of OpenGL, SDL 2 and FreeType. Wouter has previously created several languages including Amiga E and False.

Although the language looks similar to Python and Boo, but it has its own blend of features: built-in control structures, higher order functions, vector operations, coroutines, optional types, multi-methods and optional immutability.

Lobster has a built-in library for making both games and graphics, and the games can be run on almost all mobile operating systems including iOS and Android and the developer has optimized the language to run also on Windows, Linux, and Mac OS X. The language is not yet ready for public release and available as a Beta release.

Features of Lobster

As per official documentation, the language is dynamically typed and follows Python-type indentation. Being a game programming language it supports vector operations and multi-methods. One of its main features is that you can bind the result of a function to a new scope.

Language

• Dynamically Typed with Optional Typing
• Python-style indentation based syntax with C-style flavoring
• Lightweight Blocks / Anonymous Functions that make any function using them look identical to built-in control structures supporting non-local return (& exception handling)
• Lexically Scoped with optional Dynamic Scoping
• Vector operations (for math and many other builtins)
• Multimethods (dynamic dispatch on multiple arguments at once)
• First Class Stackful Asymmetric Coroutines
• Optionally immutable objects

Implementation

• Reference Counting with cycle detection at exit, or optional garbage collection calls
• Debugging functionality (stack traces with full variable output)
• Dynamic code loading
• Relatively fast (several times faster than Python/Ruby, about as fast as non-JIT Lua) and economical (low overhead memory allocation)
• Easy to deploy (engine/interpreter exe + compressed bytecode file)
• Modularly extendable with your own library of C++ functions

Engine

• High level interface to OpenGL functionality, very quick to get going with simple 2D geometric primitives
• 3D primitive construction either directly from triangles, loaded from (animated) .IQM models, or using high level primitives made into meshes through marching cubes
• GLSL shaders (usable accross OpenGL & OpenGL ES 2 without changes)
• Accurate text rendering through FreeType
• Uniform input system for mouse & touch
• Simple sound system supporting .wav and .sfxr synth files.
• Comes with useful libraries written in Lobster for things like A* path finding and game GUIs

Lobster is open source ZLIB license and is available on GitHub.

Homepage: http://strlen.com/lobster

Online docs: http://strlen.com/files/lang/lobster/readme_first.html

Github: https://github.com/aardappel/lobster

Google+ community: https://plus.google.com/u/0/communities/102851862468639498591