This article is about the development of the 1998 video game Tom Clancy's Rainbow Six.


Rainbow Six and Red Storm Entertainment were simultaneously conceived in the fall of 1996. After spending a weekend brainstorming game ideas it was unanimously agreed that they would develop a game called HRT, based on the FBI's Hostage Rescue Team.


The first treatment of the game was finished a few weeks later and was named Black Ops. The scope of the game had been expanded beyond hostage rescue to include covert missions. Gameplay consisted of a planning phase followed by an action phase. Players would have to create a team from a pool of operatives with different strengths and weaknesses. Combat would be quick and deadly, one shot could kill but the targeting model would favor cautious gameplay over run-and-game gameplay typical of first-person shooters of the time.

With the shift in focus away from being strictly hostage rescue, a lot of different Black Ops back stories were suggested in design meetings, ranging between the World War II era to near-future settings. The developers considered setting the game in the 1960s at the height of the Cold War, giving it an Austin Powers/Avengers feel.

The game was not originally tied in with the Rainbow Six novel. Although Clancy had been part of the original design session and responded enthusiastically to the HRT concept, he had not yet decided to make his next novel about hostage rescue. They eventually converged on the Rainbow Six back story in early 1997 but didn't realize they were paralleling Clancy's novel until almost April. Red Storm had been exchanging information with Clancy the entire time so they were able to bring the game in line with the novel without too much extra work. However, due to scheduling constraints the game's final missions had to be completed several months before Clancy finished writing and so the game and the novel ended up having different endings.


The original Rainbow Six development team consisted of Brian Upton and one other programmer. Red Storm Entertainment had begun development on four titles (including Rainbow Six) and all the development teams were understaffed for the first few months. The first artist for the Rainbow Six development team arrived in the spring of 1997, followed shortly after by a full-time producer. Progress was slow because of the small size of the development team. During that first winter and spring they only had time to create a rough framework for the game.

Several crucial pieces of technology were licensed to compensate for understaffing and gaps in their schedule, including the 3D renderer and networking technology. Their parent company, Virtus Corp., had been working a next-generation rendering library for use in its line of 3D tools. The developers decided to save themselves work by building on top of the Virtus renderer, rather than developing their own. At first, they believed this to be an ideal solution to the problem. Virtus had been doing 3D applications for years, and the renderer that its engineers were working on was a very general cross-platform solution that ran well with lots of different types of hardware acceleration.

The developers also went out of house for the networking technology. They had researched a variety of third-party solutions, including Microsoft’s DirectPlay, but they weren’t satisfied with any of them. Just as they were on the verge of deciding that they'd have to write their own library, a local development group within IBM contacted them. The group’s engineers were interested in finding uses for their powerful new Java-based client/server technology. The technology, called Inverse, was designed to allow collaborative computing between large numbers of Java applets. The IBM engineers wanted to see how it would perform in a number of different application domains, including games. Inverse supported all of the features that they wanted in a networking solution, such as network time synchronization and reliable detection of disconnects, so after much deliberation they decided to use it for Rainbow Six. Eventually, they would come to regret both of these third-party technology decisions, but not until months later in the project.

Over the summer of 1997, they acquired most of the motion capture data that was used for animating the characters in the game. One of the advantages of working with Tom Clancy was that he put them in touch with a wide variety of consultants very quickly. Among the many experts they spoke with to get background information on counter-terrorism were two close-quarters combat trainers who worked for the arms manufacturer Heckler & Koch. When it came time to do the motion capture, these trainers volunteered to be the actors. They spent a couple of days at the Biovision studios in California being videotaped running through every motion in the game. Using real combat trainers for the motion capture data represented one of the better decisions. While a professional actor might have been tempted to overdo the motions for effect, these guys played it absolutely straight — the results are impressive. The game’s characters come across as serious and competent, and are twice as scary as a result.

Crisis came in October of 1997. They'd been working hard all summer, but they were slipping further and further behind schedule. Partially, the delays were the result of Upton being completely overloaded. Partially, they were the result of the ambitious scale of the project: because the plot of Clancy’s evolving novel was driving level design, they'd committed themselves to creating sixteen completely unique spaces — a huge art load. And partially, they were the result of the fact that the "time-saving" technology licenses that they'd set up were proving to be anything but.

Inverse was a great networking solution — for Java. Unfortunately, they wrote Rainbow Six in C++. Initial research had suggested that mixing the two would be trivial. However, in practice the overhead involved in writing and debugging an application using two different languages at the same time was staggering. The interface code that tied the two parts together was larger than the entire networking library. It became clear that they'd have to scrap Inverse and write their own networking solution from scratch if they were ever going to get the product out the door. However they did continue to use Inverse for Java-based products, including Politika and Ruthless.Com. The problems they faced didn’t arise from the code itself, but from mixing the two development environments.

They also had problems with the Virtus rendering library. As they got deeper and deeper into Rainbow Six, they realized that if the game was going to run at an acceptable frame rate, they were going to have to implement a number of different renderer optimizations. Unfortunately, the Virtus renderer was a black box. It was designed to be a general-purpose solution for a wide variety of situations — a Swiss Army knife. With frame rates on high-end systems hovering in the single digits, they quickly realized that they would need a special-purpose solution instead.

In early November 1997, they put together a crisis plan. They pumped additional manpower into the team. They brought in Erik Erikson, their top graphics programmer, and Dave Weinstein, their top networking programmer, as troubleshooters. Brian Upton stepped down as lead engineer and producer Carl Schnurr took over more of the game design responsibilities. The original schedule, which called for the product to ship in the spring, was pushed back four months. The artists went through several rounds of production pipeline streamlining until they could finally produce levels fast enough to meet the new ship date. Finally, they took immediate action to end reliance on third-party software. They wrote an entire networking library from scratch and swapped it with the ailing Java code. Virtus graciously handed over the source code for the renderer and they totally overhauled it, pulling in code they'd been using on Dominant Species, the other 3D title that Red Storm had in progress at the time. All this took place over the holiday season. It was a very hectic two months.

From that point on, the development effort was a sprint to the finish line. The team was in crunch mode from February to July 1998. A variety of crises punctuated the final months of the project. In March, Upton came back on board as lead engineer when Peter McMurry, who’d been running development in Upton's place since November 1997, had to step down for health reasons. As they added more and more code, builds grew longer and longer, finally reaching several hours in length, much to the frustration of the overworked engineers. The size of the executable started breaking all the tools, making profiling and bounds checking impossible. In order to make the ship date, they had to cut deeply into testing time, raising the risk level even higher.

On the upside though, the closer they got to the end of the project, the more the excitement started to build. They showed a couple of cautious early demos to the press in March 1998 and were thrilled by the positive responses. (At this point, they were so deep into the product that they had no idea of what an outsider would think.) The real unveiling came at the 1998 E3 in Atlanta, Ga. Members of the development team ran the demos on the show floor — for most them, that was the longest stretch they had playing the game before it shipped. Almost all of the final game-play tweaks came out of what they learned over those three days.

Rainbow Six's development cycle was 21 months.



Community content is available under CC-BY-SA unless otherwise noted.