In terms of tools for running old software, ScummVM is in a class of its own. It’s a long-running project that “reimplements” old games, reconstructing the game code so they can be played on other platforms. Back when ScummVM was first under development twenty years ago (!), it was meant for games created with the SCUMM engine, a toolset by the developer LucasArts that powered their famous adventure games like The Secret of Monkey Island, Indiana Jones and the Fate of Atlantis, and Day of the Tentacle.

Since then, ScummVM has broadened considerably in scope. ScummVM now supports over 200 games, including other adventure game engines, like Sierra On-Line’s Adventure Game Interpreter; individual titles like The 7th Guest; and even unrelated vintage software like the Living Books interactive children’s book series by Brøderbund. The ability to run these games on modern platforms using a free, lightweight, open-source program — without needing to emulate an entire computer operating system — has made ScummVM a boon for video game preservation. In fact, several game publishers have turned to ScummVM when re-releasing their old games!

But ScummVM is about to get even bigger. Earlier this year, ScummVM added experimental support for Macromedia Director, one of the most widely used development tools from the CD-ROM multimedia era. This is a big deal, so big that it got press coverage, including an article that I spoke with Ars Technica for in August.

This month, to celebrate the project’s twentieth anniversary, the ScummVM team released ScummVM 2.5.0, the first version to officially support Macromedia Director games. There’s a lot of work to be done still, but I wanted to document where it stands right now — why it’s a big deal, how well it works, and what comes next.

 

Macromedia Director? Why does this matter?

If there’s a single piece of software that defined the multimedia era, it’s Macromedia Director.

Making computer software in the 90s was hard. Macromedia Director made it easy. It was a tool with a simple drag-and-drop interface that developers could use to place and manipulate elements like text, buttons, graphics, and sounds. Then they could link those scenes together, like pages in a book, or rooms in a virtual world. Even if you didn’t know much programming, you could use Director to make a presentation, an encyclopedia, or a digital magazine, or most relevant to this post, you could use it to make a game. Creating a fast-paced action game with Director was a tall order, but for point-and-click adventure-style games that move between static scenes — the type popularized by breakout CD-ROM titles like The 7th Guest and Myst — Director took out a ton of the work.

At a time when the barrier to computer game design was still fairly high, Macromedia Director was a lifeline for small and independent developers. If you wanted to create interactive media art but didn’t know how to program an application for Windows 95 from scratch, you probably used Director. It’s the reason why the ’90s computer game scene is filled with unusual Myst-inspired titles from new developers. It’s why Theresa Duncan could produce a series of children’s discovery games, or why an artist like Osamu Sato was able to seamlessly transition from digital art to designing a surreal, cosmic exploration of mortality in Eastern Mind: The Lost Souls of Tong Nou.

The collective body of work produced with Macromedia Director represents some of the most creative, inventive, and experimental games and interactive art of the 1990s. That’s why it’s alarming that these games are so difficult to play today!

Here’s the problem: Macromedia Director is built on top of old versions of the Windows and Macintosh operating systems. In order to play a Director game, you need to emulate an old Windows or Macintosh computer, neither of which is an easy task for somebody who’s accustomed to downloading and playing games with the click of a button.

Let’s say you want to play the 1992 adventure game The Legend of Kyrandia. Right now, you can purchase it on a digital storefront like GOG.com, where it comes wrapped up in an emulator and runs on your choice of computer with minimal setup. Meanwhile, if you want to play Cosmology of Kyoto, a critically acclaimed game designed in Macromedia Director, you have to manually set up an installation of Windows 3.1 using the DOSBox emulator… and at that point, unless you’re really committed to playing this game, it might not seem worth the effort. This is also one of the reasons why many of these games haven’t been re-released, because you can’t legally just bundle Cosmology of Kyoto with an emulated copy of Windows and call it a day.

Expanding ScummVM to support Macromedia Director solves this problem. Once Director support in ScummVM is robust enough, it will make it easier than ever to play an expansive library of bold, creative titles that have been left out of the conversation for decades. That’s the promise here.

But it’s not quite there yet!

 

Let’s stress-test Director in ScummVM

Macromedia Director support in ScummVM is still experimental. Many games run, but others don’t, or they have significant problems. To see where things stand right now, let’s pull out a bunch of different Director games and see how ScummVM handles them!

This is going to be a nitty-gritty, technical article. If you want the short version, you can skip ahead to the wrap-up section at the end of the post.

Please keep in mind that I’m running all these games on Windows 10. There may be specific bugs related to running these games on Windows rather than Mac or Linux, which I’ll try to call out when possible.

General notes on compatibility

The ScummVM team has compiled a wiki page listing the Director software they’ve identified so far. They don’t all play well yet, but these are the titles that the ScummVM team hopes they’ll eventually be able to support. (For an even more detailed list, see the ScummVM GitHub.)

Currently, ScummVM will only detect and run these specific Director games. According to Roland van Laar, one of the authors of ScummVM’s Director support, the team eventually wants to expand this to allow ScummVM to play any Director title, similar to how ScummVM can play any of the thousands of homemade games made with the Adventure Game Studio engine, but it’s not that far along yet.

The ScummVM team is trying to actively identify other games they can add to their compatibility checklist. In the meantime, van Laar mentioned a workaround that will force ScummVM to run any unidentified Director program. You can create an empty file in the game directory with the name of the Director version number and platform, like “D4-win,” which will allow ScummVM to detect the game and attempt to run it using the appropriate version of Director. (To keep this article from going wildly out of scope, we’ll be focusing just on the games that ScummVM can already identify.)

In this first release, ScummVM only officially supports two Macromedia Director games: Spaceship Warlock and L-ZONE (both of which, conveniently, have been covered on this blog!). Both the Windows and Macintosh versions of these games are supported; this is exciting, because the Macintosh versions of Director games tend to have better technical performance than the Windows versions. For this stress test, we’re going to try both versions of each game when appropriate.

If you want to play Macintosh games in ScummVM, you can use the ScummVM Dumper Companion, which automatically converts Macintosh disc images into a format that’s readable on modern devices. This is an invaluable tool that I wish I had known about earlier! (Back in August, when Director support for ScummVM was first announced, I attempted to livestream some Macintosh games. It did not go well!)

It’s also worth noting that ScummVM currently does not resize the screen to the correct resolution and aspect ratio for Director games. I manually configured the program to run at 640×480 resolution to take the screenshots for this article. Games may look blurrier or have letterboxing in other configurations.

Spaceship Warlock

Spaceship Warlock by Reactor Inc. was one of the earliest CD-ROM adventure games — and one of the earliest Director games in general — which makes it a perfect test candidate for ScummVM.

The good news is that Spaceship Warlock runs almost perfectly. As one of the first Director games, Warlock is notoriously finicky in emulators. Running within DOSBox, the game encounters frequent graphical glitches, and because the Windows edition of Warlock is tied to the speed of the computer’s CPU, it moves at an erratic pace, usually way too fast. Not to be outdone, on Macintosh emulators like SheepShaver, either the audio doesn’t work or it just crashes altogether.

ScummVM fixes all these issues. Spaceship Warlock runs at a consistent speed throughout, so the cutscenes can be watched as they were originally intended, maybe for the first time since the game’s release. I’ve probably played through Warlock half a dozen times in emulators, but watching scenes like the battle between the Warlock and the Belshazzar play out at close to a normal speed felt like seeing the game for the first time all over again.

That said, depending on which version you play, there are a few snags, particularly with the Macintosh releases. Some on-screen interactions are a little awkward, like trying to drag your credit card from the bottom of the screen to the on-screen Comlink terminal in Stambul City; this might be because the Macintosh versions run on Director 2.0, back when it was still known as MacroMind Director, and the older version of Director might just have some unique interactivity issues that are being accurately reproduced by ScummVM (very few games used Director 2.0, so this wouldn’t be a common problem).

More noticeably, in the original Macintosh version 1.0 release of Spaceship Warlock, the game gets caught in an infinite loop during the Pogo shuttle docking scene. At the end of the sequence, the console log for ScummVM says that the game is trying to access a non-existent file:

WARNING: Movie Data:POGO:BELSHAZZAR:SpaceStation 1 does not exist!

The error seems to be specific ScummVM’s interpretation of the Macintosh version 1.0 of Spaceship Warlock from 1991. I did not encounter the problem in either the Macintosh or Windows versions of the 1994 re-release of Spaceship Warlock, nor did it pop up when I played it in the Macintosh emulator Basilisk II. This suggests there may need to be some manual tweaking to resolve file name discrepancies between different editions of Director games.

But there’s also an issue that can’t be easily addressed. In Spaceship Warlock, certain transition scenes are meant to linger on the screen while the game reads data from the CD-ROM. That doesn’t happen here. For instance, before Spaceship Warlock loads the game over sequence, the game displays a message narrating your defeat that’s meant to hang around for a few seconds while the next scene loads. In ScummVM, without being dependent to the original CD-ROM hardware, there are no visible load times, and the scene passes instantly.

Director games have a lot of loading transitions, and the games clearly benefit from faster loading times. But in limited cases like this, long load times are important for artistic effect. This opens up a bigger question about what constitutes the most authentic experience — a question that, admittedly, might be outside the scope of ScummVM’s development. Some emulators like ViceC64 (Commodore 64) and FS-UAE (Amiga) reproduce the slow loading times of the original hardware (loading off a floppy disk or a cassette tape), which may be important given the cherished place that Commodore 64 loading screens play in the platform’s culture. In fact, other games in ScummVM already simulate slow CD-ROM loading speeds!

I don’t think that Spaceship Warlock would benefit from pausing every few seconds while the game loads the next area, like it was reading data off a 1x speed CD-ROM drive, but then there are one-off situations, like the game over sequences, where the game itself might actually need to be altered to reflect the original intent of those scenes. If Spaceship Warlock is ever commercially released with ScummVM, this is something that Joe Sparks, the co-creator and rights holder of Spaceship Warlock, would need to consider. Other developers would need to ask that about their own games as well.

(Oddly enough, this is the opposite problem that game re-releases usually encounter! Usually the issue is whether to improve or speed up the game to reflect the designers’ intent, not whether to intentionally slow it down!)

L-ZONE

L-ZONE by Synergy Inc. from 1992 was among the earliest games to use QuickTime, a video codec by Apple that became a staple for CD-ROMs and was widely used on both Macintosh and Windows. Spaceship Warlock has plenty of animated sequences, but the extensive use of audio and video in L-ZONE make it another great test candidate for this early state of Director support.

Unfortunately, my experiences running L-ZONE suggest that the version difference issues on Spaceship Warlock were not a fluke. The ScummVM team may have their work cut out for them accounting for the myriad different releases that Director games would have.

In the case of L-ZONE, it’s simple: The Macintosh version of the game can be completed, but the Windows version can’t. Early into the game, the player takes a psychedelic train ride through an abandoned underground facility (if this sounds cool, then you should really really play L-ZONE). On the Macintosh version, the player can disembark the train, but in the Windows version, ScummVM sends out an error message similar to the one from Spaceship Warlock:

WARNING: Movie R_A:CAR_A01B does not exist!

I won’t pretend to understand how ScummVM development works, but this feels like a pattern. While each version of Spaceship Warlock and L-ZONE is playable and seemingly identical on the surface, it looks like a minor discrepancy in file naming or file structure causes a loading error that renders one version of the game unfinishable. Unless there’s a common root problem here that can be fixed across the board, I imagine that troubleshooting minor differences between all the different releases of these games could end up being a nightmare. (We’ll get to an extreme example of this later on.)

The good news is that everything else in L-ZONE works terrifically. When I wrote about L-ZONE last year, I noticed that the Windows version of the game crashed almost immediately in DOSBox during the first QuickTime video sequence. No such problems were present in ScummVM. The QuickTime integration is perfect.

That’s notable because QuickTime has been a hang-up for emulating Director games in the past. When I went to the Theresa Duncan event at Rhizome in New York in 2015, archivist Dragan Espenschied pointed out that one of the challenges of pre-configuring their Macintosh emulator was determining which version of QuickTime to use with each game for the most authentic experience. I don’t know how the ScummVM team chose to implement QuickTime, but it appears they nailed it on the first try.

Even with a major bug that prevents the game from being completed, L-ZONE already runs better in ScummVM than in other emulators!

 

Here there be dragons

Those are the only two games currently supported by ScummVM. However, the ScummVM engine will still attempt to run other games made in Director, with varying degrees of success in its current state. The ScummVM team has advised that “[s]elected Director 3-based titles may work,” but there’s no guarantee that they’ll even boot up. Anything developed in Director 4.0 and beyond is, at this point, experimental.

With that in mind, we’re gonna keep going further and see what happens when we try running more advanced Director titles in ScummVM. Please keep in mind that none of the games beyond this point are officially supported by ScummVM yet. The fact that they run at all is a testament to the ScummVM team’s incredible work reverse-engineering the Director engine so far!

Beyond the Wall of Stars

As you might expect for a game designed by Choose Your Own Adventure author R. A. Montgomery, Beyond the Wall of Stars is a digital choose-your-own-adventure storybook. Apart from some basic motion graphics and transition effects, the game uses very few special features of Director, instead creating the story out of individual static scenes, closer to a PowerPoint presentation than an open adventure game like Spaceship Warlock.

Because of its simplicity, Beyond the Wall of Stars mostly runs without a hitch in ScummVM. Even though Director 3 isn’t officially supported yet, the limited use of multimedia and interactivity in Beyond the Wall of Stars means that the game can be completed, beginning to end, without interruption. I was worried about one minor feature, where the player enters their name at the start of the game and it re-appears throughout in the story, but it seems to be fine! Currently, only the Windows version runs in ScummVM; the Macintosh version returns a black screen with a string of error messages.

One recurring improvement I’ve noticed with ScummVM is that transition effects between scenes — which are missing when the games run under DOSBox —  are present again. In Beyond the Wall of Stars, there’s supposed to be a wipe effect between scenes, like turning the pages of a book. Having the effect back improves the feel of the game and gives it a little more character.

The one feature that doesn’t work, however, is bookmarking. Bookmarks in Beyond the Wall of Stars act like save files, allowing you to jump back earlier in the story and explore other choices. Clicking the “Place A Bookmark Where I Am” button seems to do nothing, which may mean there’s more work to be done to deal with Director scripting.

One other interesting inconsistency is how ScummVM handles fonts. Above, you can see the same scene in two different programs. The left side shows the Windows version of the game being run in DOSBox, while the right side shows it running in ScummVM in Windows 10. As you can see, they seem to use different fonts, which is an unexpected problem. Arguably, it looks cleaner in ScummVM (the paragraph spacing is improved), and even though it’s less technically accurate, it might be more accurate to the original intent of the scene!

This seems to happen whenever Director tries to use the default Windows system font, something that can also be seen the caption text in Spaceship Warlock. There may be situations where Director is looking for specific fonts that don’t exist in the host operating system, and I’m not sure how the ScummVM team will be able to account for that. (The ScummVM console log occasionally mentions that it can’t find a file called “classicmacfonts.dat,” which indicates some groundwork for supporting non-OS fonts, even though it seems to be non-functional right now.)

Chop Suey

The ScummVM team has stated that Chop Suey is one of their test targets for Macromedia Director 4 support, perhaps because of the high-profile preservation attention it received back in 2015 from Rhizome. But there’s another reason why it’s an interesting test candidate: it uses some pretty advanced Director techniques!

ScummVM contributor Nathanael Gentry has singled out Chop Suey for using a kitchen sink of advanced Director techniques that make it a prime test subject. He points to a number of particular features, like custom cursor graphics and the game’s use of “inks,” different methods for rendering and overlaying graphics on-screen.

But the most notable feature that Chop Suey extensively uses is Lingo, a scripting language introduced in Macromedia Director 2.0. Lingo scripting is one of the building blocks of Director games, especially later titles that got more complicated. Without investigating too closely, a relatively simple storybook game like Beyond the Wall of Stars appears to use little to no Lingo scripting; meanwhile, Gentry called Chop Suey a “Lingo-heavy game,” something that has consequences as far-reaching as the rendering speed of the game’s graphics. Lingo is a crucial component of Director (as we’ll find out throughout this article), so important that the team collaborated with the original author of Lingo, John Henry Thompson, to better understand how it works.

The effort seems to have paid off. As you can tell from those blog posts, Chop Suey has received special attention, which explains why it runs so great in ScummVM, apart for a few rough edges. (I tested the Windows 3.1 version, and for whatever reason, I spotted most of these issues in the picnic scene.) Some but not all objects animate too quickly, as if they’re still dependent on computer performance, rather than the consistent speeds seen in Spaceship Warlock. Additionally, the hi-fi radio at the picnic failed to play music:

WARNING: varFetch: global variable gSongStart not defined!!

But throughout my experimentation with Chop Suey, I don’t think I encountered a single Lingo-related error! Again, maybe it’s because ScummVM’s Lingo support was built around this game in particular, but it’s a great sign of progress for ScummVM’s Director implementation that I didn’t notice any glaring performance or media playback problems in a game that Gentry says used to be resource-intensive and sluggish. No wonder this is their ideal test candidate!

Eastern Mind: The Lost Souls of Tong Nou

Osamu Sato’s surrealistic magnum opus is another game that’s notoriously difficult to emulate well. In large part, that’s because the game’s speed is tied to the speed of the computer that it’s running on, like Spaceship Warlock, causing the game’s frequent character animations to jerk around erratically under DOSBox. The other problem is that, for whatever reason, the version of QuickTime that comes included with Eastern Mind doesn’t actually play the videos in DOSBox! It wasn’t until I installed a different version of QuickTime from another CD-ROM that I could actually watch the video clips in Eastern Mind as they were intended.

In that respect, Eastern Mind in ScummVM is already a major improvement. There are timing issues related to video playback, where Director won’t pause while a QuickTime video is playing. But like all the previous games, the speed is regulated well, and the transition effects are back in place. Once ScummVM support is more robust, this will be the best way to play this essential, overlooked game.

Except that the game freezes up almost immediately. During the opening sequence, when the white snake gives you an Amulet and a Furoshiki, clicking on the items does nothing, and the game is unable to progress. Clicking on either item returns back an error message:

WARNING: Lingo::getTheEntity(): Unprocessed getting entity doubleClick!

This is a sign that ScummVM needs more time in development before it can fully handle Lingo scripting. But for the brief time that Eastern Mind does work, it’s very promising. I’ve talked in this post about how ScummVM could allow Director games that haven’t been available in decades to be re-released, and although Osamu Sato seems like an artist who’s more interested in remixing his past work than revisiting it, Eastern Mind — a bold, experimental art game that seems like it didn’t find an audience when it first came out — feels like a strong candidate for a re-release powered by ScummVM.

Wrath of the Gods

Much like Eastern Mind, the live-action educational Greek mythology game Wrath of the Gods works up to the point when Lingo scripting starts to get complicated. The Macintosh version plays normally through the first screen of the game, when the live-action character Chiron the Centaur sends you on your quest. As soon as you move to the next screen, something breaks the Lingo script, and the game doesn’t know how to interpret any more of your commands:

WARNING: ###################### LINGO: syntax error, unexpected tINT: expected '\n' at line 116 col 10 in MovieScript id: 1!
WARNING: # 114: end if!
WARNING: # 115: !
WARNING: # 116: macro w3.1!
WARNING: # ^ about here!

Again, this is an issue that will probably be fixed as Lingo support in ScummVM becomes more robust.

One other noticeable bug is that the cursor in Wrath of the Gods is supposed to change each time you click on a different command (walk, speak, look, etc.). This doesn’t happen yet, which is unusual since custom cursor graphics are extensively used and supported in Chop Suey. ScummVM does send back a specific cursor-related error message when trying to read the cursor graphics, which suggests that it might be an issue reading the specific graphics format used by Wrath of the Gods:

Cursor::readBuiltinType failed to read cursor 116!

Wrath of the Gods works fairly well in both Classic Mac OS and Windows 3.1 emulators, so it’s less of a surprise to see the game running at a consistent pace in ScummVM (compared to Spaceship Warlock or Eastern Mind). Despite the Lingo-related setbacks, it’s still great to see this unique game working again. The Macintosh version, at least. The Windows version of Wrath of the Gods instantly crashes so hard that it brings up the internal ScummVM debug console.

The Journeyman Project

Remember when we talked about what a nightmare it would be to have to fix compatibility for multiple different versions of the same game? The Journeyman Project is as close as we’ll come to a worst-case scenario. There were three different releases of the game for Macintosh (1.0, 1.1, and 1.2), as well as a Windows port published by Quadra Interactive. In addition, the game got a revamp on both platforms called The Journeyman Project: Turbo!

Ignoring the Windows version of Turbo, which was not created with Director, that leaves four separate versions of The Journeyman Project that need to be tested. Yeesh!

The earlier, pre-Turbo versions of The Journeyman Project suffer from deep performance issues that make them difficult to complete, which is why the game was repeatedly re-released. (Journeyman Project superfan Keith Kaisershot has advised me to steer clear of the Quadra Interactive version altogether.) At this stage, it’s difficult to evaluate how well ScummVM would run programs that perform poorly to begin with — or whether rebuilding the engine in ScummVM might fix those issues — so for the sake of simplicity, we’ll only be looking at the Macintosh version of Turbo. (Although I have access to Journeyman Project version 1.2 for Macintosh, various file system conversion issues prevented me from testing it.)

Right now, on Windows, Turbo for Macintosh won’t progress beyond a black screen, and the problem seems to be related to how ScummVM parses filenames. When I first tried running Turbo in ScummVM 2.5.0, the program wouldn’t even identify it as an executable. As I eventually determined, the problem is that there’s a trademark symbol (™) in the filename. Deleting the symbol allowed the program to run, but once the game booted up, it sent back this error message:

WARNING: Movie Journeyman TurboΓäó:Support Files:First Film does not exist!

The game uses the trademark symbol internally as well! Γäó is the garbled mojibake version of ™, which explains why the game files weren’t loading. Based on results from the mojibake repair tool ftfy, this seems to be an error converting from Mac OS Roman text encoding to DOS Latin US (ie., converting from Mac OS Classic filename to a Windows filename), so this might a unique issue that occurs when trying to run the Macintosh version of the game under Windows using the ScummVM Dumper Companion. Either way, ScummVM may need to address how it handles text encoding to make this game run.

(If you want to learn more about mojibake, check out Robin Speer’s talk from !!Con 2021. It’s very informative and helped me understand this issue better!)

The Journeyman Project: Turbo! also comes with a collection of sizzle reel demos for The Journeyman Project and its sequel, Buried in Time, which give us a good idea about what we could expect from compatibility right now. Right now, the demos have problems with looping audio, as well as some timing issues that seem to be related to multimedia playback, like in Eastern Mind. Most interestingly, some video clips fail to play, with ScummVM reporting that there’s a decoder issue:

WARNING: DigitalVideoCastMember::createWidget: No video decoder!

It may be that certain versions of QuickTime aren’t supported yet, despite some of the earlier QuickTime successes we had.

 

Things that don’t work yet

It’s remarkable that ScummVM’s Director support already seems to work across so many games, even if it’s partially complete. Just for fun, let’s also look at some games that straight-up don’t run at all, in case they can tell us anything useful about the current state of Director implementation.

Microsoft Encarta ’95

I was shocked to see the Encarta ’95 encyclopedia on the list of titles being targeted by ScummVM! The Macintosh version of Encarta ’95 was developed with Director 3.1.3, which means we might be able to play MindMaze, the trivia game bundled with Encarta ’95 that’s fondly remembered by weird bookish kids who grew up in the 90s. We’ve gotta try it.

Welp. This is what Encarta ’95 looks like right now. That weird black shadow is supposed to be the cursor. In any event, this one is not even remotely supported yet, so there’s apparently lots of work to go still on Director 3.

(For the record: the ScummVM team told me that MindMaze is a separate application outside of Encarta ’95 that does not use Director, so unfortunately, no luck there.)

GADGET: Invention, Travel & Adventure

My Windows copy of the bizarre hyper-linear horror epic GADGET doesn’t run in ScummVM yet, but there’s an interesting reason why it doesn’t. When I first added the game, ScummVM misidentified it — not only as the demo version of GADGET, rather than the full version, but also as an unknown variant. Although I could still run the game, it quickly sends back the error that it can’t find the game files:

WARNING: Archive::openFile(): Error opening file GA00.MMM!
WARNING: openMainArchive(): Could not open 'GA00.MMM'!

Taking a closer look in DOSBox, it seems that, by default, the Windows version of GADGET will attempt to look for the game’s data files on the probably-non-existent F drive. As a workaround, the shortcut that Windows 3.1 creates for GADGET also specifies a “working directory” where the files are actually located. You can replicate this effect in ScummVM by adding the data files as the “Extra Path” in the game’s settings. This is something that ScummVM will have to manually account for in the future.

The game does start up if you fix this; unfortunately, it locks up shortly after, encountering the same video codec error encountered in the Buried in Time demo. So close! The most salient lesson here is that even though the ScummVM team can pre-configure games like GADGET to look for files in the right locations, it might pose an issue for running unidentified Director games that require installation or have an unusual file structure.

Star Trek: The Next Generation Interactive Technical Manual

I don’t usually get a chance to talk about this on here, but I’m openly a big Trekkie. Kira forever.

The Interactive Technical Manual CD-ROM is a virtual walkthrough of the sets from Star Trek: The Next Generation using QuickTime VR, an early plugin for displaying 360° panoramic images. I expected to run into problems with QuickTime VR, but before you can even get that far into the program, we run into another issue: the Windows version won’t run off the CD! The program is looking for an .ini file that only appears if you’ve installed the program — which you can’t do on a modern 64-bit computer! However, trying to run a pre-installed version of the game doesn’t seem to work either. (The Macintosh version, which doesn’t need to be installed the same way as the Windows version, does not encounter these issues, but it does crash as soon as a VR panorama is supposed to appear.)

This is another example where the ScummVM team may have to do some manual massaging for individual games. Maybe they would have to supply a pre-configured file to make this game run off the CD correctly. As far as QuickTime VR, that’s a bridge they’ll have to cross later.

Shaka, when the game crashed!

 

Takeaways

We’ve gone through ten examples in this article! We could keep going forever, testing further and further along the development timeline of Macromedia Director, but I think we now have a good idea how this software will run. So what did we learn?

First off: It works! It actually works.

Despite all the issues that still need to be ironed out, Macromedia Director really does work in ScummVM. For the first time, it’s possible to play these games in a platform-agnostic environment, without being dependent on the underlying operating system. Most games run at a steady pace compared to their erratic performance in other emulators. Even in its early, unstable stages, this is a huge victory.

Right now, simpler programs using less multimedia work better. Interactive storybooks like Beyond the Wall of Stars, for example, run almost perfectly. ScummVM already has support for some QuickTime videos, and although it’s still incomplete and has occasional playback issues, it works fine in L-ZONE, the only Director game officially supported by ScummVM right now that uses video clips.

The most obvious work to be done is improving support for advanced Director features, especially Lingo scripting, which became more heavily used in games built on later versions of Director. Whenever a Director game soft-locked in ScummVM — that is, when the game became unplayable without actually crashing — it was often because of a problem interpreting Lingo script. Eastern Mind and Wrath of the Gods are great examples of this: interactions as simple as clicking on the screen, one of the most common actions in Director programs, became impossible when ScummVM hit a line of script that it couldn’t understand. This is an area where the ScummVM development team is already dedicating time and resources, and it will be great to see it develop out further.

The other notable issue right now isn’t related to game content but, instead, how ScummVM and Director handle file structures. There’s seemingly a number of places where ScummVM has trouble with filenames and file locations, which may be related to the Mac-to-Windows file conversion process. It’s possible that individual games may need some TLC to resolve discrepancies between versions — like the problems that cropped up between different versions of Spaceship Warlock, or the inability to find the correct file directory for GADGET — but there may also need to be broader changes to how different platforms handle Macintosh filename conventions and character sets.

And again, it works! Despite only officially supporting two games, Director support for ScummVM is already far enough along that it can partially run many other games as well. It feels like a magic trick. Bravo to all the ScummVM contributors for their work so far!

 

Future development

Development on ScummVM continues! If you’d like to support their work, click the donation button on the ScummVM homepage.

In the meantime, if you want to get into the weeds on technical stuff, there’s a couple options for you to follow along. You can follow the Trello board (basically a fancy to-do list) that the ScummVM team is using for further work on Director support. You can see them investigating specific bugs and features here, which gives you an idea of how they’re prioritizing development. If you’re curious about how the ScummVM team has been building out support for advanced Director features, like the inks used in Chop Suey, Nathanael Gentry’s blog is a good technical read on the development process. You can also join the ScummVM Discord server, where development updates happen in real-time.

Additionally, the ScummVM team is always looking for more titles they can add to ScummVM’s list of known games. You can directly contribute new games by adding them to the detection_tables.h file on the ScummVM GitHub (see this commit from Misty De Meo for an example of how to contribute).

I haven’t submitted any new Director games yet… but I did submit support for Murder Dog IV: Trial of the Murder Dog, one of the very best and silliest games ever.

(This post was updated on October 31, 2021 with corrections from the ScummVM development team. Thanks to the team for the comments — and the reminder that ScummVM is technically not an emulator!)