GraLL 2

Wiki | Flickr | Vimeo | Facebook | GitHub


GraLL 2 is still under development, but playable. You can download and try the game in its current state. Special 'work in progress' keys:


Download! (last updated: 26 June 2012)


AUR Package for Arch Linux. For other distros, you'll have to build from source. Check the PKGBUILD file in the AUR package for an idea of the dependencies and build process.


Some screenshots of GraLL 2. The GraLL 2 Flickr page has a lot more.

Level 5Level 3

In Dimension 2 too!PhailLevel 2Level complete!GraLL vs. Crate


GraLL 2 in action! Only the latest videos are shown here, check out the GraLL 2 Vimeo page.

The video below is a behind-the-scenes look at GraLL 2 level editing. I wrote a plugin for Blender that allows exporting GraLL 2 levels. Python scripts for entities in the game can be edited and attached from within Blender too.


GraLL 1 focuses on the development of GraLL, a spherical robot created by Gravity Systems. After GraLL 1, GraLL is stolen by Antigravity Systems, reverse engineered and locked up in the lab.

Help him escape! Avoid dangerous traps and use keys, teleporters, jump-pads, crates, moving platforms, lifts and numerous other lab equipment to your advantage as you jump between two parallel worlds and play with gravity to make your way through Antigravity Systems' maze-like research facility.

Technical Mumbo Jumbo

The main highlight is the scripting system. Almost everything is scriptable, and almost everything is exposed to script. The scripting system allows every instance of a particular type of GameObject to behave differently. It also allows for scripted sequences. In the original GraLL, the behaviour of every GameObject was hard-coded. Doors were opened with keys, Switches toggled electricity. In GraLL 2, a Switch can execute any piece of Python code (with is associated only with that instance) when switched 'on'. It could open a Door, make a platform move. In fact, it could even make some music play! Of course, the usual Key-Door mechanism and Switch-Platform mechanisms are easier to implement through 'prefabs' ('prefabricated' scripted objects).

If you have the Alpha build, try this:-

  1. Go to Level 2.
  2. Press 'Ctrl+X', then click on a Bomb.
  3. Press 'F3' to open the console, then type this in (you can skip the comments):

    # Write an 'unpaused tick' event to attach to the clicked object.
    def clicked_utick(self, elapsed):
        self.translate(Ngf.Vector3.UNIT_X * elapsed)
    # Set clicked object's 'utick' event to this function we just wrote.
    clicked.utick = clicked_utick
  4. Press 'F4' to run the code.

You should see the Bomb move slowly. It's moving along the X axis. If you used 'UNIT_Y', it'd move upward. There's a lot more fun stuff possible, check out the Wiki for a (rather-incomplete-but-it's-there) description of the Python interface.

Another important new feature is serialisation. This allows the game state to be saved at any point in the game. In GraLL 2, the Player is not free to choose, however. The game is saved only when he goes through a 'Checkpoint' object.

GraLL 2 also features a 'dimension system'. There are two 'parallel worlds' in the same 3D position. Objects can be either in dimension 1, dimension 2, or both. Objects can physically interact only with other objects in their dimension. If there's a wall in dimension 1, but not 2, to go through, switch to dimension 2 and make your way. Kind of like how you jump over a wall by first going 'up' and then 'forward'. Here, you move 'up' in the 'dimension switching axis' and then go forward. Of course, these differences aren't random, they're carefully planned out by the level designer to make fun puzzles. :-) The best way to understand this is to watch one of the videos. An important question that arises is, what happens when the Player switches dimensions when GraLL 2 is in a position that is occupied by an object in the other dimension. Well, in GraLL 2, nothing happens. You hear a 'beep', and it'll refuse to switch.

GraLL 2 also has a lot to show off in the eye-candy department. I've written per-pixel surface shaders (normal mapping, parallax mapping implemented), and a 'glow' compositor. This makes the game look pretty cool (in my opinion), check out the screenshots!

Some other features worth mentioning are the 'brush' system (moving platforms can now be of any shape and size, not just blocks), the 'records' system (more stats for each level), better GUI, the 'options' dialog (you can now set controls, graphics settings etc.), the Python interpretter console.

Users can also make their own data (levels, textures, meshes). The game simply searches for content in the 'Content' directory under the user directory. In-game, he can choose which level he wants to play by clicking 'Play User Level'. The game presents a list of the user levels it found. It can also search within .zip files, which makes it easy to play levels made by other users. Just download the .zip, put it somewhere in your 'Content' directory, and that's it!

These are just features I've implemented till now. There's going to be a lot more. Stay tuned! ;-)