Announcing GreenSock Animation Platform (GSAP) v12, now with tangy JavaScript flavor!

Version 12 not only brings more tweenable goodness than ever to Flash, but for the first time ever it does the same for JavaScript too. That’s right. You can use the same animation toolset for your Flash and HTML5 projects. Same API, same user-friendliness, and the same focus on performance and a robust feature set. If you’re a Flash developer, this destroys one of the barriers keeping you from feeling comfortable with HTML5. If you’re a JavaScript developer, this should make advanced animation tasks much simpler and more performant. In fact, it could revolutionize your animation workflow.

Latest news:

Before we dive into what’s new in v12, let’s take a step back and consider the platform as a whole and why it might be worth using in the first place…

Why you'll love GreenSock Animation Platform v12

Crazy fast

Performance is paramount, especially on mobile devices with sluggish processors. Silky smooth animation is the hallmark of any tweening engine worth its weight and GSAP outperforms old “industry standards” by literally 1000%+ under stress. What was jerky and twitchy is now fluid. It’s the result of countless optimizations made to ensure that your interactive projects are responsive, efficient, and buttery smooth. Check out the speed test for a head-to-head comparison.

Freakishly robust

Built for professionals, GSAP is packed with features that make most other engines look like cheap toys. Animate colors, beziers, css properties, Flash filters, arrays, and lots more. Round values, smoothly reverse() on the fly, use relative values, automatically detect and accommodate getter/setter functions, employ virtually any easing equation, and manage conflicting tweens like a pro. Define various types of callbacks, tween in seconds or frames, build sequences effortlessly (even with overlapping tweens), repeat/yoyo and more.


Flash, HTML5, jQuery, Canvas, CSS, new browsers, old browsers, RequireJS, EaselJS, mobile, and more – GSAP gets along with them famously. Use your favorite tools without jumping through endless hoops to ensure compatibility. The JS flavor even accommodates various transforms (scale, skew, rotation, x, and y) in modern day browsers plus IE back to version 6 without requiring clunky browser prefixes and hacks. We worry about compatibility so that you don’t need to. Another headache solved.

JavaScript, AS3, and AS2

Jump back and forth between Flash and JavaScript/HTML5 projects without giving up your favorite animation tools. No more wrestling with lackluster JavaScript capabilities or cumbersome APIs. This brings the fun back to scripted animation.

Lightweight & expandable

Modular, flexible, and ultra-efficient, its plugin architecture keeps the core engine tight while allowing virtually any feature to be added via optional plugins. TweenLite packs an amazing amount of power into a surprisingly small package (under 7kb in all flavors).

No dependencies

The GreenSock Animation Platform isn’t built on top of any 3rd party tools like jQuery (although it works great with jQuery as a selector). This approach minimizes load times and maximizes performance.

Advanced sequencing

You’re not limited to “one-after-the-other” sequencing; have animations overlap as much as you want. Nest timelines inside other timelines. Insert gaps, callbacks, labels, staggered tweens, and more. You get precise control over timing and unprecedented flexibility to create expressive animations with minimal code.

Dedicated support

Everybody needs a little help sometimes. We’ve got your back. When deadlines are looming and you can’t figure something out, hop over to to get your GreenSock-related questions answered in the forums. With a proven track record of active participation by the author and an army of fellow users, GreenSock tools are unlike most open source projects that stagnate or offer zero support.

Animate anything

That’s right. Anything. No predefined list of properties to choose from. Any numeric property of any object can be tweened, and if the property needs special handling (like colors, filters, non-numeric values, etc.), chances are there’s a plugin that will do it. If not, one can be created. The possibilities are endless.

Overwrite management

Another rarity among animation engines is the process of identifying conflicting tweens and handling them elegantly. This all happens automatically under the hood in GSAP, plus there are some advanced options if the default behavior isn’t what you prefer. GSAP protects you from conflicts that cause other engines to become frustratingly glitchy.

Learn fast

Frameworks are a dime-a-dozen, but precious few offer solid documentation, tutorials, interactive examples, a detailed “getting started” guide, and dedicated forums. You don’t have to be a genius to get up and running. There are plenty of resources here to guide you.

Permissive license

Completely free for everything except a very specific type of commercial use (reselling to multiple customers), GreenSock’s license makes it extremely accessible and business-friendly while providing a small funding mechanism to sustain ongoing support, enhancement, and innovation. The web is littered with abandoned “open source” projects, but GreenSock has a years-long track record of commitment to the platform. This unique licensing model is a key component of that sustainability. Learn more about licensing.

What exactly is it?

The GreenSock Animation Platform is a suite of tools for scripted animation. It includes:

  • TweenLite: the core of the engine which handles animating just about any property of any object. It is relatively lightweight yet full-featured and can be expanded using optional plugins (like CSSPlugin for animating DOM element styles in the browser, or BlurFilterPlugin for animating BlurFilters in Flash, etc.)
  • TweenMax: think of it like TweenLite’s beefy big brother; it does everything TweenLite can do plus non-essentials like repeat, yoyo, repeatDelay, updateTo(), etc. It automatically activates many common plugins for you too. The focus is on being full-featured rather than lightweight.
  • TimelineLite: a powerful, lightweight sequencing tool that acts like a container for tweens, making it simple to control them as a whole and precisely manage their timing in relation to each other. You can even nest timelines inside other timelines as deeply as you want. This allows you to modularize your animation workflow easily.
  • TimelineMax: extends TimelineLite, offering exactly the same functionality plus useful (but non-essential) features like repeat, repeatDelay, yoyo, currentLabel(), and many more. Again, just like TweenMax does for TweenLite, TimelineMax aims to be the ultimate full-featured tool rather than lightweight.
  • Extras like easing tools, motion paths, plugins, blitting tools, and more

Dive in

Download the code

Visit the dedicated JavaScript page

Read the Getting Started with JavaScript Guide

JavaScript speed comparison: see how much better TweenLite performs under pressure than other industry standards like jQuery, MooTools, YUI, and Zepto.

Full documentation: every property and method has been documented. The docs are available in the downloads and online [ ActionScript | JavaScript ].

Get help in the forums.

What’s new?

In addition to the brand new JavaScript flavor, there are plenty of other enhancements to the ActionScript version that the Flash community can get excited about. If you’ve never used TweenLite or TweenMax before, you can skip this section altogether.

One of the goals of this release was improving ease of use, particularly with sequencing and working with arrays. The API is less restrictive and things just work. You can now tween arrays of objects with a single tween. You can pass arrays to killTweensOf(). You can pass callbacks, labels, tweens or arrays to the add() timeline method (which replaces append(), insert(), appendMultiple() and insertMultiple()). There are new convenience methods that make sequencing much more concise. You can accomplish the same tasks with literally 50% less code in many cases. There are scores of little improvements that make it even more enjoyable to use.

As always, performance is a huge priority. All of the easing methods have been further optimized and there are many under-the-hood refinements that ensure blazing fast speed. In general, performance was prioritized over small file size except in TweenNano where file size is of paramount importance.

Top 10 improvements

  1. The entire engine has been made more array-friendly.
    //notice the target is an array[mc1, mc2, mc3], 1, {alpha:0});
    var tl:TimelineLite = new TimelineLite();
    //previously only appendMultiple() and insertMultiple() handled arrays. The new add() method combines the functionality of append(), insert(), appendMultiple() and insertMultiple()
    tl.add( [tween1, tween2, tween3] );
    //kill all tweens of mc1, mc2, and/or mc3
    TweenLite.killTweensOf([mc1, mc2, mc3]);
  2. You can tween function-based values, not just properties. For example, if you have a width() method that is used for both getting and setting (when no parameters are passed in it acts as a getter, and when a parameter is passed it acts as a setter).
    var curWidth:Number = myObject.width(); //gets
    myObject.width( curWidth + 10 ); //sets, 1, {width:300}); //tweens

    The engine even recognizes “get” and “set” methods automatically, so for example, if your object has getCustomProp() and setCustomProp() methods, you can tween the value like this:, 1, {setCustomProp:10});

    TweenLite will see that it’s a function and swap out “set” for “get” in the method name to get the starting value. This also works for methods that don’t have “get”/”set” in the name like jQuery-style methods (width(), height(), etc.)

  3. There’s a new SlowMo ease that makes it much easier to create a slow-motion effect. For example, you could have text fly in quickly, decelerate and then move at a linear pace before accelerating out of frame. Previously you could sequence 3 tweens (an easeOut, then Linear.easeNone, then easeIn), but the eases didn’t transition smoothly (you’d see a sudden shift in pace at the joints). The new SlowMo ease can be configured easily. Control the proportion of the tween that moves things in a linear fashion (like 0.5 if you want half of the tween to be linear, 0.8 for 80%, etc.) as well as the strength of the ease in/out. Here is an interactive example, courtesy of Carl Schooff:

    Carl did a fantastic job demonstrating and explaining SlowMo in his video at I highly recommend checking it out.

  4. To make sequencing less verbose, convenience methods were added to TimelineLite and TimelineMax that append TweenLite instances using a shorter syntax. You can chain things together too.
    //OLD (still works, but is deprecated):
    var tl:TimelineLite = new TimelineLite();
    tl.append(, 1, {x:100}) );
    tl.append( TweenLite.from(mc, 1, {y:-100}), 0.5);
    tl.appendMultiple( TweenMax.staggerTo([mc1, mc2], 1, {alpha:0}, 0.2) );
    var tl:TimelineLite = new TimelineLite();, 1, {x:100})
      .from(mc, 1, {y:-100}, "+=0.5")
      .staggerTo([mc1, mc2], 1, {alpha:0}, 0.2);

    Methods that were added are: to(), from(), fromTo(), staggerTo(), staggerFrom(), staggerFromTo(), call(), and set().

  5. You can now add global “tick” event listeners that call your own method(s) immediately after all the tweens/timelines update (on each frame).
    TweenLite.ticker.addEventListener("tick", myMethod);

    This can be a boon for games that want to run certain logic after each refresh.

  6. OverwriteManager’s functionality is now baked into TweenLite, whose new default mode is “auto” (just like TweenMax). In 98% of the scenarios, this is what people preferred anyway. (Previously TweenLite’s default mode was “all” which killed all tweens of the same target immediately.) You no longer need to call OverwriteManager.init(). There is no OverwriteManager now. Overwrite modes are defined using Strings (although legacy code will still work with integers or booleans). An example of the new syntax is:, 1, {x:100, overwrite:"all"}); but again, “auto” mode is the new default. You can even change the default using the static .defaultOverwrite property.
  7. There’s a new TweenLite.fromTo() method that allows you to define both the starting and ending values (previously only TweenMax had a fromTo() method.)
  8. Most methods return the instance itself so that you can chain them if you want. Like:
    //chain as much as you want
    myTimeline.add( ... ).add( ... ).timeScale( ... );
  9. Completely rewritten BezierPlugin with a vastly improved proprietary algorithm for drawing Beziers through an array of points/values naturally (even define a “curviness” value), a new “timeResolution” feature that ensures your object moves along the Bezier with the appropriate timing, and more accurate “autoRotate” (previously called orientToBezier) functionality. Plus you can pass in regular cubic or quadratic Bezier values if you prefer. Even use the static BezierPlugin.bezierThrough() method to have the plugin calculate the anchors and control points through the values you provide in either cubic or quadratic format so that you can, for example, draw the lines yourself using Flash’s graphics API or a <canvas> element. Ultimate control and freedom. Click on the “EXAMPLE” button next to “bezier” in the Plugin Explorer below to play with the new options interactively and see the sample code:
  10. You can now self-reference the tween/timeline in the onCompleteParams, onUpdateParams, onStartParams, onReverseCompleteParams, or onRepeatParams using the special keyword “{self}”. For example:, 1, {x:100, onUpdate:reportTime, onUpdateParams:["{self}"]});
    function reportTime(tween) {
        trace("time: " + tween.time() + ", target: " +;

    This works with all callbacks in TweenLite, TweenMax, TimelineLite, and TimelineMax.

To see the rest of the 40 changes, click here.
  1. There are 5 new eases: Power0, Power1, Power2, Power3, and Power4 that make it simpler to choose the strength of the easing that you want. These are identical to their less intuitively named Linear, Quad, Cubic, Quart, Quint (and Strong which is the same as Quint) counterparts. All of these eases are accelerated inside TweenLite and TweenMax for optimal performance. So instead of Quad.easeIn, you can use Power1.easeIn. For Strong.easeOut, you can use Power4.easeOut, etc. That way, when you are experimenting with the effect you want, you can simply change the number.
  2. play(), reverse(), and pause() accept parameters that allow you to skip to a certain spot in the tween/timeline and optionally suppress events when doing so. You can omit the parameters and it will use the current time (as it always has). For example:; //plays from current time; //plays from 2-seconds into the tween
    tween.reverse(); //reverses from current time
    tween.reverse(3); //reverse from the 3-second point
    tween.reverse(0); //zero is a special value for reverse() that tells it to jump to the very end

    They also accept a 2nd “suppressEvents” parameter that indicates whether or not callbacks/events are triggered as it does the initial skip to the time indicated. Think of it like picking the needle on the record player up and moving it to the new position rather than dragging it. If the tween/timeline is at time:1 and you do play(5) and there are callbacks between those times (like at time:4), you can tell it to ignore those when it jumps to 5.

  3. To define a relative value instead of absolute, preface the value with “+=” or “-=” and make it a String. Previously, you only needed to cast as a String, but since JavaScript often uses values that contain characters, like “150px”, casting as a String won’t suffice. So, for example:
    //OLD, 1, {x:"100"});
    //NEW:, 1, {x:"+=100"});
    //OLD:, 1, {x:"-100"});
    //NEW:, 1, {x:"-=100"});

    In ActionScript the old way still works, but it is deprecated.

  4. New TimelineLite.exportRoot() method that makes it simple to grab all the animations currently on the global timeline and wrap them in a TimelineLite instance that can be paused, resumed, reversed or its timeScale could be changed, all without affecting future tweens/timelines that are created. For example, imagine a game that uses GSAP for all of its animations and at some point during the game, the developer wants to slow everything down to a stop (tweening the timeScale) while at the same time animating a new popup window into place:
    var tl = TimelineLite.exportRoot();, 0.5, {timeScale:0});
    //this tween isn't affected because it's created after the export.
    TweenLite.fromTo(myWindow, 1, {scaleX:0, scaleY:0}, {scaleX:1, scaleY:1});

    You could then re-animate things when you’re ready by tweening the timeScale back to 1. Or you could use exportRoot() to collect all the animations and pause() them and then animate the popup screen (or whatever). Then resume() that instance or even reverse(). Keep in mind, however, that completed tweens/timelines are removed from the root (for automatic garbage collection), so if you exportRoot() after a tween completes, it won’t be included in the export.

  5. All the old getter/setter properties like totalTime, duration, paused, timeScale, progress, reversed, etc. are now methods like totalTime(), duration(), and paused() methods for better compatibility with JavaScript and slightly better memory efficiency. It also allows for passing extra parameters in some cases like totalTime(time, suppressEvents). If you don’t pass a parameter to the method, it acts as a getter. If you do pass a parameter, it acts as a setter. For example:
    myTween.duration(3); //sets
    var dur:Number = myTween.duration(); //gets
  6. There’s a new static TweenLite.getTweensOf() method that can be very useful. It returns an array of tweens of a specific target.
  7. TimelineLite and TimelineMax’s insert() and append() methods are deprecated in favor of a new add() method which accepts tween instances, timeline instances, arrays, strings and function references so that you can easily add labels or callbacks or arrays of tweens. For example:
    myTimeline.add( TweenMax.staggerTo(...) );
    myTimeline.add( "myLabel" );
    myTimeline.add( myCallback );
  8. You can now change the timeScale() of TweenLite instances (previously, timeScale was only available on TweenMax, TimelineLite and TimelineMax). You can even tween it using another tween:
    var tween1 = new TweenLite(mc, 10, {x:1000});, 1, {timeScale:0.5}); //slow to half-speed, 1, {timeScale:2, delay:2}); //then speed up to double speed
  9. Now onReverseComplete will fire whenever the tween is played backwards all the way to the beginning. Previously, if you nested a tween with an onReverseComplete in a TimelineLite and then reversed the TimelineLite, the tween’s onReverseComplete wouldn’t fire because the tween itself wasn’t technically reversed. The new functionality seems more intuitive for most users I think.
  10. Simplified the syntax for defining roundProps as a comma-delimited String instead of an array, although the old syntax still works in AS3/AS2.
    //OLD:, 1, {x:10, y:5, roundProps:["x","y"]});
    //NEW:, 1, {x:10, y:5, roundProps:"x,y"}); 
  11. You can define overwrite modes with Strings instead of numbers – this seemed more intuitive. Example:
    //use any of these: "auto" | "all" | "none" | "concurrent" | "allOnStart" | "preexisting", 1, {x:0, overwrite:"all"}); 

    For now, numbers will still work (for backwards compatibility).

  12. The easing methods have been revamped and are full-fleged classes that extend a common Ease class. There’s no need for FastEase anymore – the common ones are baked-in. And instead of easeParams, you can use the new config() method on the eases that accept extra parameters (although easeParams still works – it is just less elegant). For example, Elastic accepts 2 parameters to define the amplitude and period which you could set like this:
    //config() replaces the old "easeParams" special property, 1, {x:100, ease:Elastic.easeOut.config(1, 0.5)});
  13. All tweens and timelines have a new eventCallback() method that allows you to set (or get) event callbacks anytime like “onComplete”, “onUpdate”, “onStart”, “onReverseComplete”, or “onRepeat”. This is functionally equivalent to defining them in the constructor’s vars parameter like {onComplete:myFunction}, but the new method delivers greater flexibility because you can change things after the instance has been created (anytime actually) or even remove event callbacks.
    //the following two lines produce IDENTICAL results in terms of defining the onComplete and onCompleteParams:
    var myAnimation = new TweenLite(mc, 1, {x:100, onComplete:myFunction, onCompleteParams:["param1","param2"]});
    myAnimation.eventCallback("onComplete", myFunction, ["param1","param2"]);
  14. Now that the entire engine is array-friendly, TweenMax’s allTo(), allFrom(), and allFromTo() methods aren’t as useful as they were previously, although the staggering feature is quite convenient. That’s the only reason to keep them around. Therefore, they have been renamed staggerTo(), staggerFrom(), and staggerFromTo() to make their functionality more clear. However, there are still aliases to allTo(), allFrom() and allFromTo() in place for backwards compatibility. Those methods have been deprecated.
  15. The killVars() method of TweenLite and TweenMax has been removed in favor of a common kill() method to which you can optionally pass vars and/or a target for precise control over exactly what gets killed. You can do any of the following:
    //kills the whole tween
    //kills only the "x" and "y" parts
    myTween.kill({x:true, y:true});
    //kills all the tweening properties for myTarget (only useful for tweens of arrays like[mc1, mc2, mc3], 1, {x:0});
    myTween.kill(null, myTarget);
    //kills only the "x" part of tweens of myTarget
    myTween.kill({x:true}, myTarget);
  16. The complete parameter of killTweensOf() has been removed because it created confusion when only specific properties were defined using the vars parameter. For example, if the old method was called like TweenLite.killTweensOf(myObject, true, {y:true}), was the whole tween supposed to be forced to completion or only the y property? Adding the ability to only force the y property to completion would require too much kb (file size) and it wouldn’t solve the confusion issue, so I removed the parameter altogether. If you want to force all the tweens of a particular object to completion, simply use the TweenLite.getTweensOf() to get an array of them, and loop through it and do myTween.duration() ) first. The revised method works just like the old one:
    //kills ALL tweens of myObject immediately
    //kills only the "y" and "x" portions of any tweens of myObject
    TweenLite.killTweensOf(myObject, false, {y:true, x:true});
  17. There is a new smoothChildTiming property for TimelineLites and TimelineMaxes which controls whether or not child tweens/timelines are allowed to shift around (change their startTimes) when you do things like reverse() them or alter their timeScale, etc. Currently (in v11), it acts like this is true, but I think it caused some confusion for users. So I’m changing it to false in v12 so that tweens remain locked into place unless you specifically change their startTime. Say, for example, you’ve got a TimelineLite with a child tween that is 75% done and you reverse() that child tween. With smoothChildTiming set to true, that would pick the tween up and move it so that it is 25% done (thus as it continues playing, it has that 75% left to go, making it look natural). This makes total sense when the timeline is perpetually moving forward (like on the root timeline) but in TimelineLite and TimelineMax instances, users seem to want to have very specific control there rather than having things move around on them “automagically”. I figured if they reverse() the tween nested in a TimelineLite, they’d probably expect its startTime to remain consistent regardless of where the playhead is. Thus, smoothChildTiming defaults to false.
  18. TweenNano recognizes the startAt special property, so you can essentially do fromTo() tweens like:, 1, {x:100, y:200, startAt:{x:0, y:0}});
  19. TweenNano has many of the new enhancements that TweenLite and TweenMax got, like:
    • Tween arrays
    • Automatically recognizes getter/setter methods, so you can do things like, 1, {mySetterFunction:5});
    • There’s a new TweenNano.defaultEase property that you can set.
    • There’s a TweenNano.ticker that you can addEventListener(“tick”, myFunction) to in order to be notified every time all tweens have been updated.
    • TweenNano.killTweensOf() accepts either an array or an object, so it is easier to kill tweens of multiple objects with one call, like TweenNano.killTweensOf([mc1, mc2, mc3]);
  20. TweenNano’s default overwrite mode is now “none”. To cause a tween to overwrite all other tweens of the same target, pass overwrite:”all” in the vars object like, 1, {x:100, overwrite:"all"});
  21. TweenNano.kill() accepts an optional target parameter that allows you to specify a particular target (or array of targets) to kill inside the tween. This is only helpful with tweens of arrays, like:
    var tween =[mc1, mc2, mc3], 2, {x:100});
    tween.kill(mc2); //kills only the mc2 portion of the tween
  22. What used to be called currentTime is simplified to time()
  23. Changed the name of the com.greensock.core.TweenCore class to Animation because it is more intuitive.
  24. Removed onInit and onInitParams special properties (it’s doubtful many people used them anyway)
  25. The complete() method has been removed from all classes (you can accomplish the same thing with Seemed like complete() wasn’t used very often anyway. Dead weight.
  26. The clear() method of TimelineLite/Max doesn’t accept a parameter anymore because the functionality is duplicated in the remove() method and it just created confusion and redundancy. Plus it was almost never used from what I can tell (I doubt anyone will even notice its removal).
  27. Removed prepend() and prependMultiple() methods in TimelineLite/Max because they seemed like dead weight. You can still accomplish exactly the same things using other methods. Shaved some kb and tightened up the API.
  28. Removed TimelineLite/Max’s killTweensOf() method because the functionality is included in the new kill() method (myTimeline.kill(null, target)). TweenLite.killTweensOf() and TweenMax.killTweensOf() are unaffected – they’ll stick around (they’re used quite often).
  29. There are some public properties and methods that are intended to be used only by the tweening engine itself (the properties are exposed for performance reasons) and they use a prefix of “_”. Previously a “cached” prefix was used, but the underscore is more concise and it’s a widely-accepted way of declaring off-limits public variables.
  30. Improved, in-depth ASDocs

A note to those updating legacy ActionScript code

With thousands of developers relying on the GreenSock Animation Platform, backwards compatibility is definitely something we strive to maintain. However, in some rare cases the benefits of changing part of the API for a greater purpose looking forward trumps backward compatibility. In most cases, you should be able to swap v12 in for v11 and everything will work great, but there are a few exceptions which are flagged in the expanded list above with a caution icon (). Don’t forget to expand the list so that you can see all 40 items.

FAQ (click to view answer)

  • Twitter
  • Facebook
  • Digg
  • StumbleUpon
  • Yahoo! Buzz
  • Google Bookmarks
  • RSS
  • LinkedIn
  • Reddit

Comments (107) RSS

Posted by Gurtej on May 15, 2012


This is absolutely brilliant. I think this is by far the most remarkable release from Greensock. Brilliant work and I cant wait to check it out. Keep up the best work!.


Posted by William on May 15, 2012

You may just have saved my career with the HTML5 update. Thank you so much.

Posted by Mike Oscar on May 15, 2012

You have done it again.
regards Mike :)

Posted by sina on May 15, 2012

oh my goddd . this is great , I’ve been waiting for such library for the long time, i don’t know what to tell , the things that you do in here nobody does before . congratulation and thank you

sina n.

Posted by Luis on May 15, 2012

Jack, superb work.

You gave another life for the HTML, thanks for this great platform.


Posted by Weavermedia on May 15, 2012

Remarkable indeed. Tools like Hype are a nice start to Flash-like HTML5 displays but Greensock has the maturity and community to really succeed.

Posted by harry on May 15, 2012

man awesssssssommmmmmmeeeeeeeee work ….. i realyyyy love u man … GreenSock rocksssssss….. love to wear GreenSock…. love it love it love it love it love it love it…………. thnx man…… this will make the huge diffrence in HTML5 eraa

Posted by emrah atilkan on May 15, 2012

what can i say. it is beyond any good words. Congrats Jack.

Posted by Ramiro Araujo on May 15, 2012

Contrats on the release! I’m assuming this will be the new de-facto standard for animations :D

[...] news for those who are looking to get into JS animation. GreenSock, the creator of excellent libraries like TweenLite and TweenMax, has just released their new [...]

[...] news for those who are looking to get into JS animation. GreenSock, the creator of excellent libraries like TweenLite and TweenMax, has just released theirnew [...]

Posted by vamapaull on May 15, 2012

This is awesome!! Congratulations on the release!

Posted by michael barsotti on May 15, 2012

Thank you

Posted by Richard Clark on May 15, 2012

Excellent! The GreenSock AS libraries were a lifesaver when I was building commercial training in Flash. Now I can introduce my HTML5 students to them.

[...] finally here! GreenSock has just released the GreenSock Animation Platform v12 BETA (GSAP v12). The big news is that GSAP has now been ported to JavaScript. I know tons of you have [...]

Posted by Brennan on May 15, 2012

Oh. My. Goodness. You are insane! You are a God of programming Jack. Great work. Can’t wait for the membership for the javascript comes out. Definitely will renew my membership for it!!

Posted by Ted Kusio on May 15, 2012

Awesome, and brilliant.
I’ll spread the word, and hope to play with this soon.

Posted by Chris Calabrese on May 15, 2012

(crying tears of joy) Amazing. Wish I was smart like Jack.

Posted by David Espurvoa on May 15, 2012

How wonderful! Jack, you are the man!!!!
I am telling all my Flash students about this!

Posted by rSavage on May 15, 2012

HOLY TASSLED BAZOOMBAS! I was just working on some crappy jquery animations and almost peed when I pondered the thought of using the familiar greensock tweening platform instead!

Posted by Calvinalibra on May 15, 2012

Wow this is awesome!

Posted by Pier on May 15, 2012


Posted by Tim on May 15, 2012

Simply amazing. Been waiting for this since the announcement. Now moving from Flash to HTML5 is much easier. Same syntax. Thanks Jack!

Posted by Doug Burnett on May 15, 2012

Been looking forward to this for a long time. I was excited just about using the TweenLite syntax. Didn’t realize it would be 1000x better!! Congrats Jack. You did it again!

Posted by ian hobbs on May 15, 2012

Brilliant work Jack – Just in time for the overhaul of my client sites!!!

Posted by Pete on May 15, 2012

Jack, you’ve really contributed something special here. What an amazing release. I’m sure you’re excited to see how v12 will change the game — and there is no doubt it will. You are an incredible central figure in the Flash community, and now your amazing tools will be known by every single web developer. Your contributions have helped push the web forward. It’s incredible that one developer could have such a huge affect – sincere thanks and congratulations!

Posted by Pellumb on May 15, 2012

Great work, Jack !! I’ve been using TweenLite for a long time now ( for as3 ), and you keep coming with new and impressive things. Now that i also started using js a lot, this will surely be very helpful. Thanks for all this awesomeness :)

Posted by Steve Jones on May 15, 2012

Well, I knew it would just be a matter of time until you treated the HTML world to your magic that made Flash development such a pleasure. I’m really excited about these. Haven’t opened FlashBuilder in about 4 months (sign of the times) but it will be really good to start using TweenLite again. Thanks Jack – super stuff!!

Posted by fenixkim on May 15, 2012

Wow, wow, wow, Congrats Jack.

Posted by Zync on May 15, 2012

Mind = Blown!!!

I’ve been putting off HTML for ages as it never had anything even remotely as awesome as the Greensock platform, but now that it’s here you’ve single handedly given me motivation to get cracking with HTML Apps and Games.

Kudos Green Man, you’ve done it again!! :D

Posted by behigh on May 15, 2012

super cool !!!

Posted by ed on May 15, 2012

Amazing, can’t wait to start using it!!!

Posted by Fily on May 15, 2012

WOW! It’s just awesome! From other world!

Posted by qingzhizhu on May 15, 2012

I like it!!

Posted by Madhu Rakhal Magar on May 15, 2012

I love it.

Posted by mathias valentin on May 15, 2012

Download js = Ohhh yeah!!!! Awesome good news.. Thanks greensock!

Posted by Pieter Helsen on May 15, 2012

Jack… As ever man, you are the very best of the best when it comes to animation.

Leave it up to the flashers to teach HTML5′ers to tween :)

Posted by LDowding on May 16, 2012

I remember suggesting this a couple of years ago! You are an amazing developer dude.

Posted by Niklas on May 16, 2012

Holy crap!
This truly looks amazing!!

Posted by Tinku TR on May 16, 2012

Great step. I was looking for a TweenMax alternative to my js projects.

Posted by Adrian Parr on May 16, 2012

Great stuff Jack! This is going to make a LOT of people happy. :-)

Posted by richbrill on May 16, 2012

Having used your greensock TweenLite library in the past for AS3 animation/Papervision 3D, I can honestly say this will make working with CSS 3 transitions so much easier for everyone. Having looked at the speed tests I can’t recommend the sheer speed of this library highly enough! Great job Jack!

[...] Jack “Green Sock” Doyle has just released version 12 of his GreenSock Animation Platform (GSAP) for Flash AS2 and AS3, but the big announcement is that it now supports JavaScript [...]

Posted by Josh on May 16, 2012

Building a new HTML5 eLearning engine and have been eagerly awaiting this release. Excellent!

Posted by Vini on May 16, 2012

Hey, Jack I’m following from flash8 days, and you have always contributed something to the community. I do find a slight lag thoughbut definitely its better than, and the tuning will even make it finer. Thank you for the awesome work

Posted by Ted Kusio on May 16, 2012

Would love to see some mobile device benchmarks/tests/samples, especially compared w/ CSS3, and Android vs. iOS.

Posted by michael barsotti on May 16, 2012

Regarding the new JS library. This is what I like about Greensock (Keep in mind I haven’t used the javascript collection yet, so this comment is just based on reading the information provided above) Y’all could have, very easily, just supported the latest browsers, but you make this backwards compatible to IE6! That’s ‘real-world’! Our company is developing “modern” sites but we still have to support IE6 (for Gods sake). This is suddenly very usable. Thank you.

Posted by Evan on May 16, 2012

Talk about revitalizing! This makes it so worth being a member and keeping up with GreenSock! Thanks for the hard work.

[...] UPDATE: SlowMo Ease is now freely and publicly available in all of the GSAP v12 downloads. [...]

Posted by emrah on May 16, 2012

Still need a selector engine! Don’t use Jquery(min 32kb) as a selector. Use sizzle.js(min 4 kb). Sizzle is the exactly the same as jquery selector. jquery uses sizzle, both created by the same man (J. Resig).

Posted by Boris on May 16, 2012


Posted by jim on May 16, 2012

Looks awesome!

If possible, please add TweenJS, JSTween and other Javascript animation engines to the Speed Comparison with Greensock JS.

Posted by Bob Finger on May 16, 2012

Yeah, what they said.

You are a Jedi, no question.

Posted by Stacey Reiman on May 16, 2012

Awesome Jack!

I look forward to playing around with some of the new stuff.

Posted by Gio on May 16, 2012

Just glorious. Great job!!!

Posted by buz on May 17, 2012

You remind me of your Father… you rock, Jack!

Posted by Shawn on May 17, 2012

Great stuff….as always!!

Posted by P Thompson on May 17, 2012

Dood. Thank you!!!!

Posted by Tyler Jones on May 17, 2012

FANTASTIC!!! This is EXACTLY what the Javascript world needs! Javascript now has the greatest animation platform ever written!

Posted by Ollie Olarte on May 18, 2012

I’ve always said “i will learn javascript the day someone helps me understand it and there is some sort of tweening platform as tweenlite to easily achieve effects” that day has come!!! THANKS TO YOU JACK!

Posted by John Morton on May 18, 2012

Jack… the JS library is so sweet. Thank you for the hard work on this!

Posted by Fidel on May 21, 2012

Nice work jack! Are you working on a loader class for JS – similar to the AS one?

Posted by Jack on May 21, 2012

Fidel, there aren’t any plans to create a loading solution at this point for JS, but you never know what the future may hold :)

Posted by Fidel on May 22, 2012

I guess that’s fine since we have!/CreateJS or rather preloadjs. It would be nice to have one js framework for preloading, tweening and use advance selectors without including another framework like jQuery :)

BTW: why isn’t tweenjs in your speed comparison page?

Thanks again Jack and keep up the great work!

[...] demo of banner-style javascript animation for you. The main player here is TimelineLite from GreenSock’s tangy Javascript port. I created this demo to try to prove to myself [...]

Posted by Pipo on May 23, 2012

Awesome! This is really great!

I just released a JavaScript Tutorial (in german), if somebody is interested:

Posted by Sharp on May 24, 2012

Goooood work!

Posted by hoc thiet ke thoi trang on May 24, 2012

wow, amazing, thanks

Posted by Ely on May 25, 2012

OMG!!! So far I’ve tried the JS flavor on several web templates and the results are quite impressive! I’d like to know if a css blur filter plugin will be available any time soon. Kudos and Thank yous

Posted by Ely on May 25, 2012

Correction: I meant OMG!!! This joint is awesome!!! …

Posted by Jack on May 25, 2012

Ely, there may eventually be a blur plugin for JS that utilizes canvas, but that isn’t in the works quite yet. There are some other features and enhancements that are more pressing at the moment, but we’ll keep the blur idea in mind. Thanks!

Posted by Jack on May 25, 2012

Fidel, I just added TweenJS to the speed test. Thanks for the suggestion.

Posted by flashindonesia on May 26, 2012

This is awesome man !!!!!!

Posted by Iwan on May 26, 2012

jack, i’m using your tweening engine for as3 projects since a long time. to now have the same ammount of control and performance in html is just wonderful. thank you!

Posted by Herman Taniwan on May 27, 2012

awesome !

Posted by Bob on May 27, 2012

¡¡¡Simplemente espectacular!!!

Gracias de nuevo…


Posted by BenB on May 29, 2012

Love the way it toggles between whichever tween method is going to be the fastest. Rock solid rotations in all the majors – preferring to look forward but handling the past too – super nice!

[...] lots of the things we have done in Flash can now be accomplished with other languages. The birth of GSAP12 offers Flash developers a HUGE opportunity to transfer their existing skills over to the [...]

Posted by YopSolo on May 30, 2012

It will be fun to see html-zealot-flash-hater loving to work like a flash dev with this awesome tool.

congratz !

Posted by Sumit on May 30, 2012

It is really powerful tool to animate object.

Posted by Kaleb Wyman on May 31, 2012

The v12 JS version is amazing — thanks for sharing your hard work, Jack! This is easing the transition from ActionScript over to JavaScript quite well.

Posted by lizeqiangd on June 1, 2012

Awesome jobs..

Posted by Michael on June 4, 2012

Released a javascript/Jquery and TimelineMax animation sample page here:

Enjoy and thanks Jack for all the goodies!

Posted by Brent Lagerman on June 5, 2012

I get why you can’t do everything in CSS3 that you can do in greensock, but couldn’t you write some code to detect when a certain instructions are achievable with css3 and then render using that method? I’m sure this is much easier said than done, but not utilizing the graphics processor seems like a killer to me, does javascript not have any access to the GPU ? will that change in the future?


Posted by Jack on June 6, 2012

I wish it were that easy, Brent, but from what I can see, CSS3 transitions just don’t provide enough flexibility to integrate well with the tweening engine. Everything in the platform is built so that you can pause(), resume(), seek(), reverse(), and pretty much have TOTAL control of ANY animation and use various easing effects. What you’re asking for would be very doable if all the system was supposed to do was go forward, finish the tween, and move on. But in this modern age where complex animations are commonplace and developers want tools that give them immense amount of control, CSS3 transitions fall apart. Sure, I could check and see if each particular animation is “simplistic” (no special non-CSS3-friendly easing or special handling of properties, etc.) and then fire off a CSS3 transition but then what if that tween gets nested in a timeline that the user pauses and then tweens its progress? What about jumping to certain spots in the animation? I believe there may be some funky workarounds to calculate the jumping and manually override things, but those all involve JavaScript and making function calls that would ultimately degrade the performance to being even worse that pure JS.

Check out the speed test at and compare Zepto’s performance to TweenLite’s. Zepto apparently uses ONLY CSS3 transitions (and consequently doesn’t work in IE at all). Its animation capabilities and flexibility are nowhere close to TweenLite’s, but even for these simple tweens notice that TweenLite is still faster (at least on the systems I have tested). I think there is a common perception out there that CSS3 is GPU-accelerated and therefore exponentially faster than raw JS animation but from what I’m seeing there, it ain’t the case.

Anyway, I’ll certainly watch for ways to integrate techniques that deliver the best performance and flexibility. Maybe CSS3 transitions will indeed become viable at which time I’ll leverage them. And yes, I believe parts of JS are indeed getting GPU acceleration, like canvas. I suspect that trend will continue and JS will only get better and faster.

Thanks for asking the question – I think a lot of people were wondering the same thing.

Posted by Echo « on June 8, 2012

[...] based on and is an evolution of the Greensock ‘ball dropping’ demo example that comes with the GSAP JavaScript libraries. It’s using TimelineMax for the animation and Adobe Edge’s bindSymbolAction for the [...]

Posted by Michael on June 10, 2012

Are there plans to integrate ThrowProps plugin into JS? That would make a huge impact due to its mobile-ish nature.

Posted by Jack on June 10, 2012

Absolutely, Michael, ThrowPropsPlugin is coming to the JS version too. Soon. If you have a specific need for it right away, let me know.

Posted by Antoine Bisch on June 15, 2012

Jack, this is some amazing piece of work dude! I have been creating increasingly complex animations with jQuery and felt like I had reach its limits in terms of performance. I have recoded one of my projects with your JS library and… man, the result is so smooth… Mind blowing! You’re simply taking it to a whole new level, this is becoming a standard in JS animation for me now.

[...] perform a Y-axis 3D rotation on any jQuery element – it’s used in conjunction with the Greensock JavaScript libraries and it means you can simply add the call to the element as a function of itself. It’s a bit [...]

Posted by jason on July 25, 2012

Great work you did here, love it. Now lets corner the tween library market…objective-c and java, go for the hat-trick Jack.

Posted by MooDisco! « Darkliner – creative code on August 21, 2012

[...] with Adobe Edge Animate preview, Greensock (TweenMax and TimelineMax), the rather nifty SoundManager 2 and a few jQuery UI libraries for dragging, this demo has [...]

Posted by Tushar Singh on September 28, 2012

This is undoubtedly the most powerful animation library i’ve ever seen. I’m going to promote this

Posted by Chris McAndrew on October 9, 2012

This is why we all loved Flash. Once again, thank you sir.

Posted by Snorkl Report September 2012: New Beginnings on October 14, 2012

[...] you through ALL of the tools GreenSock offers. Although there’s a lot of buzz around JavaScript, GSAP 12 for AS2/AS3 is by far the most powerful GreenSock release for Flash. I can’t urge you enough to upgrade from [...]

Posted by Casey on November 1, 2012

Easily my favorite ActionScript library. So glad to use it again with JS. Nothing better than TweenMax!

Posted by daklab on November 16, 2012

I’ve realized GSAP 12 has been in beta for quite some time now. In your “Currently v12 is considered a beta release although there are no known bugs (knock on wood) and it is actively being used by many developers in the wild with great results.” remark I would have expected it to be out of beta. No rush :) Just curious if you have an updated timeline on releasing out of beta? Thanks again Jack, you kill it!

Posted by Jack on November 17, 2012

Fair point, daklab. It has indeed taken longer than expected to firm things up, but we’ve been doing lots of work to enhance things since the original post. In fact, we’re about to release a major update to CSSPlugin that’ll handle 3D transforms, boxShadow, borderRadius, clip, and textShadow (in browsers that support those features, of course). That was a major undertaking, especially because various browsers have inconsistent implementations of CSS3 features and/or glaring bugs that we must engineer workarounds for. The good news is that we’re sweating all that stuff so that you don’t have to. We’re VERY excited about all these new features and I think you’ll dig ‘em too.

I think removing the “beta” label carries a certain significance that can make it sound like we’re claiming everything is certified bug-free in all browsers when in reality the nature of the web these days and the rapid update cycle of browsers (and their related bugs and inconsistencies) make it a bit of a moving target, so it’s rather intimidating. It’s also very important to us that GreenSock tools live up to the reputation we’ve worked hard to earn, and that things “just work”. However, we’re approaching the point where things feel solid enough to release as non-beta and we’ll rely on the trust that the community has in us to promptly patch any bugs that rise to the surface. Don’t get me wrong – we aren’t aware of ANY bugs at this point, but that doesn’t mean they don’t exist. With an animation system as robust and complex as GSAP, there are a lot of moving parts and certain things can’t be discovered until very particular scenarios are attempted (and we can’t think of them all).

Our plan is to push this big update out while still in beta, let it simmer out there with folks and see if anyone discovers some things that need patching. Then after we port a few more plugins over (like ThrowPropsPlugin and PhysicsPropsPlugin for members) we’ll likely remove the “beta” label. That should happen within the next month or two.

Posted by Ford Dye on January 20, 2013

I have been using the Greensock platform since V.11 to re-build my website from scratch in AS3/Flash10 and it is absolutely amazing! The provided documentation and dedication to helping people is top notch. I am thankful that the Greensock team put in the time and continues to put in the time to enrich our flash content!

Posted by FabioTNT on February 8, 2013

Wow! Awesome work man! I will really use in my next projects!!

Posted by Steven Vachon on May 19, 2013

I think you forgot to mention that v11′s timeScale property has been removed in v12.

Posted by Jack on May 19, 2013

Nope, timeScale is still very much a part of v12. In fact, it’s even more a part of it because it’s now included in TweenLite too, so there’s a new level of consistency. The only difference is that [like most other properties] it’s a method now instead of a regular property (getter/setter). So you’d do tween.timeScale(2) instead of tween.timeScale = 2.

Posted by Paopee on August 15, 2013


Posted by Derek Collie on November 14, 2013

Possibly missed in the list of gotchas is that EaseLookup.find now returns an Ease rather than a Function as it did in v11. If you had previously stored the result of EaseLookup.find in a var of type Function it will cause a compile error 1067: Implicit coercion of a value of type com.greensock.easing:Ease to an unrelated type Function.

Posted by Jack on November 14, 2013

Great point, Derek. Thanks for pointing that out.

Posted by Erik Grieten on January 30, 2014

Jack! This is easing the transition from ActionScript over to JavaScript quite well.
I will really use in my next projects!


To download the code, you must agree to the following license:


  1. You may use the code at no charge in commercial or non-commercial apps, web sites, games, components, and other software as long as end users are not charged a fee of any kind to use your product or gain access to any part of it. If your client pays you a one-time fee to create the site/product, that's perfectly fine and qualifies under the "no charge" license. If end users are charged a usage/access/license fee, please sign up for a "Business Green" Club GreenSock membership which comes with a comprehensive commercial license. See for details.
  2. Use at your own risk. No warranties are offered.
  3. Please respect the copyright.



This is a legal agreement between you (either an individual or a single entity) and GreenSock, Inc. ("GREENSOCK") for the proprietary GreenSock code known as TweenLite, TweenMax, TweenNano, TimelineLite, TimelineMax, and other copyrighted code that is available for download at (this code and documentation, as well as any updates which may at GREENSOCK's sole discretion be provided to you from time to time, are referred to in this Agreement as "PROGRAM"). By downloading, copying, or otherwise using the PROGRAM, you agree to the terms and conditions of this Agreement. If you do not agree to the terms and conditions of this Agreement, please do not download or use the PROGRAM.

A. Subject to the terms and conditions of this Agreement, GREENSOCK hereby grants you a non-exclusive, worldwide, non-transferable right to use the PROGRAM in apps, web sites, games, components and other software applications ("Developed Works") for which the end user is NOT charged any fees. If you would like to use the code in a commercially licensed Developed Work for which end users are charged a fee (either for usage or access), simply sign up for the appropriate "Business Green" Club GreenSock membership at

A. You agree that you will not sell, rent, or license the PROGRAM's source code or any derivative works thereof to any third party without the prior written consent of GREENSOCK. Distribution of the PROGRAM as part of your Developed Work is acceptable so long as it is used exclusively as a part of your Developed Work. You agree not to modify or delete GREENSOCK'S existing copyright notices located in the source code.

B. You may use, duplicate, and distribute the compiled object code as embedded in Developed Works created by you, either for your own use or for distribution to a third party so long as end users of the Developed Work are not charged a fee for usage of or access to any portion of the Developed Work. Please see for descriptions of Developed Works that qualify for the "No Charge" license.

C. You may make modifications to the source code exclusively for your own use in order to perform bug fixes or other minor edits required to operate the PROGRAM as originally intended.

A. The license rights granted to you under this Agreement are at no charge, but only in the following circumstances: If on your own behalf or on behalf of a third party you incorporate the PROGRAM into a web site, app, game, program or any component thereof (collectively, "Developed Work"), which in the case of a web site, must be accessible to internet users without payment of a fee of any kind, and in the case of a software application, game, program or component, neither you nor anyone to whom you distribute the Developed Work charges a user a fee of any kind to use such Developed Work or application, game, program or component into which such Developed Work is embedded. The foregoing shall apply regardless of whether you are paid to create such Developed Work.

B. In the event your intended use of the PROGRAM does not meet the criteria for the "no charge" license rights set forth in the immediately preceding paragraph, then you are not licensed to use the PROGRAM under this Agreement and must license the PROGRAM under GREENSOCK'S separate fee-based Software License Agreement which is granted to "Business Green" Club GreenSock members (see for details).

C. You may make modifications to the source code exclusively for your own use in order to perform bug fixes or other minor edits required to operate the PROGRAM as originally intended.

A. The PROGRAM is licensed, not sold, and is protected by copyright laws and international treaty provisions. You acknowledge that no title to the intellectual property in the PROGRAM is transferred to you. You further acknowledge that title and full ownership rights to the PROGRAM, including all intellectual property rights therein, will remain the exclusive property of GREENSOCK and you will not acquire any rights to the PROGRAM except as expressly set forth in this Agreement. You agree that any copies of the PROGRAM you make will contain the same proprietary notices which appear on and in the PROGRAM. You agree that GREENSOCK may identify you as a licensee unless you make a written request otherwise. GREENSOCK hereby grants to you the right to disclose that your product, game, software application, component, or other Developed Work makes use of GREENSOCK code (for example, "Powered by TweenLite").

A. THE PROGRAM IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. GREENSOCK DOES NOT WARRANT THAT THE FUNCTIONS CONTAINED IN THE PROGRAM WILL MEET YOUR REQUIREMENTS OR THAT OPERATION WILL BE UNINTERRUPTED OR ERROR FREE. GREENSOCK shall not be liable for special, indirect, incidental, or consequential damages with respect to any claim on account of or arising from this Agreement or use of the PROGRAM, even if GREENSOCK has been or is hereafter advised of the possibility of such damages. Because some states do not allow certain exclusions or limitations on implied warranties or of liability for consequential or incidental damages, the above exclusions may not apply to you. In no event, however, will GREENSOCK be liable to you, under any theory of recovery, in an amount in excess of $250. Notwithstanding anything else in this agreement, you agree to indemnify GREENSOCK, its assignees, and licensees, and hold each of them harmless from and against any and all claims, losses, damages, and expenses, including legal fees arising out of or resulting from any negligent act or omission by you.

B. GREENSOCK may, at its sole discretion, provide support services related to the PROGRAM, but has no obligation to do so.

If you at any time fail to abide by the terms of this Agreement, GREENSOCK shall have the right to immediately terminate the license granted herein and pursue any other legal or equitable remedies available.

A. This Agreement shall be construed in accordance with the laws of the State of Illinois. In the event of any dispute between you and GREENSOCK with respect to this Agreement, we both agree that if we cannot resolve the dispute in good faith discussion, either of us may submit the dispute for resolution to arbitration with the American Arbitration Association before a single arbitrator using the AAA Rules for Commercial Arbitration. The arbitrator's decision is final and can be enforced in any court with jurisdiction over such matters.

B. This agreement represents the complete and exclusive statement of the agreement between GREENSOCK and you and supersedes all prior agreements, proposals, representations and other communications, verbal or written, between them with respect to use of the program. This agreement may be modified only with the mutual written approval of authorized representatives of the parties.

C. The terms and conditions of this Agreement shall prevail notwithstanding any different, conflicting, or additional terms or conditions which may appear in any purchase order or other document submitted by you. You agree that such additional or inconsistent terms are deemed rejected by GREENSOCK.

D. GREENSOCK and you agree that any xerographically or electronically reproduced copy of this Agreement shall have the same legal force and effect as any copy bearing original signatures of the parties.

Copyright 2006-2013, GreenSock, Inc. Updated 2012-08-28

I'd like to learn how to get bonus plugins, update notifications, SVN access, and more.
To continue, you must agree to the following license: