diff --git a/.gitignore b/.gitignore
index a111d56475..999db3b894 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,3 +28,25 @@ Properties
 !_infrastructure/tests/*/*.js
 !_infrastructure/tests/*/*/*.js
 !_infrastructure/tests/*/*/*/*.js
+
+.idea/.name
+
+.idea/DefinitelyTyped.iml
+
+.idea/encodings.xml
+
+.idea/libraries/Generated_files.xml
+
+.idea/misc.xml
+
+.idea/modules.xml
+
+.idea/scopes/scope_settings.xml
+
+.idea/vcs.xml
+
+.idea/workspace.xml
+
+.idea/watcherTasks.xml
+
+.idea/watcherTasks.xml
diff --git a/README.md b/README.md
index 3f6874db82..497eff663c 100755
--- a/README.md
+++ b/README.md
@@ -152,6 +152,7 @@ List of Definitions
 * [Persona](http://www.mozilla.org/en-US/persona) (by [James Frasca](https://github.com/Nycto))
 * [PhantomJS](http://phantomjs.org) (by [Jed Hunsaker](https://github.com/jedhunsaker))
 * [PhoneGap](http://phonegap.com) (by [Boris Yankov](https://github.com/borisyankov))
+* [PixiJS](https://github.com/GoodBoyDigital/pixi.js) (by [Pedro Casaubon](https://github.com/xperiments))
 * [Platform](https://github.com/bestiejs/platform.js) (by [Jake Hickman](https://github.com/JakeH))
 * [PouchDB](http://pouchdb.com) (by [Bill Sears](https://github.com/MrBigDog2U/))
 * [PreloadJS](http://www.createjs.com/#!/PreloadJS) (by [Pedro Ferreira](https://bitbucket.org/drk4))
diff --git a/pixi/pixi-tests.ts b/pixi/pixi-tests.ts
new file mode 100644
index 0000000000..93ff79593a
--- /dev/null
+++ b/pixi/pixi-tests.ts
@@ -0,0 +1,1190 @@
+///<reference path="pixi.d.ts"/>
+///<reference path="webgl.d.ts"/>
+
+
+var stage = new PIXI.Stage(0xFFFFFF, true);
+
+stage.interactive = true;
+
+var bg = PIXI.Sprite.fromImage("BGrotate.jpg");
+bg.anchor.x = 0.5;
+bg.anchor.y = 0.5;
+
+bg.position.x = 620/2;
+bg.position.y = 380/2;
+
+stage.addChild(bg);
+
+var container = new PIXI.DisplayObjectContainer();
+container.position.x = 620/2;
+container.position.y = 380/2;
+
+var bgFront = PIXI.Sprite.fromImage("SceneRotate.jpg");
+bgFront.anchor.x = 0.5;
+bgFront.anchor.y = 0.5;
+
+container.addChild(bgFront);
+
+var light2 = PIXI.Sprite.fromImage("LightRotate2.png");
+light2.anchor.x = 0.5;
+light2.anchor.y = 0.5;
+container.addChild(light2);
+
+var light1 = PIXI.Sprite.fromImage("LightRotate1.png");
+light1.anchor.x = 0.5;
+light1.anchor.y = 0.5;
+container.addChild(light1);
+
+var panda =  PIXI.Sprite.fromImage("panda.png");
+panda.anchor.x = 0.5;
+panda.anchor.y = 0.5;
+
+container.addChild(panda);
+
+stage.addChild(container);
+
+// create a renderer instance
+var renderer = PIXI.autoDetectRenderer(620, 380);
+
+renderer.view.style.position = "absolute"
+renderer.view.style.marginLeft = "-310px";
+renderer.view.style.marginTop = "-190px";
+renderer.view.style.top = "50%";
+renderer.view.style.left = "50%";
+renderer.view.style.display = "block";
+
+// add render view to DOM
+document.body.appendChild(renderer.view);
+
+// lets create moving shape
+var thing = new PIXI.Graphics();
+stage.addChild(thing);
+thing.position.x = 620/2;
+thing.position.y = 380/2;
+thing.lineStyle(0);
+
+container.mask = thing;
+
+var count = 0;
+
+stage.click = stage.tap = function()
+{
+	if(!container.filter)
+	{
+		container.mask = thing;
+		PIXI.runList(stage);
+	}
+	else
+	{
+		container.mask = null;
+	}
+}
+
+/*
+ * Add a pixi Logo!
+ */
+var logo = PIXI.Sprite.fromImage("../../logo_small.png")
+stage.addChild(logo);
+
+logo.anchor.x = 1;
+logo.position.x = 620
+logo.scale.x = logo.scale.y = 0.5;
+logo.position.y = 320
+logo.interactive = true;
+logo.buttonMode = true;
+
+logo.click = logo.tap = function()
+{
+	window.open("https://github.com/GoodBoyDigital/pixi.js", "_blank")
+}
+
+var help = new PIXI.Text("Click to turn masking on / off.", {font:"bold 12pt Arial", fill:"white"});
+help.position.y = 350;
+help.position.x = 10;
+stage.addChild(help);
+
+requestAnimFrame(animate);
+
+function animate() {
+
+	bg.rotation += 0.01;
+	bgFront.rotation -= 0.01;
+
+	light1.rotation += 0.02;
+	light2.rotation += 0.01;
+
+	panda.scale.x = 1 + Math.sin(count) * 0.04;
+	panda.scale.y = 1 + Math.cos(count) * 0.04;
+
+	count += 0.1;
+
+	thing.clear();
+	thing.lineStyle(5, 0x16f1ff, 1);
+	thing.beginFill(0x8bc5ff, 0.4);
+	thing.moveTo(-120 + Math.sin(count) * 20, -100 + Math.cos(count)* 20);
+	thing.lineTo(120 + Math.cos(count) * 20, -100 + Math.sin(count)* 20);
+	thing.lineTo(120 + Math.sin(count) * 20, 100 + Math.cos(count)* 20);
+	thing.lineTo(-120 + Math.cos(count)* 20, 100 + Math.sin(count)* 20);
+	thing.lineTo(-120 + Math.sin(count) * 20, -100 + Math.cos(count)* 20);
+	thing.rotation = count * 0.1;
+
+	renderer.render(stage);
+	requestAnimFrame( animate );
+}
+
+/* 13 */
+
+// create an new instance of a pixi stage
+var stage = new PIXI.Stage(0xFFFFFF, true);
+
+stage.setInteractive(true);
+
+var sprite=  PIXI.Sprite.fromImage("spinObj_02.png");
+//stage.addChild(sprite);
+// create a renderer instance
+// the 5the parameter is the anti aliasing
+var renderer = PIXI.autoDetectRenderer(620, 380, null, false, true);
+
+// set the canvas width and height to fill the screen
+//renderer.view.style.width = window.innerWidth + "px";
+//renderer.view.style.height = window.innerHeight + "px";
+renderer.view.style.display = "block";
+
+// add render view to DOM
+document.body.appendChild(renderer.view);
+
+var graphics = new PIXI.Graphics();
+
+
+// set a fill and line style
+graphics.beginFill(0xFF3300);
+graphics.lineStyle(10, 0xffd900, 1);
+
+// draw a shape
+graphics.moveTo(50,50);
+graphics.lineTo(250, 50);
+graphics.lineTo(100, 100);
+graphics.lineTo(250, 220);
+graphics.lineTo(50, 220);
+graphics.lineTo(50, 50);
+graphics.endFill();
+
+// set a fill and line style again
+graphics.lineStyle(10, 0xFF0000, 0.8);
+graphics.beginFill(0xFF700B, 1);
+
+// draw a second shape
+graphics.moveTo(210,300);
+graphics.lineTo(450,320);
+graphics.lineTo(570,350);
+graphics.lineTo(580,20);
+graphics.lineTo(330,120);
+graphics.lineTo(410,200);
+graphics.lineTo(210,300);
+graphics.endFill();
+
+// draw a rectangel
+graphics.lineStyle(2, 0x0000FF, 1);
+graphics.drawRect(50, 250, 100, 100);
+
+// draw a circle
+graphics.lineStyle(0);
+graphics.beginFill(0xFFFF0B, 0.5);
+graphics.drawCircle(470, 200,100);
+
+graphics.lineStyle(20, 0x33FF00);
+graphics.moveTo(30,30);
+graphics.lineTo(600, 300);
+
+
+stage.addChild(graphics);
+
+// lets create moving shape
+var thing = new PIXI.Graphics();
+stage.addChild(thing);
+thing.position.x = 620/2;
+thing.position.y = 380/2;
+
+var count = 0;
+
+stage.click = stage.tap = function()
+{
+	graphics.lineStyle(Math.random() * 30, Math.random() * 0xFFFFFF, 1);
+	graphics.moveTo(Math.random() * 620,Math.random() * 380);
+	graphics.lineTo(Math.random() * 620,Math.random() * 380);
+}
+
+requestAnimFrame(animate);
+
+function animate1() {
+
+	thing.clear();
+
+	count += 0.1;
+
+	thing.clear();
+	thing.lineStyle(30, 0xff0000, 1);
+	thing.beginFill(0xffFF00, 0.5);
+
+	thing.moveTo(-120 + Math.sin(count) * 20, -100 + Math.cos(count)* 20);
+	thing.lineTo(120 + Math.cos(count) * 20, -100 + Math.sin(count)* 20);
+	thing.lineTo(120 + Math.sin(count) * 20, 100 + Math.cos(count)* 20);
+	thing.lineTo(-120 + Math.cos(count)* 20, 100 + Math.sin(count)* 20);
+	thing.lineTo(-120 + Math.sin(count) * 20, -100 + Math.cos(count)* 20);
+
+	thing.rotation = count * 0.1;
+	renderer.render(stage);
+	requestAnimFrame( animate );
+}
+
+
+// create an new instance of a pixi stage
+var stage = new PIXI.Stage(0x000000);
+
+// create a renderer instance
+var renderer = PIXI.autoDetectRenderer(800, 600);
+
+// set the canvas width and height to fill the screen
+renderer.view.style.width = window.innerWidth + "px";
+renderer.view.style.height = window.innerHeight + "px";
+renderer.view.style.display = "block";
+
+// add render view to DOM
+document.body.appendChild(renderer.view);
+
+// OOH! SHINY!
+// create two render textures.. these dynamic textures will be used to draw the scene into itself
+var renderTexture = new PIXI.RenderTexture(800, 600);
+var renderTexture2 = new PIXI.RenderTexture(800, 600);
+var currentTexture = renderTexture;
+
+// create a new sprite that uses the render texture we created above
+var outputSprite = new PIXI.Sprite(currentTexture);
+
+// align the sprite
+outputSprite.position.x = 800/2;
+outputSprite.position.y = 600/2;
+outputSprite.anchor.x = 0.5;
+outputSprite.anchor.y = 0.5;
+
+// add to stage
+stage.addChild(outputSprite);
+
+var stuffContainer = new PIXI.DisplayObjectContainer();
+
+stuffContainer.position.x = 800/2;
+stuffContainer.position.y = 600/2
+
+stage.addChild(stuffContainer);
+
+// create an array of image ids..
+var fruits = ["spinObj_01.png", "spinObj_02.png",
+	"spinObj_03.png", "spinObj_04.png",
+	"spinObj_05.png", "spinObj_06.png",
+	"spinObj_07.png", "spinObj_08.png"];
+
+// create an array of items
+var items = [];
+
+// now create some items and randomly position them in the stuff container
+for (var i=0; i < 20; i++)
+{
+	var item = PIXI.Sprite.fromImage(fruits[i % fruits.length]);
+	item.position.x = Math.random() * 400 - 200;
+	item.position.y = Math.random() * 400 - 200;
+
+	item.anchor.x = 0.5;
+	item.anchor.y = 0.5;
+
+	stuffContainer.addChild(item);
+	console.log("_")
+	items.push(item);
+};
+
+// used for spinning!
+var count = 0;
+
+
+requestAnimFrame(animate);
+
+function animate2() {
+
+	requestAnimFrame( animate );
+
+	for (var i=0; i < items.length; i++)
+	{
+		// rotate each item
+		var item = items[i];
+		item.rotation += 0.1;
+	};
+
+	count += 0.01;
+
+	// swap the buffers..
+	var temp = renderTexture;
+	renderTexture = renderTexture2;
+	renderTexture2 = temp;
+
+
+	// set the new texture
+	outputSprite.setTexture(renderTexture);
+
+	// twist this up!
+	stuffContainer.rotation -= 0.01
+	outputSprite.scale.x = outputSprite.scale.y  = 1 + Math.sin(count) * 0.2;
+
+	// render the stage to the texture
+	// the true clears the texture before content is rendered
+	renderTexture2.render(stage, new PIXI.Point(0,0), true);
+
+	// and finally render the stage
+	renderer.render(stage);
+}
+
+
+////
+
+
+
+function init()
+{
+	var assetsToLoader = ["desyrel.fnt"];
+
+	// create a new loader
+	var loader = new PIXI.AssetLoader(assetsToLoader);
+
+	// use callback
+	loader.onComplete = onAssetsLoaded;
+
+	//begin load
+
+	// create an new instance of a pixi stage
+	var stage = new PIXI.Stage(0x66FF99);
+
+	loader.load();
+	function onAssetsLoaded()
+	{
+		var bitmapFontText = new PIXI.BitmapText("bitmap fonts are\n now supported!", {font: "35px Desyrel", align: "right"});
+		bitmapFontText.position.x = 620 - bitmapFontText.width - 20;
+		bitmapFontText.position.y = 20;
+
+		PIXI.runList(bitmapFontText)
+		stage.addChild(bitmapFontText);
+
+
+	}
+
+
+
+	// add a shiney background..
+	var background = PIXI.Sprite.fromImage("textDemoBG.jpg");
+	stage.addChild(background);
+
+	// create a renderer instance
+	var renderer = PIXI.autoDetectRenderer(620, 400);
+	// add the renderer view element to the DOM
+	document.body.appendChild(renderer.view);
+
+	requestAnimFrame(animate);
+
+	// create some white text using the Snippet webfont
+	var textSample = new PIXI.Text("Pixi.js can has\nmultiline text!", {font: "35px Snippet", fill: "white", align: "left"});
+	textSample.position.x = 20;
+	textSample.position.y = 20;
+
+	// create a text object with a nice stroke
+	var spinningText = new PIXI.Text("I'm fun!", {font: "bold 60px Podkova", fill: "#cc00ff", align: "center", stroke: "#FFFFFF", strokeThickness: 6});
+	// setting the anchor point to 0.5 will center align the text... great for spinning!
+	spinningText.anchor.x = spinningText.anchor.y = 0.5;
+	spinningText.position.x = 620 / 2;
+	spinningText.position.y = 400 / 2;
+
+	// create a text object that will be updated..
+	var countingText = new PIXI.Text("COUNT 4EVAR: 0", {font: "bold italic 60px Arvo", fill: "#3e1707", align: "center", stroke: "#a4410e", strokeThickness: 7});
+	countingText.position.x = 620 / 2;
+	countingText.position.y = 320;
+	countingText.anchor.x = 0.5;
+
+	stage.addChild(textSample);
+	stage.addChild(spinningText);
+	stage.addChild(countingText);
+
+	var count = 0;
+	var score = 0;
+
+	function animate() {
+
+		requestAnimFrame( animate );
+		count++;
+		if(count == 50)
+		{
+			count = 0;
+			score++;
+			// update the text...
+			countingText.setText("COUNT 4EVAR: " + score);
+
+		}
+		// just for fun, lets rotate the text
+		spinningText.rotation += 0.03;
+
+		// render the stage
+		renderer.render(stage);
+	}
+}
+
+
+/////
+
+
+
+// create an new instance of a pixi stage
+var stage = new PIXI.Stage(0x97c56e, true);
+
+// create a renderer instance
+var renderer = PIXI.autoDetectRenderer(window.innerWidth, window.innerHeight, null);
+
+// add the renderer view element to the DOM
+document.body.appendChild(renderer.view);
+renderer.view.style.position = "absolute";
+renderer.view.style.top = "0px";
+renderer.view.style.left = "0px";
+requestAnimFrame( animate );
+
+// create a texture from an image path
+var texture = PIXI.Texture.fromImage("p2.jpeg");
+
+// create a tiling sprite..
+// requires a texture, width and height
+// to work in webGL the texture size must be a power of two
+var tilingSprite = new PIXI.TilingSprite(texture, window.innerWidth, window.innerHeight)
+
+var count = 0;
+
+stage.addChild(tilingSprite);
+
+function animate33() {
+
+	requestAnimFrame( animate );
+
+
+	count += 0.005
+	tilingSprite.tileScale.x = 2 + Math.sin(count);
+	tilingSprite.tileScale.y = 2 + Math.cos(count);
+
+	tilingSprite.tilePosition.x += 1;
+	tilingSprite.tilePosition.y += 1;
+
+	// just for fun, lets rotate mr rabbit a little
+	//stage.interactionManager.update();
+	// render the stage
+	renderer.render(stage);
+}
+
+
+
+/////
+
+
+// create an new instance of a pixi stage
+var stage = new PIXI.Stage(0x97c56e, true);
+
+// create a renderer instance
+var renderer = PIXI.autoDetectRenderer(window.innerWidth, window.innerHeight, null);
+
+// add the renderer view element to the DOM
+document.body.appendChild(renderer.view);
+renderer.view.style.position = "absolute";
+renderer.view.style.top = "0px";
+renderer.view.style.left = "0px";
+requestAnimFrame( animate );
+
+// create a texture from an image path
+var texture = PIXI.Texture.fromImage("bunny.png");
+
+for (var i=0; i < 10; i++)
+{
+	createBunny(Math.random() * window.innerWidth, Math.random() * window.innerHeight)
+};
+
+
+function createBunny(x, y)
+{
+	// create our little bunny friend..
+	var bunny = new PIXI.Sprite(texture);
+	//	bunny.width = 300;
+	// enable the bunny to be interactive.. this will allow it to respond to mouse and touch events
+	bunny.interactive = true;
+	// this button mode will mean the hand cursor appears when you rollover the bunny with your mouse
+	bunny.buttonMode = true;
+
+	// center the bunnys anchor point
+	bunny.anchor.x = 0.5;
+	bunny.anchor.y = 0.5;
+	// make it a bit bigger, so its easier to touch
+	bunny.scale.x = bunny.scale.y = 3;
+
+
+	// use the mousedown and touchstart
+	bunny.mousedown = bunny.touchstart = function(data)
+	{
+		// stop the default event...
+		data.originalEvent.preventDefault();
+
+		// store a refference to the data
+		// The reason for this is because of multitouch
+		// we want to track the movement of this particular touch
+		this.data = data;
+		this.alpha = 0.9;
+		this.dragging = true;
+	};
+
+	// set the events for when the mouse is released or a touch is released
+	bunny.mouseup = bunny.mouseupoutside = bunny.touchend = bunny.touchendoutside = function(data)
+	{
+		this.alpha = 1
+		this.dragging = false;
+		// set the interaction data to null
+		this.data = null;
+	};
+
+	// set the callbacks for when the mouse or a touch moves
+	bunny.mousemove = bunny.touchmove = function(data)
+	{
+		if(this.dragging)
+		{
+			// need to get parent coords..
+			var newPosition = this.data.getLocalPosition(this.parent);
+			this.position.x = newPosition.x;
+			this.position.y = newPosition.y;
+		}
+	}
+
+	// move the sprite to its designated position
+	bunny.position.x = x;
+	bunny.position.y = y;
+
+	// add it to the stage
+	stage.addChild(bunny);
+}
+
+function animate44() {
+
+	requestAnimFrame( animate );
+
+	// just for fun, lets rotate mr rabbit a little
+	//stage.interactionManager.update();
+	// render the stage
+	renderer.render(stage);
+}
+
+
+
+////
+
+// create an new instance of a pixi stage
+var stage = new PIXI.Stage(0x66FF99);
+
+// create a renderer instance
+var renderer = PIXI.autoDetectRenderer(400, 300, null, true);
+
+// add the renderer view element to the DOM
+document.body.appendChild(renderer.view);
+renderer.view.style.position = "absolute";
+renderer.view.style.top = "0px";
+renderer.view.style.left = "0px";
+requestAnimFrame( animate );
+
+// create a texture from an image path
+var texture = PIXI.Texture.fromImage("bunny.png");
+// create a new Sprite using the texture
+var bunny = new PIXI.Sprite(texture);
+
+// center the sprites anchor point
+bunny.anchor.x = 0.5;
+bunny.anchor.y = 0.5;
+
+// move the sprite t the center of the screen
+bunny.position.x = 200;
+bunny.position.y = 150;
+
+stage.addChild(bunny);
+
+function animate55() {
+
+	requestAnimFrame( animate );
+
+	// just for fun, lets rotate mr rabbit a little
+	bunny.rotation += 0.1;
+
+	// render the stage
+	renderer.render(stage);
+}
+
+
+
+///////
+
+
+
+// create an new instance of a pixi stage
+// the second parameter is interactivity...
+var interactive = true;
+var stage = new PIXI.Stage(0x000000, interactive);
+
+// create a renderer instance.
+var renderer = PIXI.autoDetectRenderer(620, 400);
+
+// add the renderer view element to the DOM
+document.body.appendChild(renderer.view);
+
+requestAnimFrame( animate );
+
+// create a background..
+var background = PIXI.Sprite.fromImage("button_test_BG.jpg");
+
+// add background to stage..
+stage.addChild(background);
+
+// create some textures from an image path
+var textureButton = PIXI.Texture.fromImage("button.png");
+var textureButtonDown = PIXI.Texture.fromImage("buttonDown.png");
+var textureButtonOver = PIXI.Texture.fromImage("buttonOver.png");
+
+var buttons = [];
+
+var buttonPositions = [175,75,
+	600-145, 75,
+	600/2 - 20, 400/2 + 10,
+	175, 400-75,
+	600-115, 400-95];
+
+
+for (var i=0; i < 5; i++)
+{
+	var button = new PIXI.Sprite(textureButton);
+	button.buttonMode = true;
+
+	button.anchor.x = 0.5;
+	button.anchor.y = 0.5;
+
+	button.position.x = buttonPositions[i*2];
+	button.position.y = buttonPositions[i*2 + 1];
+
+	// make the button interactive..
+	button.interactive = true;
+
+	// set the mousedown and touchstart callback..
+	button.mousedown = button.touchstart = function(data){
+
+		this.isdown = true;
+		this.setTexture(textureButtonDown);
+		this.alpha = 1;
+	}
+
+	// set the mouseup and touchend callback..
+	button.mouseup = button.touchend = button.mouseupoutside = button.touchendoutside = function(data){
+		this.isdown = false;
+
+		if(this.isOver)
+		{
+			this.setTexture(textureButtonOver);
+		}
+		else
+		{
+			this.setTexture(textureButton);
+		}
+	}
+
+	// set the mouseover callback..
+	button.mouseover = function(data){
+
+		this.isOver = true;
+
+		if(this.isdown)return
+
+		this.setTexture(textureButtonOver)
+	}
+
+	// set the mouseout callback..
+	button.mouseout = function(data){
+
+		this.isOver = false;
+		if(this.isdown)return
+		this.setTexture(textureButton)
+	}
+
+	button.click = function(data){
+		// click!
+		console.log("CLICK!");
+		//	alert("CLICK!")
+	}
+
+	button.tap = function(data){
+		// click!
+		console.log("TAP!!");
+		//this.alpha = 0.5;
+	}
+
+	// add it to the stage
+	stage.addChild(button);
+
+	// add button to array
+	buttons.push(button);
+};
+
+// set some silly values..
+
+buttons[0].scale.x = 1.2;
+
+buttons[1].scale.y = 1.2;
+
+buttons[2].rotation = Math.PI/10;
+
+buttons[3].scale.x = 0.8;
+buttons[3].scale.y = 0.8;
+
+buttons[4].scale.x = 0.8;
+buttons[4].scale.y = 1.2;
+buttons[4].rotation = Math.PI;
+// var button1 =
+function animate66() {
+
+	requestAnimFrame( animate );
+	// render the stage
+
+	// do a test..
+
+	renderer.render(stage);
+}
+
+// add a logo!
+var pixiLogo = PIXI.Sprite.fromImage("pixi.png");
+stage.addChild(pixiLogo);
+
+pixiLogo.position.x = 620 - 56;
+pixiLogo.position.y = 400- 32;
+
+pixiLogo.setInteractive(true);
+
+pixiLogo.click = pixiLogo.tap = function(){
+
+	var win=window.open("https://github.com/GoodBoyDigital/pixi.js", '_blank');
+
+}
+
+
+//////
+
+
+
+var w = 1024;
+var h = 768;
+
+var n = 2000;
+var d = 1;
+var current = 1;
+var objs = 17;
+var vx = 0;
+var vy = 0;
+var vz = 0;
+var points1 = [];
+var points2 = [];
+var points3 = [];
+var tpoint1 = [];
+var tpoint2 = [];
+var tpoint3 = [];
+var balls = [];
+
+function start() {
+
+	var ballTexture = PIXI.Texture.fromImage("assets/pixel.png");
+
+	renderer = PIXI.autoDetectRenderer(w, h);
+
+	stage = new PIXI.Stage(0x000000);
+
+	document.body.appendChild(renderer.view);
+
+	makeObject(0);
+
+	for (var i = 0; i < n; i++)
+	{
+		tpoint1[i] = points1[i];
+		tpoint2[i] = points2[i];
+		tpoint3[i] = points3[i];
+
+		var tempBall = new PIXI.Sprite(ballTexture);
+		tempBall.anchor.x = 0.5;
+		tempBall.anchor.y = 0.5;
+		tempBall.alpha = 0.5;
+		balls[i] = tempBall;
+
+		stage.addChild(tempBall);
+	}
+
+
+
+	setTimeout(nextObject, 5000);
+
+	requestAnimFrame(update);
+
+}
+
+function nextObject () {
+
+	current++;
+
+	if (current > objs)
+	{
+		current = 0;
+	}
+
+	makeObject(current);
+
+	setTimeout(nextObject, 8000);
+
+}
+
+function makeObject ( t ) {
+
+	var xd;
+
+	switch (t)
+	{
+		case 0:
+
+			for (var i = 0; i < n; i++)
+			{
+				points1[i] = -50 + Math.round(Math.random() * 100);
+				points2[i] = 0;
+				points3[i] = 0;
+			}
+			break;
+
+		case 1:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(xd) * 10) * (Math.cos(t * 360 / n) * 10);
+				points2[i] = (Math.cos(xd) * 10) * (Math.sin(t * 360 / n) * 10);
+				points3[i] = Math.sin(xd) * 100;
+			}
+			break;
+
+		case 2:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(xd) * 10) * (Math.cos(t * 360 / n) * 10);
+				points2[i] = (Math.cos(xd) * 10) * (Math.sin(t * 360 / n) * 10);
+				points3[i] = Math.sin(i * 360 / n) * 100;
+			}
+			break;
+
+		case 3:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(xd) * 10) * (Math.cos(xd) * 10);
+				points2[i] = (Math.cos(xd) * 10) * (Math.sin(xd) * 10);
+				points3[i] = Math.sin(xd) * 100;
+			}
+			break;
+
+		case 4:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(xd) * 10) * (Math.cos(xd) * 10);
+				points2[i] = (Math.cos(xd) * 10) * (Math.sin(xd) * 10);
+				points3[i] = Math.sin(i * 360 / n) * 100;
+			}
+			break;
+
+		case 5:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(xd) * 10) * (Math.cos(xd) * 10);
+				points2[i] = (Math.cos(i * 360 / n) * 10) * (Math.sin(xd) * 10);
+				points3[i] = Math.sin(i * 360 / n) * 100;
+			}
+			break;
+
+		case 6:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(i * 360 / n) * 10) * (Math.cos(i * 360 / n) * 10);
+				points2[i] = (Math.cos(i * 360 / n) * 10) * (Math.sin(xd) * 10);
+				points3[i] = Math.sin(i * 360 / n) * 100;
+			}
+			break;
+
+		case 7:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(i * 360 / n) * 10) * (Math.cos(i * 360 / n) * 10);
+				points2[i] = (Math.cos(i * 360 / n) * 10) * (Math.sin(i * 360 / n) * 10);
+				points3[i] = Math.sin(i * 360 / n) * 100;
+			}
+			break;
+
+		case 8:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(xd) * 10) * (Math.cos(i * 360 / n) * 10);
+				points2[i] = (Math.cos(i * 360 / n) * 10) * (Math.sin(i * 360 / n) * 10);
+				points3[i] = Math.sin(xd) * 100;
+			}
+			break;
+
+		case 9:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(xd) * 10) * (Math.cos(i * 360 / n) * 10);
+				points2[i] = (Math.cos(i * 360 / n) * 10) * (Math.sin(xd) * 10);
+				points3[i] = Math.sin(xd) * 100;
+			}
+			break;
+
+		case 10:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(i * 360 / n) * 10) * (Math.cos(i * 360 / n) * 10);
+				points2[i] = (Math.cos(xd) * 10) * (Math.sin(xd) * 10);
+				points3[i] = Math.sin(i * 360 / n) * 100;
+			}
+			break;
+
+		case 11:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(xd) * 10) * (Math.cos(i * 360 / n) * 10);
+				points2[i] = (Math.sin(xd) * 10) * (Math.sin(i * 360 / n) * 10);
+				points3[i] = Math.sin(xd) * 100;
+			}
+			break;
+
+		case 12:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(xd) * 10) * (Math.cos(xd) * 10);
+				points2[i] = (Math.sin(xd) * 10) * (Math.sin(xd) * 10);
+				points3[i] = Math.sin(i * 360 / n) * 100;
+			}
+			break;
+
+		case 13:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(xd) * 10) * (Math.cos(i * 360 / n) * 10);
+				points2[i] = (Math.sin(i * 360 / n) * 10) * (Math.sin(xd) * 10);
+				points3[i] = Math.sin(i * 360 / n) * 100;
+			}
+			break;
+
+		case 14:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.sin(xd) * 10) * (Math.cos(xd) * 10);
+				points2[i] = (Math.sin(xd) * 10) * (Math.sin(i * 360 / n) * 10);
+				points3[i] = Math.sin(i * 360 / n) * 100;
+			}
+			break;
+
+		case 15:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(i * 360 / n) * 10) * (Math.cos(i * 360 / n) * 10);
+				points2[i] = (Math.sin(i * 360 / n) * 10) * (Math.sin(xd) * 10);
+				points3[i] = Math.sin(i * 360 / n) * 100;
+			}
+			break;
+
+		case 16:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(xd) * 10) * (Math.cos(i * 360 / n) * 10);
+				points2[i] = (Math.sin(i * 360 / n) * 10) * (Math.sin(xd) * 10);
+				points3[i] = Math.sin(xd) * 100;
+			}
+			break;
+
+		case 17:
+
+			for (var i = 0; i < n; i++)
+			{
+				xd = -90 + Math.round(Math.random() * 180);
+				points1[i] = (Math.cos(xd) * 10) * (Math.cos(xd) * 10);
+				points2[i] = (Math.cos(i * 360 / n) * 10) * (Math.sin(i * 360 / n) * 10);
+				points3[i] = Math.sin(i * 360 / n) * 100;
+			}
+			break;
+	}
+
+}
+
+
+
+function update()
+{
+	var x3d, y3d, z3d, tx, ty, tz, ox;
+
+	if (d < 250)
+	{
+		d++;
+	}
+
+	vx += 0.0075;
+	vy += 0.0075;
+	vz += 0.0075;
+
+	for (var i = 0; i < n; i++)
+	{
+		if (points1[i] > tpoint1[i]) { tpoint1[i] = tpoint1[i] + 1; }
+		if (points1[i] < tpoint1[i]) { tpoint1[i] = tpoint1[i] - 1; }
+		if (points2[i] > tpoint2[i]) { tpoint2[i] = tpoint2[i] + 1; }
+		if (points2[i] < tpoint2[i]) { tpoint2[i] = tpoint2[i] - 1; }
+		if (points3[i] > tpoint3[i]) { tpoint3[i] = tpoint3[i] + 1; }
+		if (points3[i] < tpoint3[i]) { tpoint3[i] = tpoint3[i] - 1; }
+
+		x3d = tpoint1[i];
+		y3d = tpoint2[i];
+		z3d = tpoint3[i];
+
+		ty = (y3d * Math.cos(vx)) - (z3d * Math.sin(vx));
+		tz = (y3d * Math.sin(vx)) + (z3d * Math.cos(vx));
+		tx = (x3d * Math.cos(vy)) - (tz * Math.sin(vy));
+		tz = (x3d * Math.sin(vy)) + (tz * Math.cos(vy));
+		ox = tx;
+		tx = (tx * Math.cos(vz)) - (ty * Math.sin(vz));
+		ty = (ox * Math.sin(vz)) + (ty * Math.cos(vz));
+
+		balls[i].position.x = (512 * tx) / (d - tz) + w / 2;
+		balls[i].position.y = (h/2) - (512 * ty) / (d - tz);
+
+	}
+
+	renderer.render(stage);
+
+	requestAnimFrame(update);
+}
+
+
+
+///////
+
+
+
+//	Globals, globals everywhere and not a drop to drink
+var w = 1024;
+var h = 768;
+var starCount = 2500;
+var sx = 1.0 + (Math.random() / 20);
+var sy = 1.0 + (Math.random() / 20);
+var slideX = w / 2;
+var slideY = h / 2;
+var stars = [];
+
+function start2() {
+
+	var ballTexture = PIXI.Texture.fromImage("assets/bubble_32x32.png");
+
+	renderer = PIXI.autoDetectRenderer(w, h);
+
+	stage = new PIXI.Stage(0x000000);
+
+	document.body.appendChild(renderer.view);
+
+	for (var i = 0; i < starCount; i++)
+	{
+		var tempBall = new PIXI.Sprite(ballTexture);
+
+		tempBall.position.x = (Math.random() * w) - slideX;
+		tempBall.position.y = (Math.random() * h) - slideY;
+		tempBall.anchor.x = 0.5;
+		tempBall.anchor.y = 0.5;
+
+		stars.push({ sprite: tempBall, x: tempBall.position.x, y: tempBall.position.y });
+
+		stage.addChild(tempBall);
+	}
+
+	document.getElementById('rnd').onclick = newWave;
+	document.getElementById('sx').innerHTML = 'SX: ' + sx + '<br />SY: ' + sy;
+
+
+
+	requestAnimFrame(update);
+
+}
+
+function newWave () {
+
+	sx = 1.0 + (Math.random() / 20);
+	sy = 1.0 + (Math.random() / 20);
+	document.getElementById('sx').innerHTML = 'SX: ' + sx + '<br />SY: ' + sy;
+
+}
+
+
+
+function update22()
+{
+	for (var i = 0; i < starCount; i++)
+	{
+		stars[i].sprite.position.x = stars[i].x + slideX;
+		stars[i].sprite.position.y = stars[i].y + slideY;
+		stars[i].x = stars[i].x * sx;
+		stars[i].y = stars[i].y * sy;
+
+		if (stars[i].x > w)
+		{
+			stars[i].x = stars[i].x - w;
+		}
+		else if (stars[i].x < -w)
+		{
+			stars[i].x = stars[i].x + w;
+		}
+
+		if (stars[i].y > h)
+		{
+			stars[i].y = stars[i].y - h;
+		}
+		else if (stars[i].y < -h)
+		{
+			stars[i].y = stars[i].y + h;
+		}
+	}
+
+	renderer.render(stage);
+
+	requestAnimFrame(update);
+}
diff --git a/pixi/pixi.d.ts b/pixi/pixi.d.ts
new file mode 100644
index 0000000000..d5daba9481
--- /dev/null
+++ b/pixi/pixi.d.ts
@@ -0,0 +1,447 @@
+// Type definitions for PIXI 1.3
+// Project: https://github.com/GoodBoyDigital/pixi.js/
+// Definitions by: xperiments <http://github.com/xperiments>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path="webgl.d.ts"/>
+declare module PIXI
+{
+
+	/* STATICS */
+	export var gl:WebGLRenderingContext;
+	export var BaseTextureCache: {};
+	export var texturesToUpdate: BaseTexture[];
+	export var texturesToDestroy: BaseTexture[];
+	export var TextureCache: {};
+	export var FrameCache: {};
+	export var blendModes:{ NORMAL:number; SCREEN:number; };
+
+
+	/* MODULE FUNCTIONS */
+	export function autoDetectRenderer(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean, antialias?: boolean): IPixiRenderer;
+	export function FilterBlock( mask:Graphics ):void;
+	export function MaskFilter( graphics:Graphics ):void;
+
+
+	/* DEBUG METHODS */
+
+	export function runList( x ):void;
+
+		/*INTERFACES*/
+
+	export interface IBasicCallback
+	{
+		():void
+	}
+
+	export interface IEvent
+	{
+		type: string;
+		content: any;
+	}
+
+	export interface IHitArea
+	{
+		contains(x: number, y: number):boolean;
+	}
+
+	export interface IInteractionDataCallback
+	{
+		(interactionData: InteractionData):void
+	}
+
+	export interface IPixiRenderer
+	{
+		view: HTMLCanvasElement;
+		render(stage: Stage): void;
+	}
+
+	export interface IBitmapTextStyle
+	{
+		font?: string;
+		align?: string;
+	}
+
+	export interface ITextStyle
+	{
+		font?: string;
+		stroke?: string;
+		fill?: string;
+		align?: string;
+		strokeThickness?: number;
+		wordWrap?: boolean;
+		wordWrapWidth?:number;
+	}
+
+
+
+	/* CLASES */
+
+	export class AssetLoader extends EventTarget
+	{
+		assetURLs: string[];
+		onComplete: IBasicCallback;
+		onProgress: IBasicCallback;
+		constructor(assetURLs: string[], crossorigin?:boolean );
+		load(): void;
+	}
+
+	export class BaseTexture extends EventTarget
+	{
+		height: number;
+		width: number;
+		source: string;
+
+		constructor(source: HTMLImageElement);
+		constructor(source: HTMLCanvasElement);
+		destroy():void;
+
+		static fromImage(imageUrl: string, crossorigin?:boolean ): BaseTexture;
+	}
+
+	export class BitmapFontLoader extends EventTarget
+	{
+		baseUrl:string;
+		crossorigin:boolean;
+		texture:Texture;
+		url:string;
+		constructor(url: string, crossorigin?: boolean);
+		load():void;
+	}
+
+	export class BitmapText extends DisplayObjectContainer
+	{
+		width:number;
+		height:number;
+		constructor(text: string, style: IBitmapTextStyle);
+		setStyle(style: IBitmapTextStyle): void;
+		setText(text: string): void;
+	}
+
+	export class CanvasRenderer implements IPixiRenderer
+	{
+		context: CanvasRenderingContext2D;
+		height: number;
+		view: HTMLCanvasElement;
+		width: number;
+		constructor(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean);
+		render(stage: Stage): void;
+		resize(width: number, height: number):void;
+	}
+
+	export class Circle implements IHitArea
+	{
+		x: number;
+		y: number;
+		radius: number;
+		constructor(x: number, y: number, radius: number);
+		clone(): Circle;
+		contains(x: number, y: number):boolean;
+	}
+
+	// TODO what is renderGroup
+	export class CustomRenderable extends DisplayObject
+	{
+		constructor();
+		renderCanvas(renderer: CanvasRenderer): void;
+		initWebGL(renderer: WebGLRenderer): void;
+		renderWebGL(renderGroup: any, projectionMatrix: any): void;
+	}
+
+	export class DisplayObject
+	{
+		alpha: number;
+		buttonMode: boolean;
+		filter:boolean;
+		hitArea: IHitArea;
+		parent: DisplayObjectContainer;
+		pivot: Point;
+		position: Point;
+		rotation: number;
+		renderable: boolean;
+		scale: Point;
+		stage: Stage;
+		visible: boolean;
+		worldAlpha: number;
+		constructor();
+		static autoDetectRenderer(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean): IPixiRenderer;
+		click: IInteractionDataCallback;
+		mousedown: IInteractionDataCallback;
+		mouseout: IInteractionDataCallback;
+		mouseover: IInteractionDataCallback;
+		mouseup: IInteractionDataCallback;
+		mouseupoutside: IInteractionDataCallback;
+		mousemove: IInteractionDataCallback;
+		tap: IInteractionDataCallback;
+		touchend: IInteractionDataCallback;
+		touchendoutside: IInteractionDataCallback;
+		touchstart: IInteractionDataCallback;
+		touchmove: IInteractionDataCallback;
+
+		//deprecated
+		setInteractive(interactive: boolean): void;
+
+		// getters setters
+		interactive:boolean;
+		mask:Graphics;
+	}
+
+	export class DisplayObjectContainer extends DisplayObject
+	{
+		children: DisplayObject[];
+		constructor();
+
+		addChild(child: DisplayObject): void;
+		addChildAt(child: DisplayObject, index: number): void;
+		getChildAt(index:number):DisplayObject;
+		removeChild(child: DisplayObject): void;
+		swapChildren(child: DisplayObject, child2: DisplayObject): void;
+	}
+
+	export class Ellipse implements IHitArea
+	{
+		x: number;
+		y: number;
+		width: number;
+		height: number;
+
+		constructor(x: number, y: number, width: number, height: number);
+		clone(): Ellipse;
+		contains(x: number, y: number):boolean;
+		getBounds():Rectangle;
+	}
+
+	export class EventTarget
+	{
+		addEventListener(type: string, listener: (event: IEvent) => void );
+		removeEventListener(type: string, listener: (event: IEvent) => void );
+		dispatchEvent(event: IEvent);
+	}
+
+	export class Graphics extends DisplayObjectContainer
+	{
+		lineWidth:number;
+		lineColor:string;
+		constructor();
+
+		beginFill(color?: number, alpha?: number): void;
+		clear(): void;
+		drawCircle(x: number, y: number, radius: number): void;
+		drawElipse(x: number, y: number, width: number, height: number): void;
+		drawRect(x: number, y: number, width: number, height: number): void;
+		endFill(): void;
+		lineStyle(lineWidth?: number, color?: number, alpha?: number ): void;
+		lineTo(x: number, y: number): void;
+		moveTo(x: number, y: number): void;
+
+		static POLY:number;
+		static RECT:number;
+		static CIRC:number;
+		static ELIP:number;
+	}
+
+	export class ImageLoader extends EventTarget
+	{
+		texture:Texture;
+		constructor(url: string, crossorigin?: boolean);
+		load(): void;
+	}
+
+	/* TODO determine type of originalEvent*/
+	export class InteractionData
+	{
+		global: Point;
+		target: Sprite;
+		constructor();
+		originalEvent:any;
+		getLocalPosition(displayObject: DisplayObject): Point;
+	}
+
+	export class InteractionManager
+	{
+		mouse: InteractionData;
+		stage: Stage;
+		touchs:{ [id:string]:InteractionData };
+		constructor(stage: Stage);
+	}
+
+	export class JsonLoader extends EventTarget
+	{
+		url:string;
+		crossorigin: boolean;
+		baseUrl:string;
+		loaded:boolean;
+		constructor(url: string, crossorigin?: boolean);
+		load(): void;
+	}
+
+	export class MovieClip extends Sprite
+	{
+		animationSpeed: number;
+		currentFrame:number;
+		loop: boolean;
+		playing: boolean;
+		textures: Texture[];
+		constructor(textures: Texture[]);
+		onComplete:IBasicCallback;
+		gotoAndPlay(frameNumber: number): void;
+		gotoAndStop(frameNumber: number): void;
+		play(): void;
+		stop(): void;
+	}
+
+	export class Point
+	{
+		x: number;
+		y: number;
+		constructor(x: number, y: number);
+		clone(): Point;
+	}
+
+	export class Polygon implements IHitArea
+	{
+		points: Point[];
+
+		constructor(points: Point[]);
+		constructor(points: number[]);
+		constructor(...points: Point[]);
+		constructor(...points: number[]);
+
+		clone(): Polygon;
+		contains( x:number, y:number ):boolean;
+	}
+
+	export class Rectangle implements IHitArea
+	{
+		x: number;
+		y: number;
+		width: number;
+		height: number;
+		constructor(x: number, y: number, width: number, height: number);
+		clone(): Rectangle;
+		contains(x: number, y: number):boolean
+	}
+
+	export class RenderTexture extends Texture
+	{
+		constructor(width: number, height: number);
+		resize(width: number, height: number): void;
+	}
+
+	export class Sprite extends DisplayObjectContainer
+	{
+		anchor: Point;
+		blendMode: number;
+		texture: Texture;
+
+		//getters setters
+		height: number;
+		width: number;
+
+		constructor(texture: Texture);
+
+		static fromFrame(frameId: string): Sprite;
+		static fromImage(url: string): Sprite;
+		setTexture(texture: Texture): void;
+	}
+
+	/* TODO determine type of frames */
+	export class SpriteSheetLoader extends EventTarget
+	{
+		url:string;
+		crossorigin:boolean;
+		baseUrl:string;
+		texture:Texture;
+		frames:Object;
+		constructor(url: string, crossorigin?: boolean);
+		load();
+	}
+
+	export class Stage extends DisplayObjectContainer
+	{
+		interactive:boolean;
+		interactionManager:InteractionManager;
+		constructor(backgroundColor: number, interactive?: boolean);
+		getMousePosition(): Point;
+		setBackgroundColor(backgroundColor: number): void;
+	}
+
+	export class Text extends Sprite
+	{
+		constructor(text: string, style: ITextStyle);
+		destroy(destroyTexture:boolean):void;
+		setText(text: string): void;
+		setStyle(style: ITextStyle): void;
+	}
+
+	export class Texture extends EventTarget
+	{
+		baseTexture: BaseTexture;
+		frame: Rectangle;
+		trim:Point;
+		render( displayObject:DisplayObject, position:Point, clear:boolean ):void;
+		constructor(baseTexture: BaseTexture, frame?: Rectangle);
+		destroy(destroyBase:boolean):void;
+		setFrame(frame: Rectangle): void;
+
+		static addTextureToCache(texture: Texture, id: string): void;
+		static fromCanvas(canvas: HTMLCanvasElement): Texture;
+		static fromFrame(frameId: string): Texture;
+		static fromImage(imageUrl: string, crossorigin?: boolean): Texture;
+		static removeTextureFromCache(id: any): Texture;
+	}
+
+	export class TilingSprite extends DisplayObjectContainer
+	{
+		width:number;
+		height:number;
+		texture:Texture;
+		tilePosition: Point;
+		tileScale: Point;
+		constructor(texture: Texture, width: number, height: number);
+		setTexture( texture: Texture ):void;
+	}
+
+	export class WebGLBatch
+	{
+		constructor(webGLContext: WebGLRenderingContext);
+		clean():void;
+		restoreLostContext(gl:WebGLRenderingContext)
+		init(sprite: Sprite): void;
+		insertAfter(sprite: Sprite, previousSprite: Sprite): void;
+		insertBefore(sprite: Sprite, nextSprite: Sprite): void;
+		growBatch(): void;
+		merge(batch: WebGLBatch): void;
+		refresh(): void;
+		remove(sprite: Sprite): void;
+		render(): void;
+		split(sprite: Sprite): WebGLBatch;
+		update(): void;
+	}
+
+	/* Determine type of Object */
+	export class WebGLRenderGroup
+	{
+		render(projection:Object):void;
+	}
+
+	export class WebGLRenderer implements IPixiRenderer
+	{
+		view: HTMLCanvasElement;
+		constructor(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean, antialias?:boolean );
+		render(stage: Stage): void;
+		resize(width: number, height: number): void;
+	}
+
+}
+
+declare function requestAnimFrame( animate: PIXI.IBasicCallback );
+
+
+declare module PIXI.PolyK
+{
+	export function Triangulate( p:number[]):number[];
+}
+
+
+
diff --git a/pixi/webgl.d.ts b/pixi/webgl.d.ts
new file mode 100644
index 0000000000..63172ad92e
--- /dev/null
+++ b/pixi/webgl.d.ts
@@ -0,0 +1,534 @@
+interface WebGLContextAttributes {
+	alpha : boolean;
+	depth : boolean;
+	stencil : boolean;
+	antialias : boolean;
+	premultipliedAlpha : boolean;
+}
+
+interface WebGLObject {
+	$__dummyprop__WebGLObject : any;
+}
+
+interface WebGLBuffer extends WebGLObject {
+	$__dummyprop__WebGLBuffer : any;
+}
+
+interface WebGLFramebuffer extends WebGLObject {
+	$__dummyprop__WebGLFramebuffer : any;
+}
+
+interface WebGLProgram extends WebGLObject {
+	$__dummyprop__WebGLProgram : any;
+}
+
+interface WebGLRenderbuffer extends WebGLObject {
+	$__dummyprop__WebGLRenderbuffer : any;
+}
+
+interface WebGLShader extends WebGLObject {
+	$__dummyprop__WebGLShader : any;
+}
+
+interface WebGLTexture extends WebGLObject {
+	$__dummyprop__WebGLTexture : any;
+}
+
+interface WebGLUniformLocation {
+	$__dummyprop__WebGLUniformLocation : any;
+}
+
+interface WebGLActiveInfo {
+	size : number;
+	type : number;
+	name : string;
+}
+
+interface WebGLRenderingContext {
+	DEPTH_BUFFER_BIT : number;
+	STENCIL_BUFFER_BIT : number;
+	COLOR_BUFFER_BIT : number;
+	POINTS : number;
+	LINES : number;
+	LINE_LOOP : number;
+	LINE_STRIP : number;
+	TRIANGLES : number;
+	TRIANGLE_STRIP : number;
+	TRIANGLE_FAN : number;
+	ZERO : number;
+	ONE : number;
+	SRC_COLOR : number;
+	ONE_MINUS_SRC_COLOR : number;
+	SRC_ALPHA : number;
+	ONE_MINUS_SRC_ALPHA : number;
+	DST_ALPHA : number;
+	ONE_MINUS_DST_ALPHA : number;
+	DST_COLOR : number;
+	ONE_MINUS_DST_COLOR : number;
+	SRC_ALPHA_SATURATE : number;
+	FUNC_ADD : number;
+	BLEND_EQUATION : number;
+	BLEND_EQUATION_RGB : number;
+	BLEND_EQUATION_ALPHA : number;
+	FUNC_SUBTRACT : number;
+	FUNC_REVERSE_SUBTRACT : number;
+	BLEND_DST_RGB : number;
+	BLEND_SRC_RGB : number;
+	BLEND_DST_ALPHA : number;
+	BLEND_SRC_ALPHA : number;
+	CONSTANT_COLOR : number;
+	ONE_MINUS_CONSTANT_COLOR : number;
+	CONSTANT_ALPHA : number;
+	ONE_MINUS_CONSTANT_ALPHA : number;
+	BLEND_COLOR : number;
+	ARRAY_BUFFER : number;
+	ELEMENT_ARRAY_BUFFER : number;
+	ARRAY_BUFFER_BINDING : number;
+	ELEMENT_ARRAY_BUFFER_BINDING : number;
+	STREAM_DRAW : number;
+	STATIC_DRAW : number;
+	DYNAMIC_DRAW : number;
+	BUFFER_SIZE : number;
+	BUFFER_USAGE : number;
+	CURRENT_VERTEX_ATTRIB : number;
+	FRONT : number;
+	BACK : number;
+	FRONT_AND_BACK : number;
+	TEXTURE_2D : number;
+	CULL_FACE : number;
+	BLEND : number;
+	DITHER : number;
+	STENCIL_TEST : number;
+	DEPTH_TEST : number;
+	SCISSOR_TEST : number;
+	POLYGON_OFFSET_FILL : number;
+	SAMPLE_ALPHA_TO_COVERAGE : number;
+	SAMPLE_COVERAGE : number;
+	NO_ERROR : number;
+	INVALID_ENUM : number;
+	INVALID_VALUE : number;
+	INVALID_OPERATION : number;
+	OUT_OF_MEMORY : number;
+	CW : number;
+	CCW : number;
+	LINE_WIDTH : number;
+	ALIASED_POINT_SIZE_RANGE : number;
+	ALIASED_LINE_WIDTH_RANGE : number;
+	CULL_FACE_MODE : number;
+	FRONT_FACE : number;
+	DEPTH_RANGE : number;
+	DEPTH_WRITEMASK : number;
+	DEPTH_CLEAR_VALUE : number;
+	DEPTH_FUNC : number;
+	STENCIL_CLEAR_VALUE : number;
+	STENCIL_FUNC : number;
+	STENCIL_FAIL : number;
+	STENCIL_PASS_DEPTH_FAIL : number;
+	STENCIL_PASS_DEPTH_PASS : number;
+	STENCIL_REF : number;
+	STENCIL_VALUE_MASK : number;
+	STENCIL_WRITEMASK : number;
+	STENCIL_BACK_FUNC : number;
+	STENCIL_BACK_FAIL : number;
+	STENCIL_BACK_PASS_DEPTH_FAIL : number;
+	STENCIL_BACK_PASS_DEPTH_PASS : number;
+	STENCIL_BACK_REF : number;
+	STENCIL_BACK_VALUE_MASK : number;
+	STENCIL_BACK_WRITEMASK : number;
+	VIEWPORT : number;
+	SCISSOR_BOX : number;
+	COLOR_CLEAR_VALUE : number;
+	COLOR_WRITEMASK : number;
+	UNPACK_ALIGNMENT : number;
+	PACK_ALIGNMENT : number;
+	MAX_TEXTURE_SIZE : number;
+	MAX_VIEWPORT_DIMS : number;
+	SUBPIXEL_BITS : number;
+	RED_BITS : number;
+	GREEN_BITS : number;
+	BLUE_BITS : number;
+	ALPHA_BITS : number;
+	DEPTH_BITS : number;
+	STENCIL_BITS : number;
+	POLYGON_OFFSET_UNITS : number;
+	POLYGON_OFFSET_FACTOR : number;
+	TEXTURE_BINDING_2D : number;
+	SAMPLE_BUFFERS : number;
+	SAMPLES : number;
+	SAMPLE_COVERAGE_VALUE : number;
+	SAMPLE_COVERAGE_INVERT : number;
+	NUM_COMPRESSED_TEXTURE_FORMATS : number;
+	COMPRESSED_TEXTURE_FORMATS : number;
+	DONT_CARE : number;
+	FASTEST : number;
+	NICEST : number;
+	GENERATE_MIPMAP_HINT : number;
+	BYTE : number;
+	UNSIGNED_BYTE : number;
+	SHORT : number;
+	UNSIGNED_SHORT : number;
+	INT : number;
+	UNSIGNED_INT : number;
+	FLOAT : number;
+	DEPTH_COMPONENT : number;
+	ALPHA : number;
+	RGB : number;
+	RGBA : number;
+	LUMINANCE : number;
+	LUMINANCE_ALPHA : number;
+	UNSIGNED_SHORT_4_4_4_4 : number;
+	UNSIGNED_SHORT_5_5_5_1 : number;
+	UNSIGNED_SHORT_5_6_5 : number;
+	FRAGMENT_SHADER : number;
+	VERTEX_SHADER : number;
+	MAX_VERTEX_ATTRIBS : number;
+	MAX_VERTEX_UNIFORM_VECTORS : number;
+	MAX_VARYING_VECTORS : number;
+	MAX_COMBINED_TEXTURE_IMAGE_UNITS : number;
+	MAX_VERTEX_TEXTURE_IMAGE_UNITS : number;
+	MAX_TEXTURE_IMAGE_UNITS : number;
+	MAX_FRAGMENT_UNIFORM_VECTORS : number;
+	SHADER_TYPE : number;
+	DELETE_STATUS : number;
+	LINK_STATUS : number;
+	VALIDATE_STATUS : number;
+	ATTACHED_SHADERS : number;
+	ACTIVE_UNIFORMS : number;
+	ACTIVE_UNIFORM_MAX_LENGTH : number;
+	ACTIVE_ATTRIBUTES : number;
+	ACTIVE_ATTRIBUTE_MAX_LENGTH : number;
+	SHADING_LANGUAGE_VERSION : number;
+	CURRENT_PROGRAM : number;
+	NEVER : number;
+	LESS : number;
+	EQUAL : number;
+	LEQUAL : number;
+	GREATER : number;
+	NOTEQUAL : number;
+	GEQUAL : number;
+	ALWAYS : number;
+	KEEP : number;
+	REPLACE : number;
+	INCR : number;
+	DECR : number;
+	INVERT : number;
+	INCR_WRAP : number;
+	DECR_WRAP : number;
+	VENDOR : number;
+	RENDERER : number;
+	VERSION : number;
+	NEAREST : number;
+	LINEAR : number;
+	NEAREST_MIPMAP_NEAREST : number;
+	LINEAR_MIPMAP_NEAREST : number;
+	NEAREST_MIPMAP_LINEAR : number;
+	LINEAR_MIPMAP_LINEAR : number;
+	TEXTURE_MAG_FILTER : number;
+	TEXTURE_MIN_FILTER : number;
+	TEXTURE_WRAP_S : number;
+	TEXTURE_WRAP_T : number;
+	TEXTURE : number;
+	TEXTURE_CUBE_MAP : number;
+	TEXTURE_BINDING_CUBE_MAP : number;
+	TEXTURE_CUBE_MAP_POSITIVE_X : number;
+	TEXTURE_CUBE_MAP_NEGATIVE_X : number;
+	TEXTURE_CUBE_MAP_POSITIVE_Y : number;
+	TEXTURE_CUBE_MAP_NEGATIVE_Y : number;
+	TEXTURE_CUBE_MAP_POSITIVE_Z : number;
+	TEXTURE_CUBE_MAP_NEGATIVE_Z : number;
+	MAX_CUBE_MAP_TEXTURE_SIZE : number;
+	TEXTURE0 : number;
+	TEXTURE1 : number;
+	TEXTURE2 : number;
+	TEXTURE3 : number;
+	TEXTURE4 : number;
+	TEXTURE5 : number;
+	TEXTURE6 : number;
+	TEXTURE7 : number;
+	TEXTURE8 : number;
+	TEXTURE9 : number;
+	TEXTURE10 : number;
+	TEXTURE11 : number;
+	TEXTURE12 : number;
+	TEXTURE13 : number;
+	TEXTURE14 : number;
+	TEXTURE15 : number;
+	TEXTURE16 : number;
+	TEXTURE17 : number;
+	TEXTURE18 : number;
+	TEXTURE19 : number;
+	TEXTURE20 : number;
+	TEXTURE21 : number;
+	TEXTURE22 : number;
+	TEXTURE23 : number;
+	TEXTURE24 : number;
+	TEXTURE25 : number;
+	TEXTURE26 : number;
+	TEXTURE27 : number;
+	TEXTURE28 : number;
+	TEXTURE29 : number;
+	TEXTURE30 : number;
+	TEXTURE31 : number;
+	ACTIVE_TEXTURE : number;
+	REPEAT : number;
+	CLAMP_TO_EDGE : number;
+	MIRRORED_REPEAT : number;
+	FLOAT_VEC2 : number;
+	FLOAT_VEC3 : number;
+	FLOAT_VEC4 : number;
+	INT_VEC2 : number;
+	INT_VEC3 : number;
+	INT_VEC4 : number;
+	BOOL : number;
+	BOOL_VEC2 : number;
+	BOOL_VEC3 : number;
+	BOOL_VEC4 : number;
+	FLOAT_MAT2 : number;
+	FLOAT_MAT3 : number;
+	FLOAT_MAT4 : number;
+	SAMPLER_2D : number;
+	SAMPLER_CUBE : number;
+	VERTEX_ATTRIB_ARRAY_ENABLED : number;
+	VERTEX_ATTRIB_ARRAY_SIZE : number;
+	VERTEX_ATTRIB_ARRAY_STRIDE : number;
+	VERTEX_ATTRIB_ARRAY_TYPE : number;
+	VERTEX_ATTRIB_ARRAY_NORMALIZED : number;
+	VERTEX_ATTRIB_ARRAY_POINTER : number;
+	VERTEX_ATTRIB_ARRAY_BUFFER_BINDING : number;
+	COMPILE_STATUS : number;
+	INFO_LOG_LENGTH : number;
+	SHADER_SOURCE_LENGTH : number;
+	LOW_FLOAT : number;
+	MEDIUM_FLOAT : number;
+	HIGH_FLOAT : number;
+	LOW_INT : number;
+	MEDIUM_INT : number;
+	HIGH_INT : number;
+	FRAMEBUFFER : number;
+	RENDERBUFFER : number;
+	RGBA4 : number;
+	RGB5_A1 : number;
+	RGB565 : number;
+	DEPTH_COMPONENT16 : number;
+	STENCIL_INDEX : number;
+	STENCIL_INDEX8 : number;
+	DEPTH_STENCIL : number;
+	RENDERBUFFER_WIDTH : number;
+	RENDERBUFFER_HEIGHT : number;
+	RENDERBUFFER_INTERNAL_FORMAT : number;
+	RENDERBUFFER_RED_SIZE : number;
+	RENDERBUFFER_GREEN_SIZE : number;
+	RENDERBUFFER_BLUE_SIZE : number;
+	RENDERBUFFER_ALPHA_SIZE : number;
+	RENDERBUFFER_DEPTH_SIZE : number;
+	RENDERBUFFER_STENCIL_SIZE : number;
+	FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE : number;
+	FRAMEBUFFER_ATTACHMENT_OBJECT_NAME : number;
+	FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL : number;
+	FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE : number;
+	COLOR_ATTACHMENT0 : number;
+	DEPTH_ATTACHMENT : number;
+	STENCIL_ATTACHMENT : number;
+	DEPTH_STENCIL_ATTACHMENT : number;
+	NONE : number;
+	FRAMEBUFFER_COMPLETE : number;
+	FRAMEBUFFER_INCOMPLETE_ATTACHMENT : number;
+	FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT : number;
+	FRAMEBUFFER_INCOMPLETE_DIMENSIONS : number;
+	FRAMEBUFFER_UNSUPPORTED : number;
+	FRAMEBUFFER_BINDING : number;
+	RENDERBUFFER_BINDING : number;
+	MAX_RENDERBUFFER_SIZE : number;
+	INVALID_FRAMEBUFFER_OPERATION : number;
+	UNPACK_FLIP_Y_WEBGL : number;
+	UNPACK_PREMULTIPLY_ALPHA_WEBGL : number;
+	CONTEXT_LOST_WEBGL : number;
+	UNPACK_COLORSPACE_CONVERSION_WEBGL : number;
+	BROWSER_DEFAULT_WEBGL : number;
+	canvas : HTMLCanvasElement;
+	getContextAttributes() : WebGLContextAttributes;
+	isContextLost() : boolean;
+	getSupportedExtensions() : string[];
+	getExtension(name : string) : any;
+	activeTexture(texture : number) : void;
+	attachShader(program : WebGLProgram, shader : WebGLShader) : void;
+	bindAttribLocation(program : WebGLProgram, index : number, name : string) : void;
+	bindBuffer(target : number, buffer : WebGLBuffer) : void;
+	bindFramebuffer(target : number, framebuffer : WebGLFramebuffer) : void;
+	bindRenderbuffer(target : number, renderbuffer : WebGLRenderbuffer) : void;
+	bindTexture(target : number, texture : WebGLTexture) : void;
+	blendColor(red : number, green : number, blue : number, alpha : number) : void;
+	blendEquation(mode : number) : void;
+	blendEquationSeparate(modeRGB : number, modeAlpha : number) : void;
+	blendFunc(sfactor : number, dfactor : number) : void;
+	blendFuncSeparate(srcRGB : number, dstRGB : number, srcAlpha : number, dstAlpha : number) : void;
+	bufferData(target : number, size : number, usage : number) : void;
+	bufferData(target : number, data : ArrayBufferView, usage : number) : void;
+	bufferData(target : number, data : ArrayBuffer, usage : number) : void;
+	bufferSubData(target : number, offset : number, data : ArrayBufferView) : void;
+	bufferSubData(target : number, offset : number, data : ArrayBuffer) : void;
+	checkFramebufferStatus(target : number) : number;
+	clear(mask : number) : void;
+	clearColor(red : number, green : number, blue : number, alpha : number) : void;
+	clearDepth(depth : number) : void;
+	clearStencil(s : number) : void;
+	colorMask(red : boolean, green : boolean, blue : boolean, alpha : boolean) : void;
+	compileShader(shader : WebGLShader) : void;
+	copyTexImage2D(target : number, level : number, internalformat : number, x : number, y : number, width : number, height : number, border : number) : void;
+	copyTexSubImage2D(target : number, level : number, xoffset : number, yoffset : number, x : number, y : number, width : number, height : number) : void;
+	createBuffer() : WebGLBuffer;
+	createFramebuffer() : WebGLFramebuffer;
+	createProgram() : WebGLProgram;
+	createRenderbuffer() : WebGLRenderbuffer;
+	createShader(type : number) : WebGLShader;
+	createTexture() : WebGLTexture;
+	cullFace(mode : number) : void;
+	deleteBuffer(buffer : WebGLBuffer) : void;
+	deleteFramebuffer(framebuffer : WebGLFramebuffer) : void;
+	deleteProgram(program : WebGLProgram) : void;
+	deleteRenderbuffer(renderbuffer : WebGLRenderbuffer) : void;
+	deleteShader(shader : WebGLShader) : void;
+	deleteTexture(texture : WebGLTexture) : void;
+	depthFunc(func : number) : void;
+	depthMask(flag : boolean) : void;
+	depthRange(zNear : number, zFar : number) : void;
+	detachShader(program : WebGLProgram, shader : WebGLShader) : void;
+	disable(cap : number) : void;
+	disableVertexAttribArray(index : number) : void;
+	drawArrays(mode : number, first : number, count : number) : void;
+	drawElements(mode : number, count : number, type : number, offset : number) : void;
+	enable(cap : number) : void;
+	enableVertexAttribArray(index : number) : void;
+	finish() : void;
+	flush() : void;
+	framebufferRenderbuffer(target : number, attachment : number, renderbuffertarget : number, renderbuffer : WebGLRenderbuffer) : void;
+	framebufferTexture2D(target : number, attachment : number, textarget : number, texture : WebGLTexture, level : number) : void;
+	frontFace(mode : number) : void;
+	generateMipmap(target : number) : void;
+	getActiveAttrib(program : WebGLProgram, index : number) : WebGLActiveInfo;
+	getActiveUniform(program : WebGLProgram, index : number) : WebGLActiveInfo;
+	getAttachedShaders(program : WebGLProgram) : WebGLShader[];
+	getAttribLocation(program : WebGLProgram, name : string) : number;
+	getParameter(pname : number) : any;
+	getBufferParameter(target : number, pname : number) : any;
+	getError() : number;
+	getFramebufferAttachmentParameter(target : number, attachment : number, pname : number) : any;
+	getProgramParameter(program : WebGLProgram, pname : number) : any;
+	getProgramInfoLog(program : WebGLProgram) : string;
+	getRenderbufferParameter(target : number, pname : number) : any;
+	getShaderParameter(shader : WebGLShader, pname : number) : any;
+	getShaderInfoLog(shader : WebGLShader) : string;
+	getShaderSource(shader : WebGLShader) : string;
+	getTexParameter(target : number, pname : number) : any;
+	getUniform(program : WebGLProgram, location : WebGLUniformLocation) : any;
+	getUniformLocation(program : WebGLProgram, name : string) : WebGLUniformLocation;
+	getVertexAttrib(index : number, pname : number) : any;
+	getVertexAttribOffset(index : number, pname : number) : number;
+	hint(target : number, mode : number) : void;
+	isBuffer(buffer : WebGLBuffer) : boolean;
+	isEnabled(cap : number) : boolean;
+	isFramebuffer(framebuffer : WebGLFramebuffer) : boolean;
+	isProgram(program : WebGLProgram) : boolean;
+	isRenderbuffer(renderbuffer : WebGLRenderbuffer) : boolean;
+	isShader(shader : WebGLShader) : boolean;
+	isTexture(texture : WebGLTexture) : boolean;
+	lineWidth(width : number) : void;
+	linkProgram(program : WebGLProgram) : void;
+	pixelStorei(pname : number, param : number) : void;
+	polygonOffset(factor : number, units : number) : void;
+	readPixels(x : number, y : number, width : number, height : number, format : number, type : number, pixels : ArrayBufferView) : void;
+	renderbufferStorage(target : number, internalformat : number, width : number, height : number) : void;
+	sampleCoverage(value : number, invert : boolean) : void;
+	scissor(x : number, y : number, width : number, height : number) : void;
+	shaderSource(shader : WebGLShader, source : string) : void;
+	stencilFunc(func : number, ref : number, mask : number) : void;
+	stencilFuncSeparate(face : number, func : number, ref : number, mask : number) : void;
+	stencilMask(mask : number) : void;
+	stencilMaskSeparate(face : number, mask : number) : void;
+	stencilOp(fail : number, zfail : number, zpass : number) : void;
+	stencilOpSeparate(face : number, fail : number, zfail : number, zpass : number) : void;
+	texImage2D(target : number, level : number, internalformat : number, width : number, height : number, border : number, format : number, type : number, pixels : ArrayBufferView) : void;
+	texImage2D(target : number, level : number, internalformat : number, format : number, type : number, pixels : ImageData) : void;
+	texImage2D(target : number, level : number, internalformat : number, format : number, type : number, image : HTMLImageElement) : void;
+	texImage2D(target : number, level : number, internalformat : number, format : number, type : number, canvas : HTMLCanvasElement) : void;
+	texImage2D(target : number, level : number, internalformat : number, format : number, type : number, video : HTMLVideoElement) : void;
+	texParameterf(target : number, pname : number, param : number) : void;
+	texParameteri(target : number, pname : number, param : number) : void;
+	texSubImage2D(target : number, level : number, xoffset : number, yoffset : number, width : number, height : number, format : number, type : number, pixels : ArrayBufferView) : void;
+	texSubImage2D(target : number, level : number, xoffset : number, yoffset : number, format : number, type : number, pixels : ImageData) : void;
+	texSubImage2D(target : number, level : number, xoffset : number, yoffset : number, format : number, type : number, image : HTMLImageElement) : void;
+	texSubImage2D(target : number, level : number, xoffset : number, yoffset : number, format : number, type : number, canvas : HTMLCanvasElement) : void;
+	texSubImage2D(target : number, level : number, xoffset : number, yoffset : number, format : number, type : number, video : HTMLVideoElement) : void;
+	uniform1f(location : WebGLUniformLocation, x : number) : void;
+	uniform1fv(location : WebGLUniformLocation, v : Float32Array) : void;
+	uniform1fv(location : WebGLUniformLocation, v : number[]) : void;
+	uniform1i(location : WebGLUniformLocation, x : number) : void;
+	uniform1iv(location : WebGLUniformLocation, v : Int32Array) : void;
+	uniform1iv(location : WebGLUniformLocation, v : number[]) : void;
+	uniform2f(location : WebGLUniformLocation, x : number, y : number) : void;
+	uniform2fv(location : WebGLUniformLocation, v : Float32Array) : void;
+	uniform2fv(location : WebGLUniformLocation, v : number[]) : void;
+	uniform2i(location : WebGLUniformLocation, x : number, y : number) : void;
+	uniform2iv(location : WebGLUniformLocation, v : Int32Array) : void;
+	uniform2iv(location : WebGLUniformLocation, v : number[]) : void;
+	uniform3f(location : WebGLUniformLocation, x : number, y : number, z : number) : void;
+	uniform3fv(location : WebGLUniformLocation, v : Float32Array) : void;
+	uniform3fv(location : WebGLUniformLocation, v : number[]) : void;
+	uniform3i(location : WebGLUniformLocation, x : number, y : number, z : number) : void;
+	uniform3iv(location : WebGLUniformLocation, v : Int32Array) : void;
+	uniform3iv(location : WebGLUniformLocation, v : number[]) : void;
+	uniform4f(location : WebGLUniformLocation, x : number, y : number, z : number, w : number) : void;
+	uniform4fv(location : WebGLUniformLocation, v : Float32Array) : void;
+	uniform4fv(location : WebGLUniformLocation, v : number[]) : void;
+	uniform4i(location : WebGLUniformLocation, x : number, y : number, z : number, w : number) : void;
+	uniform4iv(location : WebGLUniformLocation, v : Int32Array) : void;
+	uniform4iv(location : WebGLUniformLocation, v : number[]) : void;
+	uniformMatrix2fv(location : WebGLUniformLocation, transpose : boolean, value : Float32Array) : void;
+	uniformMatrix2fv(location : WebGLUniformLocation, transpose : boolean, value : number[]) : void;
+	uniformMatrix3fv(location : WebGLUniformLocation, transpose : boolean, value : Float32Array) : void;
+	uniformMatrix3fv(location : WebGLUniformLocation, transpose : boolean, value : number[]) : void;
+	uniformMatrix4fv(location : WebGLUniformLocation, transpose : boolean, value : Float32Array) : void;
+	uniformMatrix4fv(location : WebGLUniformLocation, transpose : boolean, value : number[]) : void;
+	useProgram(program : WebGLProgram) : void;
+	validateProgram(program : WebGLProgram) : void;
+	vertexAttrib1f(indx : number, x : number) : void;
+	vertexAttrib1fv(indx : number, values : Float32Array) : void;
+	vertexAttrib1fv(indx : number, values : number[]) : void;
+	vertexAttrib2f(indx : number, x : number, y : number) : void;
+	vertexAttrib2fv(indx : number, values : Float32Array) : void;
+	vertexAttrib2fv(indx : number, values : number[]) : void;
+	vertexAttrib3f(indx : number, x : number, y : number, z : number) : void;
+	vertexAttrib3fv(indx : number, values : Float32Array) : void;
+	vertexAttrib3fv(indx : number, values : number[]) : void;
+	vertexAttrib4f(indx : number, x : number, y : number, z : number, w : number) : void;
+	vertexAttrib4fv(indx : number, values : Float32Array) : void;
+	vertexAttrib4fv(indx : number, values : number[]) : void;
+	vertexAttribPointer(indx : number, size : number, type : number, normalized : boolean, stride : number, offset : number) : void;
+	viewport(x : number, y : number, width : number, height : number) : void;
+}
+
+interface WebGLContextEvent extends Event {
+	statusMessage : string;
+	initWebGLContextEvent(typeArg : string, canBubbleArg : boolean, cancelableArg : boolean, statusMessageArg : string) : void;
+}
+
+//Extend the window object with cross Browser callbacks so TS will not complain 
+//Also add the (non-standard) Canvas Element parameter for performance improvement 
+interface WindowAnimationTiming {
+	requestAnimationFrame(callback: FrameRequestCallback, canvas ?: HTMLCanvasElement): number;
+	//msRequestAnimationFrame(callback: FrameRequestCallback, canvas ?: HTMLCanvasElement): number;
+	mozRequestAnimationFrame(callback: FrameRequestCallback, canvas ?: HTMLCanvasElement): number;
+	webkitRequestAnimationFrame(callback: FrameRequestCallback, canvas ?: HTMLCanvasElement): number;
+	oRequestAnimationFrame(callback: FrameRequestCallback, canvas ?: HTMLCanvasElement): number;	 
+
+	cancelRequestAnimationFrame(handle: number): void;
+	//msCancelRequestAnimationFrame(handle: number): void;
+	mozCancelRequestAnimationFrame(handle: number): void;
+	webkitCancelRequestAnimationFrame(handle: number): void;
+	oCancelRequestAnimationFrame(handle: number): void;
+}
+
+//To make WebGL work 
+interface HTMLCanvasElement {
+	getContext(contextId: string, params : {}): WebGLRenderingContext;
+}
\ No newline at end of file