Exploding onto your screen: GPU particles in Turbulenz SDK 0.28.0

SDK 0.28.0 is the first major release of 2014. It includes new libraries (GPU particles) and upgrades to old ones (FontManager). There is also support for newly capable browsers (WebGL, IE11) and fond farewell to old way of doing things, not forgetting plenty of fixes.

GPU Particle API

We are proud to announce a brand new GPU-powered particle system API, designed to simulate and render hundreds of thousands of particles with minimal impact on the CPU. Now you can add pretty particle effects to your games without worrying about having to sacrifice performance. The comprehensive system which consists of a high-level API (for running out of the box) and a low-level API (for developers who customize the behaviour via an extensible interface) comes together with a sample showing how the pieces fit together. Go forth and fill your game with particles!


IE11 support

We’re excited about Internet Explorer’s arrival into the world of WebGL. Internet Explorer 11 is well on its way to supporting the WebGL 1.0 specification and while Microsoft are still implementing the spec, we’ve added a few work-around fixes for the features it is currently missing so you can try your Turbulenz Engine games on IE11 without a plug-in! This feature is still in beta at the moment, so please let us know how you get on and report any issue to the Turbulenz Engine Users Group.

FontManager multiple pages support and subtitles sample

Sometimes a single texture page is not enough to store all the bitmap font characters you need to render in game. This is likely the case when supporting Japanese and other large character sets. The FontManager has been upgraded to support multiple pages as well new properties such as line spacing. These new features are in use in the Subtitles sample, which demonstrates how fonts can be used to render written dialogue for in-game cut sequences.

Library upgrades

The Turbulenz Engine is comprised of many modular-libraries and we are always making improvements to performance, behaviour and robustness. Here are a selection of just a few that have benefited from upgrades in SDK 0.28.0: AssetCache, Camera, FontManager, PhysicsManager, Protolib, Scene, SoundDevice and Turbulenz Services.

Farewell old friend

SDK 0.28.0 marks the deprecation of the “plugin-debug” build mode. Moving forward, this means that apps will no longer be able to generate a debug build targeting plug-ins. Over the past few years, the debugging tools for targeting canvas have improved dramatically, while performance of plug-in targets has decreased. We now recommend all developers to use “canvas-debug” build mode to debug their applications. Release builds targeting the plug-in, Android and iOS can still be generated using “plugin-release”.

In line with browser vendors and platform holders the Turbulenz SDK is winding down support for certain older browser/platform configurations. In SDK 0.28.0 we say farewell to Mac OS X 10.6, Safari 5 and the TurbulenzEngine binary installer for Mac. Previous SDKs will continue to function as normal and users wishing to play the latest Turbulenz Engine games on Mac should use Safari 6 with WebGL enabled or use the latest version of Google Chrome or Firefox.

A flood of fixes

SDK 0.28.0 also contains a large number of fixes and small changes. For the detailed release notes head here.

Download a packaged 0.28.0 installer for Windows, Mac OS X or Linux directly from hub.turbulenz.com.

Alternatively follow the latest engine SDK development via the open source turbulenz_engine github repo.

Happy Hacking


Short video demonstration of the in-game editor created by Wonderstruck Games that they’re using to create their next game.

The editor is an evolution of the in-game editor that was used to create Polycraft.

The editor allows the developers and designers to quickly switch between playing and creating - giving them a rapid process of iteration. As many bites at the cherry as you could ever want.

The editor and game are built with the Turbulenz Engine.


Turbulenz Engine on Android developer release

We’ve finally released a developer application for running games created with the Turbulenz Engine on Android. (The iOS version is just around the corner.) The purpose of this app is to let developers start getting their games in shape. This means reviewing screen resolution, touch input, payments via the Google Play Store and CPU / GPU performance. Make sure you check it out if you want to create HTML5 apps that work across all devices.

This mechanism allows you to publish a native app that knows how to play JavaScript / HTML5 applications from your own (or the Turbulenz) web service.

We continue to petition and work with platform owners to promote HTML5 applications as first classic citizens in their operating systems. Things are looking good on Tizen, Firefox OS, Chrome OS and hopefully the full Windows family, and we’re gradually getting there on Android, with Apple dragging along at the back with OS X and iOS. (Fingers crossed for iOS7.)

Check out the developer announcement on the Turbulenz Engine Users group for details on getting started.

Additionally, there is a README in the Turbulenz docs online.

Make sure you are a member of the Turbulenz Engine Users group to get access to the Android APK on the Google Play Store.


Turbulenz JavaScript libs available for tinkerers…

There are a few ways to get started with the open source Turbulenz Engine.

1. turbulenz_jslib repository

Explore the JavaScript libraries directly from the turbulenz_jslib repository on Github. The master branch tracks the main development line.

Each versioned release of the engine is available as a git tag, so you can check out 0.26.1, or browse 0.26.1 or directly download the source as a 0.26.1.zip or 0.26.1.tar.gz.

This version is great for browsing and prototyping applications with procedural content. However, this repo doesn’t come with any other tools or assets for building applications. This is no problem if you already have a set of tools that you want to connect with a Turbulenz powered runtime app.

2. turbulenz_engine repository

This is the main open source Turbulenz Engine repository on Github. This is where the Turbulenz Engine is publicly developed and contains everything required to create the Turbulenz SDK.

Building the engine from the source in this repository does require a collection of tools. All the requirements and setup details are defined in the repository’s README and getting started guide. The main step is building the JavaScript libraries out of the source TypeScript libraries. The Turbulenz Engine was ported to TypeScript to help control the complexity and development cost of such a large and feature-rich set of JavaScript libraries.

Additional tools and dependencies are required for building assets including shaders and models.

3. Turbulenz SDK releases

If you don’t want to track the development line or build the engine from source but would rather have a QA’d released SDK then you should check out the Turbulenz SDK releases. These are available to download from the Turbulenz developer service at hub.turbulenz.com.

Packaged installers are available for Windows, Mac OS X, and Linux. These installers have a limited set of dependencies but set up a full development environment. This environment can be integrated with your own game development environment. Details on using these SDKs are available in the main Turbulenz documentation.


WebGL on IE11: welcomed but unfinished

Last week Microsoft released a preview of Windows 8.1 including a version of Internet Explorer 11 supporting WebGL. This is great news from Microsoft and immediately downloaded and installed the preview version in order to test the game engine running on IE11. Once the installation was complete the first thing we ran was the device initialization sample, and we got a couple of errors on the Console:

Not a great start, but lets look at the stats reported by the WebGL device:

The interesting bit is what is missing from the bottom, after “Extensions:”. Disappointingly IE11 does not support any WebGL extensions yet. This is unfortunate because some of them, for example the ones that provide support for compressed textures, are fundamental to reducing memory usage and improving performance.

Anyway, we pressed on and tried one of the less graphically demanding examples:


You may notice something missing, those cubes are supposed to have a nice crate texture on each face! There are a few reasons they don’t:

1. One of the errors reported by the console is “vertexAttribPointer: Enum SHORT is not currently supported”, you can see it at the bottom of the first image.

This particular example is storing the UV coordinates used for the texture as two 16 bit integers, the values are just 0 and 1 so using integers is a perfectly valid way of saving memory, the alternative is to use two 32 bit floating point values which would double the storage requirements for each UV component. This is not a big deal for a simple cube, but can become a more serious issue for big models. Reducing memory requirements is very important for games, even more so if your game is running on a browser on a mobile platform, so being able to use smaller vertex formats is a requirement for us.

2. Another error reported by the console is “bindAttribLocation: Method not currently supported”, you can see it in the middle of the first image.

Turbulenz relies heavily on using bindAttribLocation to assign vertex components from vertex buffers to their relevant input attribute on the vertex shader. We could use getAttribLocation to ask the vertex shader where it wants its inputs, but this would require late binding of vertex buffers and the update of attribute locations if the shader changes. So instead the Turbulenz engine uses bindAttribLocation to tell the shader where to get its inputs from, which allows us to bind the vertex buffer immediately and to only have to bind it once. This is important because the Turbulenz engine creates large vertex buffers that are shared between several static geometries, independent of whatever rendering technique they use, allowing us to avoid the memory overhead of creating multiple buffers and also reducing the number of state changes. This is part of what makes Turbulenz such a high-performance rendering engine.

Continuing with our experiments we tried the sample app, which is just a rotating duck, and got nothing on the screen. Why? Well, there were more errors reported on the console:

The first error reported is “bufferSubData: Method not currently supported”. The lack of support for this method is significant. As explained earlier, the Turbulenz game engine shares big vertex buffers between several static geometries in order to avoid memory overhead and state changes. In order to do that, vertex information needs to be submitted independently for each model using the method bufferSubData. One alternative would be to keep sharing but to upload all the vertex information at once, but this requires us to hold all the geometry in memory longer than we would like and is also not practical if the game is streaming in and out static geometry. The other alternative requires creating an individual vertex buffer per geometry, which is not acceptable because it will increase buffer overhead and require more state changes.

The other problem we hit with this sample was:


It seems the WebGL implementation on IE11 does not understand GLSL shaders with structure declarations - a perfectly valid language feature that is supported in other browsers. The only reason the first example we tried rendered anything to the screen was because we don’t always use structure declarations in our shaders, for simple programs it is just quicker to declare the varying values independently. Admittedly we were considering removing structure declarations from our shaders because they make the shader code bigger (a concern for us as we try to seriously reduce the amount of data a game needs to download in order to render anything on the screen) so we may rewrite our shaders to work with this version of IE11.

There were more things failing on other examples: triangle fan primitives are not supported, luminance only texture formats are not supported, full stencil support is missing, etc. And, we reproduced the same issues on different machines with different video cards from different manufactures.

Are we going to change our code to workaround the missing WebGL features on IE11? Not whilst it is in development and only a preview.

Some of the workarounds will require substantial changes to the engine, and they may impact performance significantly. This version of IE is clearly not final yet, and we’re keen to help Microsoft deliver a fully compliant implementation of WebGL that would make Internet Explorer 11 competitive with Google’s Chrome and Mozilla’s Firefox. Exciting times for WebGL and HTML5.



Q&A with Wonderstruck Games on Creative JS blog

The Creative JS blog has posted an interview with Wonderstruck Games about the development of Polycraft.

Their lead developer (Adamtalks about moving from console to HTML5 game development, creating Polycraft and plans for the future.

Check it out.


develop - Tools Spotlight on Turbulenz

Develop has published a short spotlight on Turbulenz. It covers the status of Turbulenz now that it has been open sourced.

Check out the article on the Develop website.


Turbulenz Engine at The NYCoders meeting TODAY!

Quick note to let everyone in New York know (yes, everyone in New York -  pass it on) that Duncan will be presenting details of the Turbulenz platform at the NYCoders meeting today at 7pm EDT, Wednesday 5th June.

For all the details checkout their post.


Developers! Now it’s your turn with new Data Shares and Notifications API in SDK 0.26.0

SDK 0.26.0 is the first SDK release since Turbulenz went open source and there are plenty of new features for devs to sink their teeth into.

As well as all the improvements added to the turbulenz_engine, turbulenz_local and turbulenz_tools Github repositories, you can find the following new features:

Data Shares API

The Data Shares API is a new Turbulenz service that allows games to save information between users, that are online or offline. While the User Data API allows games to save information specific to that user, Data shares allow running games to save key-value pairs that other games can read. One application of this feature is to create turn-based games or share game generated content with other users when the original player is offline. See the Data Shares API for more details.

Notifications API

The Notifications API is a new Turbulenz service that allows games to send notifications to users. These notifications are akin to the short messages that users of Turbulenz receive informing them of site activity, such as badges achieved or scores beaten in leaderboards.

Games are now able to send instant or delayed messages to a user (including the current user), which will be received in real-time (online playing), as a site notification (online) or as an email (offline). They can be used to inform users of activity, such as “It’s your turn” or “Your base is under attack”.

When used in conjunction with the Data Shares API, developers can now write games that combine, turn-based online/offline play with real-time communication. The new Tic-tac-toe app demonstrates how the APIs can be combined. See the apps directory of the SDK/Github repository.

Rapid prototyping with Protolib

Inspired by prototyping libraries used by the Turbulenz team for rapid development of game concepts, the Protolib API is a new way for Turbulenz developers to get started building games. The high level API is for 2D and 3D development and is designed to simplify features such as model loading, sound playback, text rendering, input and much more. Sitting on top of the TypeScript and JavaScript APIs is a great stepping stone to using more advanced Turbulenz APIs, whether it be throwing together game concepts or entering game jams. To help you get started, SDK 0.26.0 includes the Protolib Sample App a combined demonstration of the various APIs and Protolib Template App a skeleton app structure to start building a Turbulenz app from scratch.

Protolib was used during the Turbulenz Getting Started Webcast to build Debris Dodger a simple game example, built in 40 minutes.

See the Protolib documentation to get started.

Local server upgraded

Part of providing the Notications and Data Shares APIs, the local server now has support for logging multiple users in at the same time. This allows games to test multiple users interacting on the same server, which is the same functionality provided on hub.turbulenz.com and turbulenz.com.

In addition to the open source changes to how the Turbulenz local server and tools are packaged, the deployment process has been improved, now remembering which developer was logged in when deploying and making the discover of previously deployed project versions easier.

Rendering performance improvements

This SDK includes additional performance improvements to the 3D renderers focussing on reducing the CPU cost preparing for rendering. There are also improvements to the 2D canvas implementation, confirming it as viable option for accelerated canvas 2D rendering. These improvements should benefit machines that were previously CPU limited.

Fixes summary

  • Various fixes for the viewer rendering.
  • Addition fixes to the dae2json and obj2json importing.
  • T1424 - Local does not remember the password when deploying a game from Local to Hub.

More details of these features and additional improvements can be found in the release notes.


What is the status of Turbulenz for mobile?

The question we get asked more than any other is “does the Turbulenz Engine work on mobile?" Specifically how to use the open source Turbulenz Engine on Android and iOS.

The current answer ultimately reflects the limitations of the mobile operating systems and their associated browsers.

A game created with the Turbulenz Engine depends on the web application platform for execution. The application platform must contains all the parts that the game requires, most importantly a JavaScript engine and implementations of all the JavaScript APIs used (often called HTML5 APIs.)

The Turbulenz Engine is designed and implemented with a modular architecture. Hence it is the game that defines which modules from the engine are required and used.

Some of the APIs the engine modules require are:

There are two ways that Turbulenz games can run on mobile platforms:

1. Game runs in the browser:

As explained above, the Turbulenz Engine is supported on any browser and OS that implements the required JavaScript APIs. This already includes several mobile browsers, meaning that it is already possible to make an HTML5 game that will work on the mobile versions of Chrome and Firefox, Chrome OS, Firefox OS and other HTML5 native operating systems.

For any browsers that don’t support WebGL, for example Safari on iOS, you can’t use the 3D and high performance 2D rendering APIs. Instead you should use the 2D canvas element and rendering APIs. However you can still use all the other features in the Turbulenz Engine, including the physics engine, animation framework and web services.

The only limiting factor is that Safari for iOS supports canvas 2D rendering but not WebGL. Hopefully future releases of iOS will include a complete WebGL implementation.

2. Game runs as an App:

We are developing a native client which provides both the 2D and 3D hardware accelerated infrastructure required to run games created with the Turbulenz Engine on mobile devices. This can be used in place of the browser to open and run game URLs. The games can be hosted anywhere online as long has they have been correctly built with the Turbulenz tools. Games using the Turbulenz native client will have access to all Turbulenz APIs.


This version of your HTML5 game can be distributed as a native app and can be published to the platform owners app store, including the Apple App Store, Google Play, and Amazon App Store. If the game uses the Turbulenz Store APIs the native app will automatically connect payment requests to the native payment service. 

The native Turbulenz client may be thought of as a stop-gap until more mobile browsers improve their support for HTML5 and related APIs.

We’re also working with (and encouraging) mobile platform owners to add support for HTML5 as first class citizens in their app stores and operating systems. This would allow JavaScript applications to be deployed as apps without requiring an explicit native client or first launching a browser for execution.

The first game packaged as a native app will be released for Android in a few weeks. Early access will be given to developers who are interested. Please contact us for more details.




Turbulenz Getting Started webcast now available on demand

Forget to watch the Turbulenz getting started live stream? Remembered too late and joined halfway through? Had to take the dog for a walk?

No worries! The recording of the first (of hopefully many) Turbulenz Livestream events is now available for catch-up. You can find the video on:


The session included:

  • Getting setup with the turbulenz_engine open source repository.
  • A brief introduction to using the Turbulenz APIs.
  • A step-by-step walk-through of building a game, combining 2D physics with 3D rendering.
  • A demonstration of the example game on hub.turbulenz.com, playable from desktop and mobile.

Q&A with Ian & David from the Turbulenz development team.

The example game “Debris Dodger" created during the session has been made available on Github so you can try it for yourself. Just update to the latest open source version and follow the steps in the README.

Debris Dodge Github repo with all the code and assets to play with.

A few additional links to things we discussed:

Any follow-up questions and feedback should be directed to the Turbulenz Engine Users Group.


Join our live webcast: Introducing the Turbulenz HTML5 game engine!

We are holding a live webcast to introduce users to the open source Turbulenz Engine on Tuesday 21st May. It is free and anyone can join. You can receive email updates on the event by registering online. Whether you’re already using Turbulenz, working on HTML5 games or applications, investigating technologies for an upcoming game, or have a general interest in modern game technologies, this session is worth joining. You can even send us questions in advance on the event page here.

The agenda is:

  • Getting set up with the Turbulenz HTML5 Engine
  • An introduction to the main features and APIs
  • Creating an HTML5 app
  • Getting your app online
  • Q&A with the Turbulenz development team

Time: Tuesday 21st May at 8am West Coast US / 4pm UK time / Midnight Japan time.

Location: Streamed live online at livestream

Duration: Presentation will last 1 hour. We are leaving an additional hour afterwards for Q&A.

We hope to see you there.


"Thank you!" in response to open sourcing the Turbulenz Engine

It’s been a really exciting week for us here at Turbulenz and we have been totally blown away by your response to our release of the Turbulenz HTML5 game engine under the MIT license.

It’s always nerve-wracking releasing something into the wild which is why we are so excited that our engine has been trending on GitHub with over 1200+ stars and 140+ forks. It’s great to see so many people trying out the engine, and we’ve even accepted our first pull request.


But it’s not just on GitHub that we have seen plenty of action. Articles on DevelopGamesindustry.biz, Gamasutra and Gamesbeat have got people talking, with discussions on Slashdot and Hacker News. And we have been really excited about the buzz on Twitter - there have been over 1000 tweets and retweets talking about the open sourcing of the Turbulenz engine.


And it’s not just our open source engine that has been getting your love. Our friends at Wonderstruck knew they would probably get some attention when we made our announcement so they pulled out all the stops to get a new version of Polycraft ready for all our new visitors, including huge new gameplay elements like outposts and a whole range of new enemies. And it looks like all the hard work has paid off as we have had over 7000 new players. If you haven’t had a chance to try Polycraft yet, play it here.

So we just wanted to say a big “Thank You” for all your support and encouragement. But this is only the start for us. We need you to help us to keep on building the best HTML5 engine in the world. Whether you’re asking and answering questions on the engine users forum, reporting bugs and requesting new features, or just saying hi on twitter, we’d love to hear from you!


Turbulenz Engine Goes Open Source

We’re excited to announce that we have released the Turbulenz HTML5 game engine as open source under the standard MIT license. The open source project is available on GitHub at https://github.com/turbulenz/turbulenz_engine.

You may have seen Turbulenz mentioned somewhere and wondered what it was. Turbulenz provides a game engine that delivers all the building blocks developers need to rapidly create high quality and hardware accelerated 2D and 3D games playable across mobiles, tablets and the web.


Polycraft by Wonderstruck

We started developing the Turbulenz Engine a little over 4 years ago in early 2009, when HTML5 was still in its infancy and before WebGL even existed. We recognized that JavaScript and the web development platform offered a huge opportunity for creating high quality games and as a mechanism and market for dynamically distributing content.

We initially proved this to ourselves by creating the service and engine capable of streaming and rendering the majority of Quake 4. This continues today to be a great test of the engine as it has evolved. You can see it demonstrated by our CTO David Galeano.

Today, the Turbulenz Engine powers the highest quality 2D and 3D HTML5 games online. If you want to see some examples we recommend looking at:


Save the Day from BAFTA-winning Denki

We have seen a monotonically increasing interest in the engine and SDK since it was first made publicly available.

If you want to take a look, the best place to start is the README which you can find on the Github project page and included in the source. This details how to set up a development environment and includes a short getting started guide on how to use the Turbulenz Engine APIs. From here we recommend going through the Getting Started guide and reviewing all the documentation online.

The engine is also available bundled in an easy to install SDK for Windows, Mac OS X and GNU/Linux. This might be an easier option if you’re looking for a packaged-up and fully QA’d snapshot of the engine. All future SDK releases will contain the open source engine with the associated MIT license. (Earlier versions of the SDK were released with a partially open license which has now been deprecated.) The bundled SDK is available from the Turbulenz developer service.

What Features Does the Open Source Turbulenz Engine Provide?

The Turbulenz Engine contains an extensive range of features and services for creating games. The engine was designed to be a complete Internet generation game engine. By this, we mean a game engine that was conceived, designed and implemented specifically for building games that are played via the Internet using web technologies, rather than as a native application on a console or PC. This is a single suite of technology that spans the client game application and remote game services.

The libraries contain solutions for all sensibly reusable game services, including: 2D and 3D graphics, 2D and 3D physics, 2D and 3D effects, sound, networking, user input, scene graphs, hierarchical animation, movie playback, resource management, server requests, a range of renderers, leaderboards, badges, payments, save game userdata, user profiles, game profiles, multiplayer, metrics, maths and numerous utilities.

The graphics engine is completely shader driven and hardware accelerated using WebGL. It has been implemented to allow games to efficiently dispatch their scenes. The engine comes with multiple renderers which can be selected depending on the features and performance of a user’s device, this includes, a deferred renderer, a forward renderer and a default renderer. There is also a highly efficient 2D renderer for efficiently dispatching huge numbers of sprites and effects.

The 2D and 3D physics engines are particularly powerful in comparison to the procedurally generated ports of currently available.

All the technology has been handwritten as efficient TypeScript and JavaScript to maximise execution and memory performance.

There is a detailed list of all the engine’s features in the repository README and in the documentation.

Why Are We Open Sourcing the Engine?

We’ve had a lot of interest in the Turbulenz Engine via our SDK packages and many of the people who try it out have praised the features and performance. However, two issues that have often come up are any sort of restrictive licensing and the ease of getting things started.

By releasing the Turbulenz Engine as open source under a standard liberal MIT license we hope to ease the adoption costs and ensure that people don’t feel in any way restricted by using the Engine.

What Are the Design Goals of the Turbulenz Engine?

The main design goals of the Turbulenz Engine are performance, modularity and customizability. Users of the engine should be able to build any kind of game without limitations, in an efficient manner and with an end product that performs optimally when loading and during play.

To achieve this target the Turbulenz team followed these rules when writing code:


  • Users should be able to pick what they want and replace what they don’t.
  • When possible new functionality should be orthogonal to existing one.

High performance

  • Strict coding standards to keep code efficient.
  • Keep memory allocations to minimum, reuse existing objects or arrays whenever possible, use scratch pads, combine multiple separate objects into a single one.
  • Use most efficient storage for each data, Typed Arrays when possible.
  • Reduce function calls when possible: write functions that handle arrays of objects instead of loops that make a function call per element, games rarely do a single thing to a single object.
  • Be aware of performance differences between browsers.
  • Profile often.

Asynchronous loading

  • No API should block waiting for a response from the server, avoid polling whenever possible, use callbacks or Promises, to notify of data availability.

Data driven

  • The target should be to make the game a simple dumb player of data, all functionality defined by simple data files.

Simple well documented file formats

  • Define simple, easy to create asset formats that can trivially be connected to any tool chain.


  • Design interfaces that can be implemented with different level of detail or quality settings in order to scale from mobile to desktops.

Power without control is nothing

  • Make sure users can do exactly what they want, with a helper layer put on top if required, document performance implications at every level.

Fault tolerant

  • The engine should keep going even if any type of asset fails to load. The application is able to provide sensible defaults for all asset types making it easier to stay productive and diagnose issues.

Fast loading

  • Reduce amount of data to be downloaded, compress data efficiently.
  • Use the browser cache efficiently, use unique file names based on content and tell the browser to cache forever.


  • Strict coding standards to keep code readable, easy to maintain and debug.
  • Write unit tests, samples and documentation for every new code path.


  • This is a game engine, for games.

What Have We Made Available?

We’ve made three Git repositories available on GitHub:

Turbulenz Engine - https://github.com/turbulenz/turbulenz_engine

  • TypeScript and JavaScript implementations of the game engine
  • Documentation of the libraries, APIs and tools
  • Code samples demonstrating the engine APIs
  • Application samples showing how a basic but complete game can be built
  • Protolib high level prototyping libraries

Turbulenz Tools - https://github.com/turbulenz/turbulenz_tools

Turbulenz Local - https://github.com/turbulenz/turbulenz_local

  • A locally hosted Python development web server implementing the Turbulenz services APIs
  • Tools for interacting with the Turbulenz Hub
  • Also available from PyPi as turbulenz_local.

Want to Contribute?

We know there is a large and growing community interested in HTML5 game development and we hope that people will find this project an empowering contribution to game and Internet technology domains. Now that the project is fully available as open source and easily accessible via GitHub all contributions are gladly welcomed. Please send the project a pull request or post a git diff patch on the Turbulenz Engine google group.

Please Help Us Spread the Word

Please help spread the word to your friends and followers by sharing this announcement online. We want to make sure that anyone thinking about making a game with HTML5 is aware of Turbulenz as a free and open source solution that comes packed with high performance features.

Learn More

Sign up for the free WebCast on 21st of May at 9am PST / 5pm BST. This will include an introduction to the technology, show you how to get started, and leave time for Q&A.

Any questions or ideas about the Turbulenz Engine, HTML5 games or anything else, please get in touch.

Happy Hacking!

- James Austin

Turbulenz CEO


TypeScript in focus - getting started with TypeScript Turbulenz

SDK 0.25.1 is a minor update to SDK 0.25.0 and contains a few fixes and updated documentation. If you’ve just updated to 0.25.0 this update should be a breeze.

TypeScript in Focus

There’s now a whole new section in the “Getting Started Guide" that goes into depth about how to build against Turbulenz TypeScript modules. With a walkthrough example and commands that you can use with your own build system. You should be up and running in no time. Future developments will include a standardised build structure, so watch this space.

More and more COLLADA updates

We’re continuously making updates to our dae2json tool; supporting additional features and making improvements. There’s so much going on we can get them out fast enough. See the detailed release notes to find out what’s new.

A fistful of fixes

Fixes in this release include a bug in the soundDevice.listenerGain property on canvas and the correction of a few missing files in the SDK. See the release notes for details.

Archive Random Next page Page 1 of 8