Anyway I am getting side tracked. The process in either case to do this is really, really, really tedious and on a few occasions now I have been whinging to the guys at Adobe about this and how hopeless it is. But after many years it's still just the same and lame.

You might ask why not use SWCs to manage library assets? Problem I have with SWCs is if you use them for all the assets in your project then your compile times will eventually go through the roof! This is something which your team could waste days or even weeks of time especially in longer production phases.

This said I still want a process where I can load assets from a SWF library with some kind of strict type safety and have not just rely on resolving library assets at runtime. This could allow for you to be aware that a library asset is missing before compiling.

Creating a bulletproof utility to map existing classes to your library assets would be quite difficult to setup. So instead I have written something simple (initially) which allows for you to automatically set library assets to be exported with linkage ids. This works by basically using the library name as the linkage id for an asset and iterating through selected library assets.

 
	var packageName=prompt("Library package name","com.library.display");
 
	var selItems = fl.getDocumentDOM().library.getSelectedItems(); 
 
	for(var i =0; i<selItems.length; i++){
		item = selItems[i];
 
		var className=item.name;
 
		var sliceIndex=className.lastIndexOf("/");
		className.slice(sliceIndex+1,className.length);
 
		className = className.split(" ").join("");
 
		var dotIndex=className.lastIndexOf(".");
		if(dotIndex!=-1) className=className.slice(0,dotIndex);
 
		item.linkageExportForAS = true;
		item.linkageExportInFirstFrame = true;
		item.linkageClassName = packageName+"."+className;
 
		fl.outputPanel.trace(item.linkageClassName);
	}
 
	alert("Exported complete!");
 

Although this saves quite a bit of time it's still kinda annoying, I would have to copy and paste linkage ids from the woeful Flash IDE library and I would not get any intellisense from FlashBuilder or FDT.

Although we can take this same idea a bit further to accommodate better support for intellisense with library assets from a SWF library with FlashBuilder or FDT. Although it's important and maybe obvious this technique will require loading the SWF library assets into the parent applicationDomain by just using a Loader instance. Next by using JSFL you can create classes automatically based on the library items type. Here I am probably achieving this by an unintended use of the save function from the outputPanel but it allows for you to write classes and then save them into a particular folder.

 
	fl.outputPanel.clear();
	fl.outputPanel.trace(templateClass);
	fl.outputPanel.save(saveLocation+folderPath+"LibraryLinkageReferences.as");
 

I only set this JSFL up for Buttons, MovieClips and Bitmaps but this could be extended to work with other types. The JSFL to do this looks like :

 
	var saveLocation=fl.browseForFolderURL("Save classes location");
	var packageName=prompt("Package name","com.library.display");
	var folderPath = packageName.split(".").join("/")+"/";
 
	FLfile.createFolder(saveLocation+folderPath);
 
	var selItems=fl.getDocumentDOM().library.getSelectedItems();
 
	for (var i =0; i< selItems.length; i++) {
		item= selItems[i];
 
		var className=item.name;
 
		var sliceIndex=className.lastIndexOf("/");
		className.slice(sliceIndex+1,className.length);
 
		className = className.split(" ").join("");
 
		var dotIndex=className.lastIndexOf(".");
		if(dotIndex!=-1) className=className.slice(0,dotIndex);
 
		item.linkageExportForAS = true;
		item.linkageExportInFirstFrame = true;
		item.linkageClassName = packageName+"."+className;
 
		var templateClass='package '+packageName+' {
			classImports
			public class className extends baseClassName {
				public function className() {
					classConstructor
				}
			}
		}';
 
		var linkageName=item.linkageClassName;
 
		var className=item.name;
 
		var sliceIndex=className.lastIndexOf("/");
		className.slice(sliceIndex+1,className.length);
 
		className = className.split(" ").join("");
 
		var dotIndex=className.lastIndexOf(".");
		if(dotIndex!=-1) className=className.slice(0,dotIndex);
 
		className = className.substr(0, 1).toUpperCase()+className.substr(1, className.length-1);
 
		var baseClassName=item.linkageBaseClass;
		var classConstructor='addChild(new (getDefinitionByName("linkageName"))());';
		var classImports = '	import flash.utils.getDefinitionByName;\n';
 
		switch (item.itemType) {
			case "bitmap" :
				baseClassName="flash.display.Bitmap";
				classConstructor='super(new (getDefinitionByName("linkageName"))(0, 0));';
			break;
			case "movieclip" :
				baseClassName="flash.display.MovieClip";
			break;
			case "button" :
				baseClassName="flash.display.SimpleButton";
			break;
		}
 
		classImports+='	import '+baseClassName+';';
 
		templateClass=templateClass.replace(/className/g,className);
		templateClass=templateClass.replace(/classImports/g,classImports);
		templateClass=templateClass.replace(/classConstructor/g,classConstructor);
		templateClass=templateClass.replace(/baseClassName/g,baseClassName);
		templateClass=templateClass.replace(/linkageName/g,linkageName);
 
		fl.outputPanel.clear();
		fl.outputPanel.trace(templateClass);
		fl.outputPanel.save(saveLocation+folderPath+className+".as");
		fl.outputPanel.clear();
	}
 

Though if you don't like using this approach of creating stub classes for retrieving library assets from a SWF library then there is one last technique using JSFL which you can use whilst still having some ability to use intellisense. Like I mentioned before the most annoying part of working with SWF library assets is not having intellisense. We could then instead of creating classes as a reference to the library SWF class, automatically create a single LibraryLinkageReferences class which contains static constants which are references to the library linkage ids.

 
	var saveLocation=fl.browseForFolderURL("Save class location");
	var libraryPackageName=prompt("Library package name","library");
	var classPackageName=prompt("Class package name","com.library.display");
 
	var folderPath = classPackageName.split(".").join("/")+"/";
	var templateClass = 'package '+classPackageName+' {\n	public class LibraryLinkageReference{\n';
 
	FLfile.createFolder(saveLocation+folderPath);
 
	var selItems =fl.getDocumentDOM().library.getSelectedItems();
 
	for (var i =0; i< selItems.length; i++) {
		item= selItems[i];
 
		var className=item.name;
 
		var sliceIndex=className.lastIndexOf("/");
		className.slice(sliceIndex+1,className.length);
 
		className = className.split(" ").join("");
 
		var dotIndex=className.lastIndexOf(".");
		if(dotIndex!=-1) className=className.slice(0,dotIndex);
 
		className = className.substr(0, 1).toUpperCase()+className.substr(1, className.length-1);
 
		item.linkageExportForAS = true;
		item.linkageExportInFirstFrame = true;
		item.linkageClassName = libraryPackageName+"."+className;
 
		templateClass+="public static const "+className.toUpperCase()+":String = \""+item.linkageClassName+"\";\n";
	}
 
	templateClass+='	}\n}';
 
	fl.outputPanel.clear();
	fl.outputPanel.trace(templateClass);
	fl.outputPanel.save(saveLocation+folderPath+"LibraryLinkageReferences.as");
 
	alert("Exported complete saved to : "+saveLocation+folderPath+"LibraryLinkageReferences.as");
 

Hopefully this is some food for thought or very useful. I know I find these techniques and JSFL scripts very handy :)

Setup Library Linkages
Export Library Classes
Export Library References Class

 
<target name="removeTrace">
			<replaceregexp match="trace(.*?);" replace="" flags="gs">
			    <fileset dir="${classesdir}" includes="**/*.as"/>
			</replaceregexp>
</target>
 

Enjoy!

In the past I had always used Hurlant's crypto library which has quite a few cryptography options and includes my favorite algorithm AES. Advanced Encryption Standard is a quite secure cryptography solution and is supposedly the exact same level of encryption used by American Government's NSA. I am not a server side guy typically but I can code C#. The nice thing about C# and AES when transacting to and from Flash is it works perfectly. PHP unfortunately does not have an official cryptography package, but thankfully there are many efforts to support this cryptography algorithm from within the community. This might sound OK, but the problem we had with this is Hurlant's AS3 cryptography library doesn't seem to be able to interface with the PHP AES options we tried (though it seems to work fine with other languages like C#). We did put in a good hour or so trying several mode, pad and encoding options - no dice. After a quick Google on this issue because usually if you are facing a weird issue there's a damn good chance others have faced it already. So Google revealed to us this is a common problem and I was told maybe it's better to find an alternative cryptographic solution. Me being, well me :) I don't like being beaten on any technical challenge. During my Google link travels I came across this great Javascript implementation of AES which also has a PHP option. Knowing that Javascript and Actionscript fall under the same standards. I figured rather than find using a different encryption option which is less secure. I quickly ported the Javascript code to Actionscript which took about 15 mins and funnily this post took much longer than this to write :)

Actionscript AES Encryption

So here is a simple example demo with just pure Actionscript AES encryption and decryption with a block cipher of 256 bits.

PHP AES Encryption from Flash

And here is another example demonstrating Actionscript to PHP AES encryption and decryption with the same block cipher of 256 bits. Both demonstrations use the same key so if you change the keys so they do not match then they will not be able to decrypt between each other. Also in this demonstration I post the key with the text to either encrypt or decrypt, you would of course never do this when using AES normally.

I hope this is sunshine on a rainny day for someone out there, you can download the source code from the Lost In Actionscript code.google repository or download an archived version.

This year my talk will be much more exciting than last years, despite this the venue was p-a-c-k-e-d. If you missed it, Grant Skinner is pretty much covering a majority of this content in his FITC session Quick as a Flash. Though this year I am excited to say my talk is on Physics and Behavioral Character Motion. This talk will cover how to animate characters in a life like and improvisational using Actionscript and Flash. Though my talk will be best experienced with having a small amount of Actionscript knowledge. I will try to demonstrate tips and tricks to show how you can get these nice motion effects with very little maths ability and some experience in Flash alone.

My talk will begin by explaining how to look clever by making things move with super easy physics equations and how you can combine this knowledge with the new CS5 physics features and the existing IK stuff. Once we have a few things moving and colliding around properly I will then go on to show how to go about making things move under strategic behavioral motion constraints. This will then start to give some indication of AI with things like formation patterns. Lastly we will take the AI a step further by adding needs, desires and personality to our characters with creative and very simple application of complicated sounding things like finite state machines and decision trees so the behavioral motion makes sense.

I think the talk should be really exciting and hopefully inspiring for anyone attending, says me 'I would go'. Also for free I will be giving attendees the source code from the conference so you can play around at home. I hope to see you there and maybe even have a drink together to talk geek. Mind you had better get in quick because if you are any where in Europe and slightly keen to attend, snatch a bargain with an early bird ticket for FITC Amsterdam because these tickets usually sell like hot cakes.

If you are familiar with the Adobe product line there is inconsistency between Photoshop/Illustrator/Flash/Fireworks/InDesign and support for various subsets of blendmodes which is rather annoying especially for us Flash guys. This project overzealously named the 'Ultimate Blend Mode Collection' is an attempt to standardize this unofficially on Adobes behalf. So marrying up Photoshop designs and Flash layouts with unsupported blendmodes won't be nearly as annoying as has been previously. Further to this, these custom blendmodes allow for control to exaggerate and undo the blendmode effects. What this means is you do not have to double up the blendmode effect by duplicating the DisplayObject instance with the same blendmode you can just multiply the single blendmode effect - simple and quite effecient.

So far I have completed the following custom blend modes :

• Add
• Hard Mix
• Hardlight
• Glow
• Subtract
• Stencil Luma
• Extrapolate
• Difference
• Average
• Lighter Color
• Lighten
• Color Dodge
• Stencil Alpha
• Stamp
• Softlight
• Silhouette Luma
• Silhouette Alpha
• Screen
• PinLight
• Phoenix
• Overlay
• Negation
• Multiply
• Linear Light
• Linear Dodge
• Linear Burn
• Darken
• Desaturate
• Exclusion
• Color Burn
• Alpha
• Darker Color

These are working though have issues of dirty-ness on alpha channels (explained below) for blending layers :

• Reflect
• Freeze
• Heat
• Vivid Light

These custom blend modes are currently in development :

• Color
• Hue
• Luminosity
• Saturation
• Dissolve

How to use custom blend modes

I have only provided a method to use these custom blend modes included with the 'Ultimate Blendmode Collection' for Flex and CS4 users. This is because the PBJ files are compiled into a SWC so you will need to be able to reference SWCs from your FLA or SWF compiler to use the custom blend modes I have mentioned. The syntax to apply a custom blend mode can be achieved via any of the following approaches :

import flash.display.BlendModeShader;
 
myDisplayObject.blendShader = BlendModeShader.SOFTLIGHT;

or

 
import flash.display.BlendModeShader;
import flash.display.shaders.*;
 
myDisplayObject.blendShader = new BlendModeSoftlight();

or you can manipulate the shader

import flash.display.BlendModeShader;
import flash.display.shaders.*;
 
var customBlendMode: BlendModeSoftlight  = new BlendModeSoftlight();
customBlendMode.multiply = 2;
customBlendMode.alpha = 0.5;
myDisplayObject.blendShader = customBlendMode;

Tips for writing your own custom blend modes

Here are some potentially huge gotchas and lovely time savers for those wanna be pixel shader writers (like myself) :

1. Un-multiply alpha before carrying out your shader algorithm. You might already know that Flash pre-multiplies the alpha channel onto the rgb channels this means that if you want to know what the actual rgb components are you will need to do the following :

   void
   evaluatePixel()
   {
          	float2 uv = outCoord();
    
          	float4 src1Rgba = sampleLinear(src1, uv);
           float src1Alpha = src1Rgba.a;
           if(src1Alpha>0.0) src1Rgba.rgb *= 1.0/src1Alpha; //This line un-multiplies the alpha from the rgb channels
   }

2. When your done manipulating your blending layer against the base layer it's more than likely you will need to composite your new blending layer and base layers together while preserving the alpha components. The following should be useful for this :

   void
   evaluatePixel()
   {
          	......
    
           interpolateAlpha = src2Rgba.a;
           inverseAlpha = 1.0-interpolateAlpha;
    
           dst.rgb = src2Rgba.rgb+src1Rgba.rgb*inverseAlpha;
           dst.a = min(1.0, src1Alpha+src2Alpha);
   }

3. Make sure you clamp the components you are altering between 0.0 and 1.0 outside these will give you unusual results between tests made with the Pixel Bender Toolkit and from a published Flash movie. This bit of code ought to fix this :

   void
   evaluatePixel()
   {
          	float3 minRgb = float3(0.0, 0.0, 0.0);
           float3 maxRgb = float3(1.0, 1.0, 1.0);
    
           ......
    
           dst.rgb = clamp(dst.rgb, minRgb, maxRgb);
   }

4. Because Flash premultiplies alpha and I explained earlier about why you may need to un-multiply alpha from the rgb components. It's important to know from this there is a certain degree of losiness and this article by Mario is a great Actionscript explanation (completely unrelated to shaders) of this and is one among many others crying out for help (like me). You may notice in the example below which demonstrates these custom blend modes (or in your own tests) a certain degree of image dirty-ness and this dirty-ness is due to this. I am still working on a way to reduce or get around this - any ideas are certainly welcome - and I've highlighted the shaders above most affected by this.
5. When applying a shader the input sources for the blending and base layer are automatically set. This is great but doesn't allow for setting any further image4 inputs. From my tests if I do try to do this then the Flash Player crashes every time. This is bug and generally bugging me because I can't complete other custom blendmodes based on random math like the Dissolve blendmode

How to get the custom blend modes

I have placed my PBJ, PBK and SWC files on a code.google project. I have also put together a brief getting started page. If you want to get an idea of what's possible using these custom blend modes the simple example below should help to demonstrate this. Also make sure you try out a few of the various base and blending layers I have set up to see what does what.

References

If you are interested in writing your own blend modes I used quite a few sources in order to collect the algorithms used in the examples seen above - here are the main sources :
http://www.pegtop.net/delphi/articles/blendmodes/
http://blog.mouaif.org/?p=94
http://www.nathanm.com/photoshop-blending-math/

So I will describe the usefulness of this JSFL script by first explaining the task or problem at hand it solved for me and hopefully you find it useful also.

The Problem

I had a rather complex vector map (12 MB) in a SWF. Embedding the whole map would be obviously be a BAD idea for loading times but fortunately only very small portions of this map had to be used at any time. Though the suker punch to this idea is that the map isn't grouped to these portions - sigh.

The Solution

So I started with some unavoidable and rather laborious instance naming grinding which I did within Flash. Once I had completed this I had literally 100's of Movieclips associated to Classes that needed to be published and when I hit this I  realised - JSFL I love you! So I distributed these MovieClips to layers then ran this script and viola all the layers are published as swfs using the layer name as the published SWF name - ba da boom ching :)

The way this script works is that publishes any layer that isn't a folder or a guide on the main timeline. Then sets all the layers to guides, then loops through the layers desired to be outputted to SWF then changes them to a normal layer so that only this layer is the only one in the published SWF. Once the publish loop is completed all layers are then set back to their original states.

Rather simple I thought and a huge time saver for mindless SWF publishing. To run this JSFL simply double click it or drag it onto Flash then you will be prompted to select the output directory. Then sit back, relax or even take the evening off and tell your project manager you're hard at work!

You can view the source or download this script here - get it while it's hot!

These shader examples only represent a taste of what's possible using Shaders but I think what's most important is to note these shader examples are really practical unlike a lot of the psychedelic effects you may of seen. For me I especially found that introducing more blend modes has made the process of matching designs in Flash a whole lot easier. I will shortly post a complete list of brand spanking new blend modes for Flash via Shaders with open source code so that everyone can take advantage of these blend modes.

I usually compile SWCs via an ANT buildfile in Eclipse and I will provide this handy script to you as open source code. I like using ANT because it makes it very easy for me to automate the task of creating SWCs then even carrying out other tasks like FTPing.

As well as compiling SWCs and SWFs using ANT I also often publish documentation using these build-files and as my FITC talk briefly covered Javadoc in regard to 'coding conventions' I will also include the source code for how to convert your Javadoc notation to HTML documentation using Flex with asdoc via an ANT build-file.

But before you use these ANT build-files it's important to mention you will need to setup up the appropriate .prefs file to match particular variables to your system.

Here is an example which demonstrates the .prefs file for the SWC ANT build-file

compc 		=/Applications/Flex SDK 4/bin/compc
src    		=/classes
outputFile 	=/swc/TheSWC.swc

Here is the code you may like to use as a reference to compiling your Shader files into a swc

 
package {
	import flash.display.Shader;
	import flash.utils.ByteArray;	
 
	public class Shaders {
 
		[Embed("RippleTransition.pbj", mimeType="application/octet-stream")]
		private static var RippleTransitionData : Class;
 
		[Embed("Bloom.pbj", mimeType="application/octet-stream")]
		private static var BloomData : Class;
 
		[Embed("BlendModeSoftlight.pbj", mimeType="application/octet-stream")]
		private static var SoftLightBlendModeData : Class;
 
		// Transitions
		public static var rippleTransition : Shader;
 
		//Lighting
		public static var bloom : Shader;
 
		//BlendModes
		public static var softLightBlendMode : Shader;
 
		protected static var inited : Boolean = init();
 
		private static function init() : Boolean {
			rippleTransition = new Shader(new RippleTransitionData() as ByteArray);
 
			bloom = new Shader(new BloomData() as ByteArray);
 
			softLightBlendMode = new Shader(new SoftLightBlendModeData() as ByteArray);
 
			return true;
		}
	}
}
 

Download the handy ANT buildfiles here

If you are interested in writing your own ANT build files read up about this here

Despite some early nerves (which I thank you for baring with) the talk covered a lot of practical information regarding efficiency and Actionscript. It's actually the first time I've attended an exclusively Flash conference and 'god damn' I talked at it - pretty cool or terrifying.

If you would like to ask me questions regarding my presentation feel free to do so by email. You can also find out more about my presentation here including references and source code examples.

Lastly I would like to thank Shawn Pucknell the organizer of the FITC. I think everyone who attended would agree that him and his crew have done a fantastic job. He even had time to give me some presentation pointers just before I went up - so thanks mate for going an extra mile. Maybe next time I won't drop the microphone ;)

I've been spending quite a while tightening all the bolts in Tweensy and to get it as efficient and feature packed as possible and its paid off. I've managed to get Tweensy to run much faster than the previous fastest AS3 Tween engine which was TweenLite/TweenMax - wowzas!

Tweensy gets this performance boost compared to other tween engines because #1 it's type safe, has an option to use Object Pooling and utilizes a DoubleLinked list rather than a Dictionary or Array. The final method you can use for speed improvement in Tweensy is by rendering through a BitmapLayer using TweensyFX which circumnavigates the DisplayList and this most often provides a higher frame rate at the penalty of using more RAM - but I think that's acceptable.

Tweensy is type safe due to a collection of tween plugins which allow for targetting commonly tweened Objects such as MovieClip, DisplayObjects, ColorTransforms etc. This means creating new plugins for example Papervision's DisplayObject3D very easy, so DisplayObject3D could benefit from the performance of Tweensy property tweening as well. But regardless of this a fallback plugin allows for Tweensy to tween any public property for any Object.

But don't think Tweensy is just an efficient tween engine it's also feature packed to rival (or beat in my opinion) any other AS3 tween engine available today. And anything it doesn't fulfill feel free to feature request it. I've taken some time to write up a wiki page to help users get started. As well every method and class is commented so you should be able to use the documentation files to find out exactly what's contained within Tweensy library very easily. But if you're new to using a tween library I recommend you to read the getting started wiki page.

Not only is Tweensy feature packed and more efficient than other tween engines, TweensyZero weighs in at about 2.9KB making it an ideal product to use in banners - where every KB counts.

Tweensy also allows for tweening along complicated motion guides otherwise known as bezier curves. One thing that particularly annoyed me while using other tween engines is that the algorithim used for tweening a bezier curve resulted in the DisplayObject accelerating and decelerating as the curve distance increased and decreased. All completely regardless of the ease equation used! You'll get no such problem with Tweensy which gives precise control over tweening on a bezier curve. Other motion guides included in Tweensy include direction and orbit which are cool also but I won't go into any detail as the link above has more information on motion guides with Tweensy.

The Tweensy syntax is very similar to other tween engines and like the great AS2 tween engine FuseKit, Tweensy offers a series of methods which makes tweening otherwise complicated Objects easy. These methods include matrixTo, colorTransformTo, filterTo, functionTo, brightnessTo and contrastTo to name a few. Regardless of these methods the built-in to, from and fromTo methods provide the functionality of these functions - they are there purely for coding convenience. For example using Tweensy for tweening Matrices, ColorTransforms and SoundTransforms then applying them onto other Objects is quite easy.

 
import com.flashdynamix.motion.Tweensy;
import flash.geom.Matrix;
 
var mtx:Matrix = myInstance.transform.matrix;
mtx.tx = 200;
mtx.ty = 200;
Tweensy.to(myInstance.transform.matrix, mtx, 2.0, null, 0, myInstance);

Further to this I will quickly introduce the method functionTo, it is particularly useful if tweening the width and height of a component of some type which requires this to be done via a setSize method.

 
import com.flashdynamix.motion.TweensyGroup;
 
var tween:TweensyGroup = new TweensyGroup();
var onUpdate:Function = function(current:Object):void{
      pane.setSize(current.width, current.height);
}
tween.functionTo({width:pane.paneWidth, height:pane.paneHeight}, {width:200, height:200}, onUpdate, 1);

Further to these cool features Tweensy offers an extras package containing classes to assist with matrix math for Transformations and ColorMatrixFilters. The MatrixTransform class allows for tweening transformations of skewX,skewY around a defined registration X and Y. While the ColorMatrix class allows for applying color transform effects such as brightness, contrast, threshold, colorize etc.

Though I hadn't mentioned it much above, TweensyFX hasn't gone without a few improvements these effects include Bump Mapping, Bulge(dent/indent), pixelation, rgb channel splitting, scan lines and reflection. These FX are mostly low hanging fruit so more exciting effects are to come. In case I hadn't mentioned it somewhere TweensyFX also allows the efficient drawing to a vector layer. As well tweening complicated vector elements such as curves, lines and gradients. This combined with the effects which can be applied onto a BitmapLayer in TweensyFX can result in some really nice results.

I hope you enjoy Tweensy, I and everyone I have introduced it to are, as well those involved in the private beta who have provided great feedback - thankyou. TweensyFX is now the product I will focus on now I consider the Tweensy Original product is maturing nicely. Which is a great stage for this project and for me because this is work I find more exciting.

As well as this update to Tweensy, I have been hard at work (in my limited spare time) on a AIR product code named 'Mr Sprite' which will support TweensyFX with sprite map animations. Mr Sprite can import or create a sprite sheet from a sprite sequence. Then allows for you to define animations sequences on the sprite sheet which can then easily be imported into Flash as a ByteArray at run-time or author-time. With Mr Sprite it will allow you to apply pre-rendered effects with dynamically generated ones at ease in an extremely optimized and efficient manner. I will try to get some examples and a private beta setup for this project soon.

Get Tweensy before it takes over the world at its new home on code.google