Greetings from Kiwi.JS v1.3.0 “Moriarty”

Hello readers. Today we are happy to announce the release of Kiwi.JS version 1.3.0, “Moriarty”. This release is named in honour of Brian Moriarty, designer of Loom, a fantastic fantasy game made by LucasArts in the 90s that inspired many of us here at the studio to embark on our game development journeys. “Moriarty” also sounds like you are talking to a cunning and dastardly villain, which we think makes it sound awesome.

This latest version of Kiwi brings new features to multiple areas of the engine. Instead of focusing on a particular area to upgrade we decided to add in a lot of niceties that we have always wanted, such as window focus/blur events, window visible status, passing parameters to State preload methods, plus much more.

You can download Kiwi.JS v1.3.0 on github now.

New Features

  • Window focus/blur events added to the Stage allowing users to easily pause/resume their game. (#23)
  • The Animation Component will now look for sequences on their given texture atlas if told to play a sequence that can not be found. (#83)
  • TileMapLayers have been seperated into Orthogonal and Isometric classes to keep code more maintainable as well as more succinct. (#85)
  • Additional file management methods added to the FileStore class. (#103)
  • You can now pass parameters to a states preload method when switching states. (#104)
  • You can now filter out messages to be logged out when using the Kiwi.Log. (#151)
  • Much better consistency for passing file types. (#156)
  • @rydairegames added a method to get a tile when you know its index. (#160)
  • ArcadePhysics now contains a rotateToVelocity method. (#179)
  • Clocks now contains deltas. (#183)
  • You can now assign floating point values when changing an Animation‘s frame; they will be rounded to the nearest frame. (#186)
  • Audio now contains an onComplete signal. (#189)
  • Context menu events have been added to the Mouse Input Manager. (#191)
  • HUDWidgets can change the origin the position is based on. (#193)
  • New get children by tag methods added to groups. (#195)

Bug Fixes

  • Animation employs more rigorous methods which ensure the frameIndex is correct. (#184)
  • Timer no longer hangs when the interval is set to 0ms. (#187)
  • setInterval and setTimeout now deal with clock units. (#188)
  • IconBar positioning fixed. (#192)
  • Minor fix with the image loading when using the xhr + arraybuffer methods of loading.
  • ArcadePhysics tile collision boxes made smaller to give better collisions.

Special thanks goes out to @rydairegames for providing the getTileFromIndex method. We think it is extremely useful already.

More details can be found on the Kiwi.JS repo under the 1.3.0 milestone.

If you have any questions, or would like to report a bug, please resist the urge to shout, “Curse you, Moriarty!” Instead, visit our website and make use of our growing community!

KiwiJS v1.2.3 Available

Easy as 1-2-3, here’s the latest KiwiJS fix release.

You can download KiwiJS from our GitHub repo.

This release incorporates the following:

  • Clock.elapsed() now resets to 0 after start() is called.
  • Geom.Intersect.lineToLineSegment and lineSegmentToLineSegment now work correctly.
  • Entity.inputEnabled wasn’t used by anything, and is now officially deprecated.

Let us know what you think on the website!

KiwiJS v1.2.2 Ready To Roll

We’re pleased to announce KiwiJS v1.2.2 is now available. This release fixes a number of bugs in animation and geometry.

Download KiwiJS v1.2.2 here.

Bug fix list includes:

  • Animation now correctly plays non-looping animations.
  • Animation.onPlay, .onStop, .onupdate, .onLoop, and .onComplete now correctly documented in API.
  • Geom.Intersect.circleToRectangle() and Geom.Intersect.lineToRawSegment() now work correctly in all cases.
  • Geom.Intersect.lineSegmentToRectangle() is now named correctly in API docs.
  • Geom.Line.perp() can now deal with points at (0,0) and other edge cases.
  • Added method Geom.Intersect.lineSegmentToRawSegment() to allow lineSegmentToRectangle() to function correctly.
  • Animation now correctly plays 1 frame animations and dispatches signals appropriately.
  • Utils.GameMath.nearestAngleBetween() now returns normalized angles so results are truly nearest.

New Updates: KiwiJS v1.2.1, Particles v1.2.0

Announcing two new update releases in the KiwiJS family. KiwiJS v1.2.1 fixes some bugs, and WebGL Particles Plugin v1.2.0 updates the plugin to use KiwiJS 1.2.x standards.

KiwiJS v1.2.1 is available on Github. This is a patch release, resolving bug fixes and improving performance. It does not include new API functionality. Release notes include:

  • Animation could, under certain circumstances, freeze for a few seconds before playing. This was due to accidentally starting in 1970 and scrambling to catch up. This is no longer possible.
  • Clock.rate will now equal 0 if the clock is paused or stopped.
  • Correct documentation for TextField and Kiwi.HUD.Widget.MenuItem to show proper constructor information.
  • Non-looping animations now refer to the correct cells when played a second time.
  • State.create now fires after file loading is complete. Logs no longer overlap between loading and creating.
  • MasterClock now starts today, rather than 1970, avoiding anomalous results on first frame.

Update: The bugfix had a bug, which has been hotfixed. Downloads should now work properly.

WebGL Particles Plugin v1.2.0 is available on Github. This is a minor release, adding functionality. The main purpose of this release is to add compatibility with features in KiwiJS v1.2.x. Features include:

  • Upgrade to KiwiJS v1.2.0
  • Add setColor and getColor methods, allowing you to use Kiwi.Utils.Color style color values.
  • Add clock property to drive particle animation based on in-game rather than game-independent time
  • Config parser is stricter with numbers expressed as strings. It can find and correct most of these errors. This is not an issue in many browsers, but it has caused problems in CocoonJS.

We hope these releases are useful. Let us know how they work out!

Hello from Kiwi.JS v1.2.0 “Williams”

Happy New Year from the Kiwi team! Today we are happy to release version 1.2.0 of Kiwi.JS, “Williams”.

This version of Kiwi.JS brings powerful new ways to build and automate game architecture. With a robust Entity Component System, more time controls, faster file loading options, a new debug logging system, unified color format, and more, we reckon you’ll be able to build some seriously pro games.

“Williams” is named in honor of Roberta Williams, creator of the King’s Quest series and one of the great adventure game designers. Where would modern gaming be without Williams? We’re big fans here.

You can download 1.2.0 of Kiwi.JS on github now.

New Features

Kiwi.JS v1.2.0 has several exciting new features. Some of these are so cool that we’ll be doing entire posts on them in the near future. Upcoming articles include:

  • Entity Component System
  • Robust Clocks and Better Animation
  • Kiwi.Log Debug System
  • Color System
  • Revised File Loading System

We’ve also made some smaller improvements that don’t merit their own article. We’ll explain those here.


When an Animation is set to a single repetition, and it successfully completes that repetition, it fires a Signal called onComplete. This is useful for signalling the completion of a single event. It is different from onStop, which may fire upon completion, but will also fire if the Animation is interrupted.

Transform Performance Upgrades

GameObjects must have a Transform to set their position in space. Unfortunately, Transforms use matrix mathematics to do their thing, and this can be costly on low-end CPUs such as those in mobile devices.

We’ve streamlined the Transform process to make it 10-30% faster. In addition, we’ve supplied a couple of useful functions to squeeze even more power out of the Transform.


By default, Transform will get a matrix from its parent. This allows the Transform to follow a parent through any transformation, as though it were part of the parent Transform. Set ignoreParent = true to disable this, gaining some performance back. The entity will still be able to transform, but it will not respect any parent transforms. This is useful if your entity is not part of a Group. Note that the State is also a kind of Group, so if your entity is a child of the State, and the State does not transform, ignoreParent = true is a great way to get a little more oomph.


By default, Transform will update its matrix every frame. Set locked = true to disable this, gaining some performance back. The entity will be locked at its current transform. It will still respect parent transforms. This is useful for objects that don’t change often.

TextField now has a hitbox component. This hitbox is a clever estimate based on expected text dimensions. If you wish to add other components, such as physics or input, the presence of a Box will make it possible.

Game domParent can use CSS Selectors

When specifying the domParent in game options, you can now use CSS Selectors as well as DOM element ids.


Tired of writing long conditionals to figure out whether a number is within bounds? isBetween( x, min, max ) will do the heavy lifting for you. Note that it only returns true if x is genuinely between min and max; if x = min or if x = max, it is not between them and is thus false.

Pointer.pressed, Pointer.released

Pointer (and by extension Finger and MouseCursor) now have pressed and released properties. These are true only on the frame directly after the pointer is pressed or released. This was previously difficult to ascertain if you were creating your own input methods.


You could already call Camera.transformPoint to transform a Point into world coordinates. With transformPointToScreen, you can go the other way. This will tell you where a Point in world space maps to the screen. This can be useful for ascertaining whether something is on screen, positioning HUD elements over game objects, etc.

Reassign Tween.object

There is now a setter that permits you to reassign Tween.object midway through a Tween. This will immediately stop updating the current object. The new object will inherit the current value of any tweening value. Any tweening value that is not present on the new object will be removed from the Tween. This could be useful for substituting one object for another midway through a Tween, as in a transformation sequence or an entity suffering battle damage.

TextField name

What’s wrong with “Textfield”? It’s not properly camel-cased: it should read “TextField”. We’ve added the correct name as an alias. Old code will still work, but new code may be written in a more pleasing fashion.

Release Notes

v1.2.0 "Williams"

New Features

  • Pro architecture tools out the wazoo
  • All Component objects on a Group or Entity will automatically update when the State updates. This permits a full Entity Component System. (#122)
  • Clock greatly improved (#143)
    • Time can run at any rate, in any direction
    • rate property available on clocks
    • Animation, Tween, and TweenManager use new clock abilities
  • Animation has a Signal called onComplete which fires after finishing (#143)
  • Kiwi.Log added. This replaces and upgrades console.log functionality, with recording, tagging, and selective muting. It’s a big step up for debug! (#117)
  • Kiwi.Utils.Color object can record and output color values in a very wide range of formats, including RGB, RGBA, HSL, HSV, CSS color functions, and normalized or integer values. (#135)
  • File system is more flexible
    • Parallel loading option for lightning-fast downloads
    • Load files with easy-to-use parameters
    • Easily manage state-specific files
  • Transform optimisations (#141)
    • Improved performance
    • Transform may be set lock = true to prevent updates and increase performance
    • Transform may be set ignoreParents = true to save performance with objects whose parents don't update
  • TextField now has a hitbox (#137)
  • Game domParent parameter can now use CSS selectors (#131)
  • Kiwi.Utils.Common.between( x, a, b ) method added. It's much faster to check if something is between two numbers now. (#118)
  • Input.Pointers now has pressed and released getters, allowing you to see if a mouse or finger was pressed or released in the last frame only. (#115)
  • Camera.transformPointToScreen added, allowing you to translate world points to screen coordinates. This is the opposite of Camera.transformPoint. (#112)
  • You may now reassign Tween.object, transferring a Tween from one object to another. (#109)
  • State.loadProgress() can now estimate bytes loaded (#66)
  • Timer Helpers implemented. You can now call Clock.setInterval and Clock.setTimeout, rather than mess around with three or more calls to get the same effect. These helpers run on game clocks, and will respect clock manipulation and pausing. (#44)

Bug Fixes

  • XHR loading works with Nodewebkit where status codes are unavailable (#144)
  • Kiwi.Utils.Common.defaultToString is now in camelCase (#140)
  • TileMapLayer.getOverlappingTiles now works correctly with negative coordinates (#139)
  • Kiwi.Time.Clock.removeTimer works correctly (#138)
  • Audio objects now loop correctly after being paused and resumed (#132)
  • PluginManager now correctly allows requirements that match or exceed requested version number, rather than those that match or precede it. (#130)
  • Game prints the correct error message when no stage was specified, or an incorrect stage was specified. (#129)
  • Mouse events now include button data. (#126)
  • AnimationManager now calls onUpdate after changing cellIndex, ensuring that callbacks have more accurate data regarding cells. (#125)
  • StaticImage.objType() now reports "StaticImage" instead of "Sprite" (#119)
  • Spritesheet texture atlas correctly enumerates number of cells. (#116)
  • Timer resumes where it left off after being paused (#113)
  • File loader now correctly interprets files without extensions in CocoonJS (#106)

Deprecations and Removals

  • Textfield is deprecated in favour of TextField alias (#134)
  • Kiwi.Utils.Common.defaultToString is now in camelCase (#140)

Project Architecture

  • Switched to Typescript 1.4. Run npm update to upgrade your packages.

More details can be found on the Kiwi.JS repo under the 1.2.0 milestone

Grit your teeth – Damage Pipeline Plugin incoming

Tired of taking the same 10 damage? Want to introduce elemental weakness and resistance? How about stun damage, or energy shields, or a super meter that builds as you take hits? The new Damage Pipeline Plugin has you covered.

Connect nodes and meters, then dispatch packs into the pipeline. This plugin makes it easy to design and modify modular damage systems as you go. Create a fully functional health and armor system in less than 20 lines of code.

In this example, everything is controlled by a damage pipeline. The animation of the health bar, the text alerts, the changing status message… it’s all done by the pipeline. (With a little help from the Primitives Plugin, of course.) Note how we remain unscathed if our armor absorbs the physical blow, thanks to the ability to stack “sub Packs” representing dependent damage types.

To get started with the Damage Pipeline Plugin, check out our easy introductory tutorial.

Then download the Damage Pipeline Plugin from Github. We hope you make something amazing!

HTML5 Gamepad plugin!

Hey guys! If you’ve ever wanted to use your Gamepad in your html5 games you do not have to wait any longer!

The HTML5 Gamepad-Plugin for Kiwijs does just that. It allows you to easily connect up to 4 Gamepads to one html5 game.

Now you will finally be able to make those games you always dreamed of. So go ahead and grab a copy of the plugin from our repository and get coding!


Gamepad-plugin for Kiwijs

Kiwi.JS 1.1.1 reporting for duty.

Hello again! Today we bring to you an update to Kiwi.JS. Version 1.1.1 introduces some bug fixes and updates for currently existing systems in Kiwi to make it more stable. We’ve taken particular care to make CocoonJS work really well for this release.

Systems Changed

  • Blend modes now work correctly in CocoonJS when deviceTarget: Kiwi.TARGET_COCOON is set, fixing a number of bugs. This allows CocoonJS deployment to a wider range of devices with more reliable quality.
  • Methods on a number of Geometric Objects (such as the angleTo method on Point) have been fixed.
  • Mouse events (down, up, scrollwheel and move) now prevent the default action from escaping to the rest of the page.
  • For CocoonJS the default stage colour is now ‘#000000′. Even if your game doesn’t fill the entire screen, the WebGL renderer will use this colour to fill all parts outside of the game area.

More details on the specific bugs which were looked into can be found on the Kiwi.JS repo under the 1.1.1 milestone.

Introducing Kiwi.js Version 1.1.0 “Shigeru”

Hello, and welcome to the release of Kiwi.js v1.1.0! I’m Ben Richards, part of the core engine development team here, and we thought we’d take the time to tell you why v1.1.0 is the best Kiwi.js yet.

This is the first in a series of Kiwi.js v1.1.0 posts, in which we’ll go into depth about new features and under-the-hood enhancements. If you don’t know what Kiwi.js is, now is a great time to find out at, and perhaps get involved with development yourself at!

Today we’ll be giving you an overview of v1.1.0, explaining what this version is for, and giving a taste of some new features. So without further ado, let’s see what’s up!

What’s the Plan?

Kiwi.js v1.1.0 is versioned as a “minor release”. Using semantic versioning, this means we are allowed to add new functions and perform bug fixes, but we can’t remove or change old functions. Your v1.0.1 Kiwi.js projects should continue to perform just as they did before – but maybe faster and with fewer bugs.

The purpose of this minor release is to make animation and WebGL graphics easier and more flexible. To that end, we’ve added several useful features, both user-facing and internally. The bit that gets me excited is our rebuilt WebGL rendering pipeline, which has just blown the doors off future possibilities.

With v1.1.0 complete, it’s possible to make a huge range of plugins to do amazing things. And we’ve got plans. Our main plan is to pioneer new features as plugins. It’s a good way to introduce these features, because it doesn’t impact core functionality, and it allows us to revise the API on those features after seeing them behave in the wild. If we like the feature, we can add it to core in a future minor release. Plus, once we put something in, we can’t take it out until the next major release – version 2.0.0. Semantic versioning requires a stable API (application programming interface) and backwards compatibility within major versions. With plugins, we can explore our options and only put it into core once we have an API that we like.

What sort of plugins? Oh, little things like advanced physics, lethal AI, multiplayer with all your friends, and real-time lighting like you’ve never seen before.

New Stuff

There’s so much interesting stuff in Kiwi.js v1.1.0 that we couldn’t possibly fit it all into one blog post. (Well, we could, but your brain would explode. And we respect your carpet far too much to let that happen.) So we’re splitting it up into a series of posts.

Your favourite part of this series will depend on what you’re doing with Kiwi.js. Some parts will be quite technical – maybe you’ll learn something, or better yet, you’ll find a place where we messed up. (And tell us. We like that part best.) Other parts will be more accessible, describing some cool ways to use new features.

Before we get into the new features, we’ll go over a series of little things that don’t merit an entire blog post on their own. After that, we’ll summarise upcoming articles. The series will alternate between technical and API topics. We have a lot to say on the technical side; we hope this will prove a useful resource to other WebGL developers, as well as showing you how best to interface with Kiwi.js if you’re into shaders and other advanced topics.

Let’s get started!

The Little Things

New Examples Repo

Kiwi.js has plenty of examples, showing all sorts of useful things. Too many, in fact! All that goodness was bloating the core Kiwi.js download on Github.

So we’ve moved the examples to a new repo. If you want to see Kiwi.js in action, grab that repo, fire up your localhost server (we suggest WAMP or MAMP), and see what Kiwi.js can do.

WebGL Default Renderer

Like it says, WebGL is now the default renderer. Blazing fast graphics are even easier than ever. The moment you create a game, it uses WebGL. Don’t worry if your browser doesn’t support WebGL; Kiwi.js will detect a problem and fall back to Canvas mode.

Kiwi.js now has the following renderer options, which you can use as values for “renderer” in a gameconfig object:

  • Kiwi.RENDERER_CANVAS (fallback renderer, guaranteed to work on any HTML5 browser)
  • Kiwi.RENDERER_WEBGL (default high-powered renderer with all the best features)
  • Kiwi.RENDERER_AUTO (autodetect WEBGL if it is present, CANVAS if not)

Camera Resets

When you swap States, all cameras in the game reset to default. (This means they set x,y = 0, rotation = 0, scale = 1, rotPointx,y = width/2,height/2.) This is important, because 99% of the time you’re using the default camera. If you move that camera and then swap States, you might find yourself looking at the wrong part of the new State.

This reset happens automatically. If you want to call it yourself, use either game.cameras.zeroCamera( camera ) or game.cameras.zeroAllCameras() (where game is your game object and game.cameras is a CameraManager object).

Alpha On Stage

It is now possible to make the game background transparent, allowing you to see the rest of the webpage behind it. This can be useful if you want to integrate Kiwi.js objects with the rest of your content, although you’ll probably need to do plenty of coding to pull it off.

To set a transparent background on the Game object game, call game.stage.color( "ffffff00" ) or game.stage.rgbaColor( {r: 255, g: 255, b: 255, a: 0} ).

To set the background opaque, call game.stage.color( "ffffffff" ), game.stage.color( "ffffff" ), game.stage.rgbaColor( {r: 255, g: 255, b: 255, a: 255} ), or game.stage.rgbColor( {r: 255, g: 255, b: 255} ).

Note that the game will assume a fully opaque alpha if you call rgbColor or set color to a six-digit hex value. Note also that using rgbaColor requires an alpha parameter in the range 0-255, not 0-1 as may be used in some color formats; this is to preserve internal consistency.

Thanks to user Viriatos for asking about alpha on stage.

Off-Axis Tile Maps

It is now possible to freely transform TileMapLayer objects. You may reposition, rotate, and scale them freely. This can be very useful for creating interesting backgrounds.

However, we haven’t yet managed to get physics to follow them. You should not use transformed tilemaps as interactive objects just yet. We’re working on advanced physics systems to overcome this problem. For now, explore the aesthetic possibilities.

Goodbye, willRender

Some objects had a willRender flag to control their visibility. This is deprecated in favour of the visible flag. Because we’re not putting out a major release, willRender still works – we simply advise users not to use it, and redirect calls to visible. This simplifies an unnecessary divergence of function.

That’s it for the small things. Now for the big stuff.

New WebGL Render Pipeline

We’ve reordered the WebGL rendering pipeline in the name of greater accessibility. We already had a super-fast batch renderer, which would combine objects with identical texture and renderer settings into a single draw call. But now each batch follows a series of steps:

  • Enable renderer. Here you can set shader uniforms.
  • Clear vertex buffers.
  • Call per-object renderGL() methods. Here you can run per-object graphics operations and define geometry.
  • Upload texture/s to graphics card.
  • Manage blend mode.
  • Draw to screen.

In the render pipeline article we’ll explain what we used to do, why we changed it, and how you can use this to make powerful game objects.

New Transform Aliases

After consulting the needs of game designers, we’ve come up with some new shortcuts which we think you’ll find most useful. Game objects now have a unified set of aliases to transform properties, and we’ve added some new functions and names to boot. Want to scale an object in both x and y at once? Does anchorPointX sound cooler than rotPointX? Just how incredibly useful are transforms anyway? All shall be revealed in this article.

New WebGL Texture Pipeline

When it comes down to it, all of Kiwi.js is a system for drawing textures onto the screen. Thus far we’ve given you tools to draw with one texture at a time. But what if you could draw data from multiple textures at once? What if you could combine data, make it do more than just replicate the same set of colors? This is the domain of WebGL shaders. And we’ve taken all the hard work out of setting up your WebGL environment to drive advanced shaders.

In this article we’ll examine the flow of textures through the render pipeline and explain how they are arranged on the video card.

New Tagging System and Object Selection

Add abstract tags to game objects! Label friends and foes, set moods, inform an enemy that they are now on fire – you can do all this and more without developing new classes and functions.

In this article we’ll talk about ways to identify and sort your game objects. We’ll also look at the scene graph, and explain how it orders your assets.

New WebGL Blend Mode System

Users of our Particle Effect Plugin have seen how cool additive blending can be. Inspired by this, we’ve put blend modes into the core engine. But that’s not all; we’ve given you more control over renderers, so you can set up shader groups, clone renderers, and generally make your game objects look exactly how you want them.

In this article we’ll talk about WebGL blend modes, what they can (and can’t) do, and how to manage your renderers the way you want.

New Time Properties

Kiwi.js is super fast, but we’re ultimately at the mercy of the browser. If your game starts to run slow, whether it’s because of a pop-up from another site or because you’ve implemented ray-traced 3D global illumination in your game (and good on you), you don’t want your game to go into slow motion. Or maybe you do want some slow motion! Whatever the case, we’ve got your back with a range of new time parameters.

In this article we’ll explain the consequences of frame rate, and how you can create a whole range of super smooth animations with our new time properties.

New WebGL Shader System

We’ve looked at the new render pipeline, the new texture pipeline, and the new blending system. These are pretty awesome on their own, but they’re a hundred times better when you use them to fulfill their destiny. From the beginning, these improvements were intended to support the creation of advanced new shaders.

In this article we’ll look at the process for creating new shaders, from beginning to end. How do you write a shader? How do you write a plugin renderer? How do you apply them to objects in game? All this shall be answered, and it will be max wicked.

Change Log

Check out the readme on Github for the complete change log!

Beyond v1.1.0

What’s next for Kiwi.js? Unfortunately, your security clearance isn’t high enough to know all the details. But we have a pretty good idea of where we’re going. There will probably be a v1.1.1 targeting implementation problems on the more specialised platforms, like CocoonJS. We’ll test a series of exciting new features using plugins. And me? I’m thinking about v2.0.0. Two words: Deferred Renderer.

See you next time, when we talk about the new WebGL render pipeline!

Benjamin D. Richards

Newsflash! Kiwi.js Version 1.0.1 has landed…

Thanks to all of the support and feedback from our community – we are pleased to announce version 1.0.1 of Kiwi.js. Numerous fixes and tweaks have been updated in this version to make Kiwi.js more stable and more robust, a lot of work has been going into and will continue to go into our WebGL implementation.

Bug Fixes and Changes

  • Thanks to @zzarcon the Grunt file now has more clarity.
  • @tjwudi has pushed up numerous fixes to the Documentation!
  • Bug fix where multiple debug canvases could be generated from subsequent ‘createDebugCanvas’ calls.
  • The debug canvas now responds to the “scaleType” property on the ‘Stage’.
  • Tilemap layers no longer return error messages about the cellIndex.
  • Groups now use correct rotation point, as does the Camera and the State.
  • Fixed a bug where the HUDIcon would not work with Textures use a Canvas.
  • Canvas renderer now behaves more like the WebGL renderer.
  • Fixed a WebGL bug where alphas between 0 and 1 made the page background color bleed through.
  • The WebGL renderer now clears every frame which solves the bug where nothing would appear.
  • Textures that are set to ‘dirty’ are now re-uploaded to video memory. This fixes other bugs, such as the Textfield not working in WebGL.
  • Upgraded Kiwi.js to use Typescript version 1.0.0.

Whats cooking? And how to contribute…

A couple of people have been asking how they can contribute to the Kiwi.js project. We’d love for you to get involved and help make Kiwi.js the best damn game framework in the world! If you’d like to contribute please get in touch, fork/clone the repo and have a dig around the code.

And for those wondering about the future… we have two words for you. Two-Player. If that excites you like it excites us then you’ll want to keep an eye out for upcoming announcements on our blog.  We can’t tell you more just yet… else we’d have to vaporise you.

Have fun and keep coming back!!


Star us on Github
Download Kiwi.js 1.0.1