The following optimizations will increase AS2 execution speed.

• The less AS used, the better the file performance. Always minimize the amount of code written to perform a given task. AS should be used primarily for interactivity, not for creating graphical elements. If your code consists of heavy use of attachMovie calls, reconsider how the FLA file is constructed.
• Keep the AS as simple as possible.
• Use scripted animation sparingly; timeline animation will typically perform better.
• Avoid heavy string manipulation.
• Avoid too many looping movie clips that use an “if” statement to avoid termination.
• Avoid using on() or onClipEvent() event handlers. Use onEnterFrame, onPress, etc instead.
• Minimize placing primary AS logic on a frame. Instead, place large chunks of important code inside functions. The Flash AS compiler can generate significantly faster code for source located within the function body as compared to that located directly inside of frames or old-style event handlers (onClipEvent, on). It is however acceptable to keep simple logic in the frame, such as timeline control (gotoAndPlay, play, stop, etc.) and other non-critical logic.
• Avoid using "long-distance" gotoAndPlay/gotoAndStop in movie clips with long timelines having several animations.
  • In case of forward gotoAndPlay/gotoAndStop , the farther the target frame from the current one, the more expensive is the gotoAndPlay/gotoAndStop timeline control. Thus, the most expensive forward gotoAndPlay/gotoAndStop is from the first frame to the last one.
  • In case of backward gotoAndPlay/gotoAndStop , farther the target frame from the beginning of the timeline, the more expensive is the timeline control. Thus the most expensive backward gotoAndPlay/gotoAndStop is from the last frame to the frame before the last.
• Use movieclips with short timelines. The cost of the gotoAndPlay/gotoAndStop highly depends on the number of keyframes and the complexity of timeline animation. Thus, do not create long and complex timelines if you are planning to navigate by calling gotoAndPlay/gotoAndStop. Instead, split the movieclip's timeline into several independent movieclips with shorter timelines and less gotoAndPlay/gotoAndStop calls.
• If updating many objects simultaneously, it is essential to develop a system in which these objects can be updated as a group. On the C++ side use a GFx::Movie::SetVariableArray call to pass large amount of data from C++ to AS. This call can then be followed by a single invoke that updates multiple objects at once based on the uploaded array. Grouping multiple invokes into one call is usually several times faster than calling them for each individual object.
• Don’t attempt to perform too much work in a single frame, or Scaleform may not have time to render the Stage, and the user may perceive a slowdown. Instead, break up the amount of work being performed into smaller chunks, allowing Scaleform to refresh the Stage at the prescribed frame rate with no perceived slowdown.
• Don't overuse the Object type.
  • Data-type annotations should be precise, because it allows compiler type checking to identify bugs. Use the Object type only when there is no reasonable alternative.
• Avoid using the eval() function or array access operator. Often, setting the local reference once is preferable and more efficient.

• Assign Array.length to a variable before a loop to use as its condition, rather than using myArr.length itself. For example:

  Use the following code

  var fontArr:Array = TextField.getFontList();
  var arrayLen:Number = fontArr.length;
  for (var i:Number = 0; i < arrayLen; i++) {
      trace(fontArr[i]);
  }
  

  instead of:

  var fontArr:Array = TextField.getFontList();
  for (var i:Number = 0; i < fontArr.length; i++) {
      trace(fontArr[i]);
  }

• Manage events wisely and specifically. Keep event listener arrays compacted by using conditions to check whether a listener exists (is not null) before calling it.
• Explicitly remove listeners from objects by calling removeListener() before releasing the reference to the object.
• Minimize the number of levels in package names to reduce startup time. At startup, the AS VM has to create the chain of objects, one object per level. Moreover, before the creation of each level object, the AS compiler adds an "if" conditional to check whether the level is already created or not. Thus, for the package "com.xxx.yyy.aaa.bbb" the VM will create objects "com", "xxx", "yyy", "aaa", "bbb" and before each creation there will be an "if" opcode that checks the object's existence. Accessing of such deeply nested objects/classes/functions is also slow, since resolving names requires parsing each level (resolve "com", then "xxx", then "yyy" inside the "xxx", etc). To avoid this additional overhead, some Flash developers use preprocessor software to reduce the path to a single-level unique identifier, such as c58923409876.functionName(), before compiling the SWF.
• If an application consists of multiple SWF files that use the same AS classes, exclude those classes from select SWF files during compilation. This can help reduce runtime memory requirements.
• If AS on a keyframe in the timeline requires a lot of time to complete, consider splitting that code up to execute over multiple keyframes.
• Remove trace() statements from the code when publishing the final SWF file. To do this, select the Omit Trace Actions check box on the Flash tab in the Publish Settings dialog box, then comment them out or delete them. This is an efficient way to disable any trace statements used for debugging at runtime.
• Inheritance increases the number of method calls and uses more memory: a class that includes all the functionality it needs is more efficient at runtime than a class that inherits some of its functionality from a superclass. Therefore, it may be necessary to make a design trade-off between extensibility of classes and efficiency of code.
• When one SWF file loads another SWF file that contains a custom AS class (for example: foo.bar.CustomClass) and then unloads the SWF file, the class definition remains in memory. To save memory, explicitly delete any custom classes in unloaded SWF files. Use the delete statement and specify the fully qualified class name, as the following example shows: delete foo.bar.CustomCLass
  
• Not all code has to run every frame, use flip flops (where portions of code are alternated each frame) for non-100% time critical items.
• Try to use as few onEnterFrames as possible.
• Precalculate data tables instead of using math functions
  • If doing a lot of math, then consider precalculating the values and storing them in a (pseudo) array of variables. Pulling those values from a data table can be much faster than having Scaleform to do it on the fly.

Loops

• Focus on optimizing loops, and any repeating actions.
• Limit the number of loops used and the amount of code that each loop contains.
• Stop frame-based looping as soon as it is no longer needed.
• Avoid calling a function multiple times from within a loop.
  • It is better to include the contents of a small function inside the loop.

Functions

• Whenever possible, avoid deeply nested functions.
• Do not use with statements inside functions. This operator turns off optimizations.

Variables / Properties

• Avoid referencing nonexistent variables, objects, or functions.
• Use the “var” keyword whenever possible. The use of the “var” keyword inside functions is especially important since the ActionScript compiler optimizes access to local variables using internal registers with direct access by index rather than putting them into a hash-table and accessing by names.
• Don't use class variables or global variables when local variables will suffice.
• Limit the use of global variables, because they are not garbage collected if the movie clip that defined them was removed.
• Delete variables or set them to null when no longer needed. Doing this marks the data for garbage collection. Deleting variables helps optimize memory use during runtime, because unneeded assets are removed from the SWF file. It is better to delete variables than to set them to null.
• Always try to access properties directly rather than using AS getter and setter methods, which have more overhead than other method calls.