Director News
Director Web Sites
Mailing Lists
News Groups
Project Examples
Useful Web Sites

Don't miss these
Set FrameRate of a Flash Sprite
Dave Client
3D games online. Developed with Macromedia Director.
Import SWA (Shockwave Audio)
Find Last Label
Create File Association
Killing Moon / Director
Trim Function
Puzzler II - Slide Puzzle



Article What is the difference between Director and Flash?

Added on 11/8/2001


D7 D8 D8_5 Mac PC Shockwave


Author: durbnpoisn (website)

What is the difference between Director and Flash?

Now, of course there is no easy answer to this question. This, in fact, has been a great source of debate for a couple of years now. On one side you have diehard Flash users, on the other you have the Director people. Incidentally, I am a Director guy. That's why this article is posted in a Director forum.

When I started to really learn Flash, I thought it would have been great if someone had taken the time to illustrate the comparisons, pros and cons, and things to watch out for. I'm taking the time to write this article in hopes of helping some fellow users of either application in understanding what to expect.

One personal note before I get into this: I'm not trying to bash anyone, but, Flash users, in a way, are very much like Macintosh users. They steadfastly defend their platform of choice. And they do this not because they really know or believe the system to be better, it's just the easiest to work with. Now, I bring this up because, this steadfast loyalty can become an argument pretty quickly. And that is not what I intend to incite with this article.

So, keeping this in mind, I will make it a point, out of respect for users of both applications, to honestly list the benefits and disadvantages to both applications without any bias or prejudice. Sit back and be comfortable. There is a lot to explain here and I'm going to try to be as detailed as necessary.

Each program has pros and cons. Flash is better suited for certain types of projects than Director. For instance, interface design for a full site is much more efficient in Flash. But, game development and complicated interface programming is much better in Director. Director has a much stronger timer than Flash. This is essential for games. Flash tends to bog down when a lot of elements are on the screen. Director always runs the same speed unless you really tax it hard. Director gives far better control over user interaction and stage manipulation. Flash sacrifices some of that for the sake of ease. It's a little easier to get lots of nifty little animated features going in Flash than in Director. Flash is purposely organized in such a way because that is what its primary function is.

In the beginning there was Macromind and their product Director. There was no Flash yet. As the years went by, Macromind became Macromedia and Director went up a few version numbers. Then, the internet suddenly became the most important thing in the known universe. And browser plugins became necessary for users to really enjoy their internet experience. Around this time, Macromedia acquired Flash from another smaller company. Their intention was for Flash to be a companion program to Director. Macromedia also decided that the browser plugins for both of their biggest development packages should be bundled together. This turned out to be a great idea.
Knowing all of this, it's a lot easier to understand why the development environments for the two programs are completely different. In fact, sharing a plugin is about all they have in common.

Frankly I don't see any reason to touch on the early versions of either program. I will only speak about Director 7.02 and Flash 5.0. I used the earlier revisions of both programs for years. Both of them have made huge leaps and bounds in terms of improvement. This article is going to assume that you are very familiar with at least one of these apps. So, I will not bother to explain acronyms or terminology. Sorry.


So let's compare the two

Graphics - Vector vs. Bitmap
Flash does a wonderful job of handling vector based artwork. It supports a really nice, seamless copy and paste right from Illustrator. It also supports import from a variety of programs that can actually export vector artwork in SWF format. Also, the editor for the vector shapes is pretty accurate and easy to use.
Flash does not really handle bitmaps quite as well. It does okay, but be prepared for some artwork to appear blurrier than you expected. The bitmap editor is rather sloppy. This is especially apparent if you zoom up on the image. It shows everything as a blurry approximation of the actual image. This is not very helpful when you need to do detailed touch up work.

Flash handles the bitmap resources in a strange fashion. It holds the resource intact outside of where you view it for editing as a Symbol. So, when you break it apart to do some editing, you are actually working on a sort-of mirror image of the actual bitmap. This is an efficient way to handle the resource if you need to use the same bitmap in different places and need it to look different in every one.

Director does not handle vector artwork nearly as well as Flash. It's pretty sloppy in fact. I try to avoid using vector artwork most of the time unless they are simple native Director primitives, like circles and rectangles. I've actually seen the work environment in Director lock up and respond slowly because it can't handle the vector art. Another strange thing about vector shapes… You can't rotate them. I have no idea why they left this capability out.
Now, Director handles bitmaps like a dream. That's where the real graphical power for Director comes in to play. The built in editor is flawless and sharp. You can easily make detailed pixel by pixel edits to your images. You can also change the color depth and palette. You can even import a palette with an image, if one of the local palettes doesn't work well enough. That's a great trick for keeping file size down. Flash compresses bitmaps to attempt to do this. Director doesn't. This is another reason why bitmaps in Director look so much nicer. Director also supports copy and paste right from PhotoShop or any other app like it. Flash does this too, but it's not quite as accurate.
Director also includes a neat, helpful feature that automatically makes any white area that is not entirely surrounded, transparent. It actually omits the color from the bitmap. Director users know what I'm talking about. It's one of the most useful built in shortcuts. Also, you can change the transparent color for any bitmap from white to anything you wish. White is used be default.

Director has two really cool inking effects that Flash doesn't offer. "Copy" will make the outside of the sprite transparent. "Transparent" will make every pixel in a sprite transparent that matches the current setting for "background color". In both cases, white is the default setting, but you can make it whatever you wish.

When you compile your program for release, you will see that the image quality for bitmaps from Director is flawless. From Flash they look blurry even if you set the JPEG compression to the highest quality. Another good point about this is what happens when you compile a projector from either program that is intended to run full screen.

Flash always stretches to fit the desktop and scales the graphics. If you use bitmaps they will look horrific when scaled up. Vector artwork, on the other hand, looks exactly the same. Since vector artwork is handled so well by Flash, this is another good reason to avoid bitmaps. Director stays at 100% no matter what the resolution. Version 8.0 allows you to scale your stage the same as Flash does, but I don't recommend that since your bitmaps will appear just as horribly as they would from Flash.

The Shockwave/Flash Plugin
Even though both applications compile for the same plugin, they do not use the same parts of the plugin at all. Shockwave tends to be a little more intensive than Flash. The plugin takes quite a bit longer to initialize for a DCR file. Flash SWFs tend to launch extremely fast. This holds true for stand-alone Projectors also. Streaming in Flash is built in and it is automatic. Of course, you also can control the stage to wait for certain resources. This is usually good for "Loading, please wait" messages. This can be done in Director also, but it's a little more complicated to set up. In this respect Flash has the advantage. This is one reason so many sites tend to use Flash for a primary interface over Director.

Flash SWF files have the advantage of making a much smaller file than DCR files normally are. This is partly because Flash developers use vector graphics a lot more.

The work Environment
Both Flash and Director use a "Cast" and a "Stage". They both have timeline keyframe editors. In Director they call it the "Score". But that's about where the comparisons end.

One great thing I'd like to point out before getting into this is the differences between the various editing windows. In Director, you can open an indefinite number of any editor including, Bitmap, Text, Lingo, Score etc... This is a great feature when you need to compare resources while editing them. Flash offers only one window for editing, no matter what the resource type.

The Score
The keyframe editor in Director (the "Score") is so much smarter and easier to use than Flash's. The simplest editing functions require a ridiculous number of steps in Flash, whereas in Director, a click and drag is all that's necessary. It's almost impossible to edit multiple resources simultaneously in Flash. In Director, it's fairly easy.
Sprite appearance on the Stage is more difficult in Flash than it needs to be. All of the most important aspects of appearance like, opacity, transparency, position, etc… are handled in the same place at the top of the Score in Director. They are spread out through miscellaneous floaters and tabs in Flash. This makes it very frustrating to find what you're looking for a lot of the time.

The keyframes in Flash are handled totally differently than Director (or any other application for that matter). Normally, you can only have one object on a key frame. In Flash you can pile up as many as you wish. What's weird about this is that, you can perform no effects on layers with multiple objects. This is why every other application in existence doesn't let you do it. But Flash does… I guess, in some cases, it's nice because you can keep your layer list a little shorter, but it makes some editing a lot more difficult than it should be. On the same note, the technique for accessing objects using Action Script is different than Director. In Director, you access objects directly by the channel (layer) that it is sitting on. In Flash, you have to physically name the object (instance) before you can access it with Action Script. This, also takes some getting used to.

In Director, you have the exact same level of control for any object on the stage (well, with very few exceptions). You can also control ANY of those appearance aspects using Lingo very easily. This can be done in Flash too, but the syntax is clunky and inconsistent.
In Flash, you have to deal with different resource types (is it a Movie clip, button, or graphic?). So, you have to make sure that your desired action can even be set on any particular resource before you even try. And they don't make it easy for you to figure out what's supported. More often than not, you just see the menu line grayed out which doesn't help you at all.
Let me give you a really good example of this:
To make a graphic respond to "MouseDown" using Director, you simply drop the mousedown code on the resource in the cast, or a behavior to its sprite channel on the Stage. There are actually 4 different places to put the code in Director. You can choose what works best for any particular circumstances. And, it makes no difference at all what kind of resource it is. In Flash, you have to drop the graphic on the stage, convert it to a symbol of type "Button", then add the action to it. Getting used to the extra steps takes some time. You have to force yourself to plan ahead when developing your resources.

The Stage
The Stage in both applications is pretty much the same except for one thing. The Stage in Flash has no border. Just an outline. In Director, the stage is a floating window that looks just like your finished product will look. This is up to your opinion which you will prefer.

When nudging sprites using the arrow keys in Flash, the nudge increment is based on your current magnification. In Director it's always one pixel (10 pixels if SHIFT is held down). That is a huge mistake in Flash.

Masking is supported by both applications. In Director it involves some difficult setup and planning, but it works pretty well. You have to create a 1-bit black graphic of the shape of the visible area. Place that cast member directly next to the one that you want masked. Then lay that graphic in the Score and set it's blend to mask. So you need to have a separate resource for every mask.
Flash handles this quite a bit better. You set a layer to be of type "Mask", put whatever shape for the visible area you want on that layer, and everything under it in the hierarchy will be under the mask.

The "Cast" and the "Library"
The "Cast" in Director and the "Library" in Flash are somewhat similar. The Flash library shows up as a list that can be divided into subfolders. Director's cast is just little graphical thumbnails with no logical hierarchy. I'd say that each has their good points. It's really just a matter of opinion which works better for you. In Director, you can easily identify what cast member is occupying a key frame, it's written right on the tweener. In Flash, you have to open up grouped objects and have the Info tab visible to identify resources. Again, extra steps. In both cases, double clicking on the object will open it up for editing. In Director, it most often will launch the appropriate editor. In Flash, by default, it simply opens it on the Stage. It's strange, but it there are benefits to this technique in some cases.

Movie Clips in Flash compared to Film Loops in Director
This is a case where Flash wins hands down. They came up with a really good concept here. I'll get to that in a second.

In Director, you set up your animation and then copy/paste the keyframes into a cast member. Then you can drop that "Film Loop" on the stage and let it go. It sounds easy enough, and it is… But there are 3 major problems with this:
1) Since sprite blending is ignored by Film Loops, hit detection is active for the entire bounding box of the Film Loop. This is really bad if you need the hit detection to only respond to the shape of the visible sprite.
2) You cannot rotate, blend, or otherwise affect film loops aside from placement on the stage, using Lingo.
3) Lingo does not execute from within the film loops properly.

In Flash, you can take a whole set of timeline, Action Script and all, and plop it on the stage. Then you can use other Action Scripts to control it anyway you see fit. You can make it jump to frame labels, play, stop, etc… You can also set up the StartDrag and StopDrag functions to the entire clip. That's a really cool and useful trick.
Another huge benefit is that you can take an entire Flash program, turn it into a Movie Clip, and the copy/paste it into any other Flash file, and it will function perfectly.

Playback controller
Both apps have a means of testing your movie from the authoring environment. This is one that Director wins on. When testing in the work space, the program works 100% the way that it will when compiled. This is true assuming that the program is not dependant on external resources. But, then that would be true for anything… In Flash, hitting the play button doesn't do anything worthwhile. Frankly, I don't even know why they included it. The only way to accurately test the movie is to use "Test Movie". The problem with this is that in order to "Test Movie", Flash must publish a SWF file with the default setting (the filename of the scene or movie). It does this if you "Test Scene" also. So, if you test a lot in this fashion you will have tons of useless SWF files laying around.

In this case, Director wins as the app less likely to wipe out. Both applications have their problems. They both will crash and possibly corrupt your work files. But, Director seems to stay open longer before crashing. I would say that Director crashes about once every 7 sessions. Flash crashes about once every 3 sessions. I am only referring to Windows OS's in this section. I don't have much experience on Macs as far as stability goes.
Both programs crash for the same reason. Memory. I think this is really more of a Windows issue than either one of the programs. Windows is known to have serious memory management problems. I'll spare you my opinions about all this stuff. But, rest assured that after a while of compiling, switching apps, copying and pasting, etc… memory leaks make the either app suddenly go goofy.

The biggest one to watch out for in Director is when you get the dialog "A fatal error has occurred. Director will quit now." If you try to save your file after this, it will corrupt it. I've seen this occur many times for no apparent reason. But, the most common thing that causes this error is copying and pasting cast members. This happens especially if you use Lingo to perform this action. If you need to perform an operation like this using Lingo, it's best to compile the code and test outside the authoring environment.

Now for Flash's biggest problem. Copying and pasting code in Expert mode makes the program unstable in very short time. You can identify this by one of two things
1) The fonts all suddenly go bold and larger
or 2) the list of actions in the left pane of the Actions window appears blank. This is always followed by a dialog that pops up and says "A required resource was" and an OK button. If you save your file after this happens, it will be corrupted and unusable.

In either case, you should make backup copies of your work files before doing ANY work.

Action Scripting and Lingo
Now, I could go on for a while about this, but I'll try to keep it simple. This one, without a doubt, I favor Director. Not only because I was using Director first. Well, read on, you'll see what I mean.

There is no comparison whatsoever between the languages. Lingo is more object oriented and the syntax is more like Visual Basic than anything else. Action Scripting is barely even procedure oriented, much less object oriented. The syntax is more like C.

In Director, you can set up your functions and procedures and call them at anytime from anywhere. With Flash, it's easier to set your code in a Movie Clip and activate it by making the clip play. In Director, you can open multiple code windows. In Flash, there is only one. This is rough when you have to make modifications to code that occurs in lots of different movie clips.

Flash takes the approach that Normal view is the preferred method for writing code. It basically writes and formats everything for you with a couple of clicks. This is really a nice feature for people who don't really write code. You can switch to Expert mode and write the long way, and still have the option of using the automated method. But, there is a BIG problem here. There is a bug in the Flash compiler. If you write in Normal mode, your code is compiled instantly. If you write all your code in Expert mode, it is not compiled until the program is tested or published. The compiler that it uses for testing and publishing doesn't work as well as the Normal mode compiler. I have no idea why this is the case, but you have to periodically switch modes which forces your code to be compiled, or it won't function properly at runtime. I've actually had a chunk of code that I knew to be good, fail to work while testing - So, I switched modes and ran it again, and it worked perfectly. This also forces your code to be indented properly which expert mode does not do for you.

Director, too, has means of prewriting code, but the endless cascading menus make the process so long, you may as well just write it yourself.
Director gives you the ability to attach code to objects using a few different methods. You can write 1 behavior and then attach it to 100 objects on the stage that you wish to make use of it. You can write code that executes when the playhead enters or exits a frame. You can even set up a predefined script that runs whenever certain actions occur (i.e., mousedown or keydown). You can attach code directly to an object without attaching a behavior to it. And you can also set up lists upon lists of functions that can be called from anywhere. This is SO much more flexible than the Flash methods. Your only choices in Flash are, when the playhead enters a frame, or actions on buttons. I've heard that you can make function calls, but the syntax makes no sense. Director automatically formats, indents and color codes your code for you. It compiles the code whenever the program is saved or when the play button is hit.

The Watcher in Director is the place that you can stick any variable and view (and set) it's current value. This is probably one of the best features ever.
The Debugger window in Flash, however, is garbage. It's almost impossible to find the variable you're looking for. I can't even make sense out of it a lot of the time. I usually put a text field on the stage and populate it with the values that I want to see. Either that or I ad Trace functions to places where I need to know a value. But, that makes that annoying Output window pop up.

Both programs support the full range of necessary variables. And both programs can identify a variables type on the fly without having to predefine it. Both programs support multidimensional Arrays (or lists, as they are called in Director). Both have the ability to set up arrays with multiple data types.
Director manages arrays a little better than Flash does. You can create full data structures of object types so you can access them by name instead of list position.
Initializing a list with named objects:
ThisList = [#firstParam: 1, #secondParam: 2]
Can be accessed later using:
ThisList.FirstParam = value

I've heard programmers refer to this method as "using dot syntax". That is, objectName(dot)Parameter. I suppose that's an accurate way of describing it.
This is one of the reasons that I compare Lingo to Visual Basic. They both handle object access in this fashion. That is, you can create a whole new object data structure, and access it with the same syntax that you would use to access all the predefined Director objects. You can also use string variables to refer to objects by name very easily.

Flash does not posses the capability to set up data structures like this. Flash uses dot syntax to communicate with some objects, but the syntax is different for every type of object, and you can't always easily use variable names when referring to them.
The only way to get to the values in arrays is by accessing the values' position using integers. This is a real pain when you have a very complicated array that you need to access.

The only other really big difference is how Local variables and Global variables are handled. (Local variables only stay in memory until their procedure or function is finished, Global variables retain their value until the program exits.) Both programs handle Local variables exactly the same way. This is not at all true for Globals. Director has a better method of handling those. You have to constantly redefine a Global variable for every procedure that uses it. Failing to do so will cause the program to treat it as Local. But, once you declare that variable, you can make use of it anywhere. Flash takes EVERY variable that is initialized at the root level, of anything that HAS a root level and makes it Global. So whenever you access that variable, you have to put the full path in front of it. Failing to do so, or using the incorrect path will cause the program to treat it as Local. Now the real problem here is that you can't always identify exactly what that path will be. So, variables that you intended to be Global sometimes are not accessible that way. I always end up putting ALL the Globals in the first frame of the first scene. Then I know I can get to them from anywhere by using "_root."

Xtras are analogous to .DLL files in Windows. The idea here is that developers can create new functions and reserved words that can be called from Lingo as if they were part of the original supported code base. Xtras are written and compiled in C usually. There is a huge library of Xtras available both for free and for purchase.

Flash has a similar subset of files called Extensions. Handling these files is nowhere near as easy as Director. You actually have to download an Extension Manager from Macromedia and install it before you can even use them. There is a fairly limited number of Extensions currently available compared to Director Xtras.

I think I've pretty clearly illustrated the differences, advantages, and disadvantages to each program. The bottom line of all of this is that the decision for which app to use has to be made on a per-project basis. Your final decision must be based on what you intend for your final product to look and act like. There are some things that are almost impossible in one app that are very easy in the other. That is why I suggest that if you have the time and energy, learn both programs. Having both tools in your arsenal will prove hugely beneficial.

I think I've written enough for now. I hope that this article has proved helpful to you.



36 South Court Sq
Suite 300
Newnan, GA 30263

Send e-mail