.AS File Format

Introduction

An .as file holds ActionScript source code as plain text. ActionScript 3.0, the version on this page, arrived in June 2006 with Flash Player 9 and Flex 2, and reached the Flash authoring tool with Flash CS3 Professional in 2007. It is a different language from ActionScript 1.0 and 2.0, and it runs on a different virtual machine, the ActionScript Virtual Machine 2 (AVM2). Flash Player 9 and later carry both machines: AVM1 for older content and AVM2 for ActionScript 3.0.

The language was built on the drafts of ECMAScript 4, the planned fourth edition of the standard behind JavaScript. It has classes, packages, namespaces, optional type annotations checked by the compiler, sealed objects, method closures, native XML (E4X) and regular expressions. ECMAScript 4 itself was abandoned in 2008, so ActionScript 3.0 kept its own course. Adobe gave the source of the AVM2 to the Mozilla Foundation in November 2006 as the Tamarin project; that code is still published as avmplus.

Flash Player was discontinued at the end of 2020, but ActionScript 3.0 is still written today. Adobe Animate, the former Flash Professional, still makes ActionScript 3.0 documents. Adobe AIR, which packages ActionScript 3.0 applications for Windows, macOS, Android and iOS, passed from Adobe to HARMAN in 2019, and its SDK is now published from a Wipro site. The Apache Flex SDK, the open-source continuation of Adobe Flex, holds the command-line compilers; its last release was 4.16.1, in November 2017. Ruffle, a Flash Player emulator written in Rust, runs compiled ActionScript 3.0 in browsers through its own AVM2.

An .as file dropped on any page opens in the explorer, which shows it as text. The explorer recognises ActionScript 3.0 by its package block.

Structure

A typical ActionScript 3.0 file holds one package block. Inside it come the import directives and then exactly one definition that other files can see: a class, an interface, a function, a variable, a constant or a namespace. That definition must be public or internal and must have the same name as the file, so com.example.Hello lives in com/example/Hello.as, with one folder for each part of the package name. A package with no name, package { … }, is the top-level package, for files at the root of the source path.

package com.example {
    import flash.display.Sprite;
    import flash.text.TextField;

    [SWF(width="400", height="300", frameRate="30", backgroundColor="#FFFFFF")]
    public class Hello extends Sprite {
        public function Hello() {
            var label:TextField = new TextField();
            label.text = "Hello, world";
            addChild(label);
        }
    }
}

package {
    public class Main {
        public function Main() {
            var s:Stack = new Stack();
            s.push(1);
        }
    }
}

import flash.utils.getTimer;

class Stack {
    private var items:Array = [];
    public var created:int = getTimer();
    public function push(value:*):void { items.push(value); }
}

Where ActionScript 3.0 is stored and compiled

ActionScript 3.0 code turns up in three places: as text in .as files, as text inside Flash documents, and as compiled bytecode inside SWF files.

Compiling does not keep the source. Each class becomes an entry in the ABC file’s instance and class tables, each method a method body of AVM2 instructions, and the package, the access attributes and the namespaces become namespaces on each name. A SWF whose FileAttributes tag sets its ActionScript 3.0 flag is run by the AVM2; otherwise the player uses AVM1. See Compiled bytecode.

Telling it apart

All three ActionScript versions use the .as extension and plain text, so the content decides:

• ActionScript 3.0 – a package block wraps the definitions: package com.example { public class Hello … }
• ActionScript 2.0 – a top-level class or interface with the full dotted name and no package block: class com.example.Hello { … }
• ActionScript 1.0 – loose statements and functions, no class keyword, often pulled in with #include

A file holding only a fragment for include has no package block of its own, so it can look like older code; its import lines, typed var declarations such as :int and :uint, and ActionScript 3.0 class names such as flash.display.Sprite show what it is.

Variants

• ActionScript 1.0 – loose code pulled in by #include, with prototype-based objects (Flash 5 and Flash MX)
• ActionScript 2.0 – one class or interface per file, found through the classpath, compiled for AVM1 (Flash MX 2004 to Flash CS4)
• ActionScript 3.0 – a package block with one public definition, compiled for the AVM2 (Flash CS3, Flex 2 and later)

Links