Skip to content

Adobe Captivate

Pages about Adobe Captivate.

One of the easiest ways to make use of Adobe Captivate variables is to display their values in text captions, shapes, and Smart Shape objects at run-time. In the example below I show how this is done by inserting several display fields into a single text caption.

How to display project information

Let’s imagine your project needs to have the e-learning author’s name and contact information appear on a slide at run-time. Here’s how you could do that:

  1. Create a new blank project and open the File > Project Info… (This is quicker than navigating to the same dialog location using Edit > Preferences > Project > Information.)
  2. Type relevant information into the fields provided.
  3. On another slide in your project file, insert a text caption and some text to indicate the type of information it provides.
  4. Place your mouse cursor at the point in the text caption where you want to insert the variable display field.
  5. On the Properties tab > Format accordion, click the Insert Variable icon.
  6. When the Insert Variable dialog opens, change the Variable Type to System and from the Variables drop-down list select cpInfoAuthor as the variable to be inserted.
  7. Pay close attention to the default value shown in the Maximum length field. It has some serious gotchas!
    Gotcha # 1: In earlier versions of Cp this field was set to 15 characters by default. This length is fine if all you are doing is displaying a number, identifier code, or slide name. But it’s usually too short to display personal names, company names, course names, etc. In Cp7 the default length has been increased to 50 characters, but you can change it to specify any length up to about 250 characters. So give careful thought to how much information you need to display and set the field length accordingly.Gotcha # 2: There is a bug in versions prior to Cp7 where if you happen to be inserting a number of variables one after another, the Maximum Length field randomly reverts to a value of 0. So be sure to take a moment to check this field before hitting the OK button.

    Gotcha # 3: If you happen to guess wrong about the required number of characters to allow as the length of the display field, you cannot easily change it. You must delete the inserted field and re-insert another one to change the display length. So it’s usually wise to bet a little on the high side to be safe.

  8. Once you’re happy with the details of the inserted variable, click the OK button. Your variable will appear by name, surrounded by double dollar signs (e.g. $$cpInfoAuthor$$).
  9. Repeat the last few steps to insert any other variables in the same caption. It should then appear something like the example screenshot shown below.
  10. Publish your project to see how the variables are displayed in the caption. They should look something like the screenshot below.

Why not just type the variable name with $$ characters on either end?

Perhaps you’ve read throught the steps above and wondered if you can insert a variable into a caption or shape by just typing the variable name and adding $$ characters at the beginning and end. Yes you can.

However, while it may be slightly faster, the downside to this method it that it doesn’t allow you to set the number of characters for the maximum display length. It will just assign the default amount, which is only 15 characters for Cp versions 5 through to 6.1 and 50 characters for Cp7.  The 15 character default was far too small, and even 50 characters will sometimes be insufficient.

So, call me a control freak, but I still prefer to insert variables via the dialog method and set the display length myself.

Overcoming dynamic text formatting issues

When you insert a variable into a caption or shape, don’t be surprised if you need to fiddle around with the formatting a bit before it all looks right at run-time. These formatting issues are due to the fact that normal caption text is ‘static text’ (because it doesn’t change at run-time) while variable display text is ‘dynamic text’ (because it can change depending on the current value of the variable being displayed). In Captivate’s published output, captions containing static text are actually converted into images. But since this means the text becomes an image too, this approach would not allow dynamic text to change on-the-fly at run-time. So, static and dynamic text strings are kept separate. The result can be certain inconsistencies in visual formatting.

For example, some early versions of Captivate did not allow dynamic text to be indented. If you applied indenting in Edit mode, the indenting disappeared at runtime. If you added variable text into the middle of a paragraph of static text in a caption, none of that text would honor the applied formatting. This often resulted in captions with text unattractively crammed into the top-left corner or positioned hard against the left side of the caption. There were also notable differences in the aliasing of the text. For example note the differences in the two run-time captions below from Cp 5.5.

The text in the caption above left is just typed in. The one on the right is displaying text supplied by a user variable. The workaround for such formatting issues is to place dynamic text inside a transparent caption positioned on a layer above another caption. This made it appear as if the underlying caption contained the dynamic text when in fact it was just acting as a background.

Fortunately, these issues have been steadily diminishing with each new version and it’s now quite difficult to tell static and dynamic text apart as you can see from the Cp7 examples shown below.

Hopefully one day, in some future Cp version, there will be no discernible differences at all.

This article introduces and explains Captivate variables, including what they are, the different types of variables, how to insert them, name them, and use them to display information in an e-learning module at run-time. You need to have a good understanding of variables because they are essential components of many user interactions you can create with Adobe Captivate.

About Variables in Adobe Captivate

All programming languages use variables to temporarily store values that can then be used by other parts of an application. Some people think of variables as being ‘containers’ or ‘buckets’ into which you place values such as numbers or strings of letters. However, technically variables work more like pointers or identifiers that link to or reference their values in the computer or browser’s memory.

To use Adobe Captivate’s Advance Actions you don’t really need to worry too much about the technical aspects of how variables work ‘under the hood’ in programming languages. All you need to know is that variables store values and you can usually change those values using advanced actions. In Captivate’s terminology, you are said to ‘assign’ the value of a variable when you use an action to change it.

Captivate has a few different types of variables, and you need to become familiar with all of them in order to create advanced interactivity.

System variables

These are variables that come pre-defined with Captivate and are designed to allow you to monitor or modify what the system, i.e. your e-learning module, is doing at run-time. However, you cannot create new system variables yourself to add to the Captivate application and you cannot change their names and, since all variable names in a Captivate project must be unique, you cannot create User Variables (explained below) and use the same name assigned for a System Variable.

This PDF document contains a printable list of all System_Variables_in Adobe Captivate 2019

Of the 70 or more system variables available in Captivate, only a dozen or so can be assigned values via advanced actions.  These are known as Command Variables and always begin with the prefix cpCmnd.

All other System Variables are READ-ONLY at run-time (as indicated in the appendix list mentioned above) which means you cannot dynamically change their values, only reference them for information about the current status of the system.

User variables

These are variables that you, the developer, can create and name as you choose…as long as you don’t contravene certain variable naming rules (see below). Furthermore, any name you assign to a user variable must not conflict with Captivate’s internal functions, reserved keywords, exposed system variables, or other hidden variables.

This PDF document contains a printable list of all Reserved_Keywords that must not be used in Captivate as the name of a variable.

Hidden System Variables

There are of course hundreds of other hidden variables that Captivate uses internally, but you might as well forget about trying to use these in your e-learning. From time to time some clever developer will stumble across one of these by accident, usually as a result of accidentally naming a user variable with one of the 150 or so reserved keywords mentioned above.  The reason Adobe doesn’t publish lists of these hidden variables is that it might encourage technically savvy e-learning developers to try using them and then inevitably break some essential run-time function, or even corrupt their project file entirely.

Variable naming conventions

Naming Captivate user variables is a bit like naming your children. It’s worth taking some time to consider the ramifications of the moniker you assign, because once it goes on the birth certificate and the ink is dry it can be a major issue to change at a later date.

Similarly, whenever you create a new user variable you should pause and think carefully about the name you give it because once you assign a name to a user variable and save the new variable from then on you cannot change the name. You’re stuck with it.

If you later decide the name was a mistake, your only option is to create another variable with the correct name and then go through all the places (captions, advanced actions, etc) where you used the previous variable and reassign them to the new one. That’s more trouble than you want, believe me.

So here are some basic rules to follow when naming user variables:

You cannot begin a variable name with a number or a space character.

If you try to do so, Captivate will warn you that this is not allowed (as shown below).

Some developers like to begin all user variables with the letters V or v_ so that variables can more easily be identified in lists. However, this is not really necessary because variables and other types of Captivate slide objects (e.g. shapes or captions) are never shown side-by-side in the same selection lists. Also, since variables are sorted alphabetically in the dialog lists, if you do start your variables with the letter V, then they will all end up right at the bottom of the list and you might find yourself scrolling down to them all the time. That can get tedious. It’s your call, but I prefer to name my variables starting with a word describing their key function.

See this example where some variables are related to debugging functionality while others are related to displaying times and dates:

NEVER use reserved keywords as variable names

There are around 150 keywords that Captivate reserves for its own internal use and you must never assign any of these as the exact name of a user variable, but you can use keywords as part of a name.
Check out this page on the Captivate help system.

This PDF document contains a printable list of all Reserved_Keywords.

Although in theory Captivate should detect and prevent you from using reserved keywords as variable names, it doesn’t always seem to do this flawlessly. If you should inadvertently happen to fall into this trap, it could prevent you from being able to publish your project, throw error messages, or in a worst-case scenario, corrupt your project and render it unusable.  So, better to avoid the keywords just in case.

All variable names in a project must be unique

All variable names must be unique across any single CPTX project file. You can however use the same variable names in different modules of a course. In fact, you may need to do this when persisting variable values from one module to another.


CamelCase is a naming convention often used by software programmers. Words in the name all start with a capital letter, thus making the capital letters stand out like the humps on a camel. It’s not mandatory, but it is popular with professional programmers because it makes the words in a variable name easier to read at a glance and understand. Look at the example below and ask yourself which of the names is easier to read quickly:

  • myreallylonginvolvedvariablename
  • MyReallyLongInvolvedVariableName

Names should be descriptive

Once you really get going building interactive e-learning projects it’s quite likely you’ll be creating dozens, scores, or even hundreds of variables in a single CPTX project file. My personal record is just under 350 variables in a single module and it was functioning perfectly well. The problem with having so many variables is that you may forget what they are for. So, it’s wise to give some careful thought to how you might structure your variable names so that they are easy to locate in lists and will still make sense several years from now when you (or someone else) might need to come back and edit or update your course.  So, avoid names that will only make sense to you and nobody else.

Another suggestion you might follow is to use a prefix on your names that tells you what overall part of the interaction each variable belongs to.  For example, if you have a number of variables that are all used in the course navigation, you might begin all of their names with the word Nav_ as follows:

  • Nav_NextButtonState
  • Nav_BackButtonState
  • Nav_TOCItem

If you have a number of variables involved in a specific quiz interaction, then you may use a prefix such as Quiz_ or similar. Take a look at the screenshot below of part of the Variables dialog in one of my own projects. Can you tell from the names what each variable might be used for?

Whatever naming convention you follow, the point is that each variable name should be intuitive enough to make its purpose obvious without the next developer being required to laboriously trawl through the Variables dialog looking for descriptions. And while we’re on the subject…

Keep variable names less than 25 characters in length

The more descriptive your names are the better. But you also need to keep the names short enough to be easily read in any dialog box where they are likely to appear.  In practice this means that variable names in Captivate need to be no more than about 25 characters in length.  This means that although all of the names in the screenshot above can be easily seen in the Variables dialog, the ones with more than 25 character would have the ends cut off when seen in the Advanced Actions dialog.  Less is more.

Always add descriptions

Even though you go to great lengths to make your variable names self-explanatory, it’s still good to include text in the Description field of the Variables dialog to document what the variable will be doing or where it might be used. For example, if a particular variable will be supplying essential data to one or more Standard Actions or Conditional Actions, then you might list the names of their related actions in the description.

Since most e-learning developers never document their interaction designs for posterity, these descriptions may be all someone else has to go on when they are asked years from now to figure out how to update your project file.  You might go to all the trouble of documenting this same information in a document when you complete the project, but there’s no guarantee that document will still be easy to locate in several years time when the next person comes along to work on the same files.  However, if your ‘documentation’ is right there inside the project files, it’s always going to be available to the maintenance developer.

Boolean variables

One of the most common types of variables that you will need to use when working with advanced actions is the Boolean variable. This data type was named after George Boole, a mathematician who developed Boolean Algebra way back in the 1850’s, well before computers were ever thought of.

Unlike most variables that can hold any number of possible numeric or string (text) values, a Boolean variable can only hold one of two values. These are usually 0 or 1, TRUE or FALSE, YES or NO. A Boolean variable acts a lot like a light switch. The light is either ON or OFF.

You can set the value of a Boolean variable using the assign action, either as part of a Single Action, Standard Action, Conditional Action, or Shared Action (if it is one of the parameters). You’ll find Boolean variables particularly useful in conditional actions to store the result of a condition that checks whether something is correct or incorrect.

Migrating variables from one project to another

For many versions Captivate had no way to move variables or actions from one project file to another. But now you have two options to achieve this migration.

One ways is by using Shared Actions, because they have the ability to convert actions into a file that can be stored in the Captivate Library, exported from the initial project and imported into another. When this is done, all variables referenced by the Shared Action are migrated along with it and recreated in the new project file location at the time of import.

The other way is simply copy any slide or interactive object (e.g. button) that has events set to trigger an Advanced Action and then paste that slide or object into another project.  The related actions and variables are all then recreated in the new project.

However, there is a catch. If the target project already contains variables of the same, the incoming variables are renamed with a number appended to the end.  And since we cannot rename variables after they are created, this can sometimes result in a bit of a mess. So, watch out for that issue.

About variable data typing

In most programming languages variables are ‘typed’, meaning that they are deliberately restricted to accept and store only certain types of values such as Booleans (0 or 1, true or false, yes or no), integers (numbers), or strings (text).
By contrast, Cp user variables are not typed. They’ll accept almost any numeric or text value you want to throw at them. (System variables are mostly READ-ONLY so their data is usually also of a fixed type.)

Although on the surface this freedom to store any type of value in a variable might seem like a good thing, it can also sometimes get you into trouble. For example, you may end up inadvertently trying to perform math functions on a string of text, or concatenating a number, which of course won’t work.

So this means the onus is on you, the Captivate developer, to keep track of what type of data your variables should hold. And that’s a lot easier to do if you keep your documentation and descriptions up to date.

Why Captivate has Advanced Actions

Wanting to open up more creative possibilities for e-learning developers, the software architects behind Captivate kindly provided a mechanism allowing non-programmers to customize interactivity of their e-learning content. This all comes under an umbrella term of “Advanced Actions”. It’s really just a simplified method of scripting to customize how Cp e-learning output works at run-time.

For me personally, advanced actions are THE killer feature of Captivate that make it my go-to tool for creating custom interactivity in e-learning courses.  Of course Captivate is by no means the first or only rapid e-learning authoring tool to have this capability. In fact most (if not all) other tools now offer some form of support for basic scripting of interactivity. As a professional e-learning developer, I have also used several other rapid e-learning authoring applications to create interactive e-learning.  But, for my money, Captivate just seems to take things that little bit further than the others.

Captivate offers four different ways to execute actions and uses the broad term Advanced Actions to encompass them as a whole. Here’s a quick summary of what they are and how they differ:

Single actions

Adobe just calls these Actions in the help files, but I prefer to use the term Single Actions because it better describes how they differ from the other types we discuss below. These are the actions you can assign directly to any run-time event via the Properties tab > Actions drop-down list.  These same actions are also available when creating interactivity with Standard and Conditional Actions. The main limitation found with Single Actions is that they only allow you to execute one action per run-time event (hence the reason for the word ‘single’ in my preferred name for them). If you need to execute multiple actions from a single event, then you need one of the next action types. Another limitation of Single Actions is that you have to set them up each and every time. You cannot save and reuse them as you can with the ones we discuss next.

Standard actions

These are re-usable actions you create via the Project > Advanced Actions dialog (or SHIFT + F9). They allow you to execute one or more actions in a sequence. After creating a Standard Action you need to give it a unique name and then trigger (execute) it using any one of Captivate’s dozen or more run-time events.  I don’t personally use many Standard Actions because I find the next type much more useful.  They give you the best of both worlds.

Conditional actions

I have to confess that I love Conditional Actions! They are the unsung misunderstood work-horses of interactive e-learning. But they have a well-deserved reputation for causing Captivate developers headaches. Like their simpler brethren, the Standard Actions, they also allow you to execute any number of single actions from a single run-time event, but with the bonus of being able to specify multiple IF>THEN>ELSE conditions that determine whether or not groups of actions get executed at all. This then allows your content to respond to user interaction and make decisions on-the-fly. And this is where Captivate gets really exciting!

In earlier versions of Captivate you could not mix-and-match Standard and Conditional Actions together. But the Advanced Actions dialog now allows you to build both Standard and Conditional Actions at the same time and execute all of them from a single event. The only real difference is that Conditional Actions have decision blocks that specify the conditions that will determine if the actions under that section will be executed, whereas a section that is set up as a Standard Action has no condition and will therefore be executed each and every time the run-time event fires.

Shared actions

Captivate version 7 introduced a new type of action called Shared Actions. In theory they allow Standard or Conditional Actions to be saved in a stripped-down ‘parameterized’ format that can then be shared with other projects by exporting from one project file and importing into the other. In practice Shared Actions can sometimes be more trouble than they are worth because once you create them you cannot (as of Captivate 2019) edit them to make changes after that. Other than making actions portable across projects, shared actions don’t really allow you to do anything more than the other action types. They have some slight advantages in terms of run-time performance if you have a situation where you are going to need to reuse the same Standard or Conditional Action many many times in a single project or across many projects.  That’s about the only time that I believe it is necessary to use them.

Can Advanced Actions really be called ‘programming’?

Strictly speaking, Captivate’s advanced actions would not qualify as ‘programming’ if compared to languages such as JavaScript, Java or C++, etc.  Many of the established concepts that are regarded as essential to modern object-oriented programming are missing completely from Advanced Actions and professional programmers often struggle to see why they deserve the adjective ‘advanced’ at all.  So it’s probably more accurate to refer to what we’re doing here as simple ‘scripting’ of interativity.

However, when you publish your project, Captivate converts your Variables and Advanced Actions into much more complex programming code that is executed at runtime.  When the output is HTML5, the final code will be HTMLJavaScript and CSS.  It’s likely to be far more complex code than you could have written by yourself (unless you’re already a talented programmer).  Captivate’s simplified (and somewhat clunky) interface shields you from the dizzying complexity that hides just ‘under the hood’ of the project CPTX file. And, although there are lots of limitations in what you can do, some very sophisticated results are still achievable within those limits.

What you CAN do with Advanced Actions

So what level of sophistication are we talking about here?  Well consider the following examples:

  • Create your own custom User Variables and display them in your content at runtime;
  • Use dozens of System Variables that Captivate exposes for you;
  • Use run-time events to execute Simple Actions chosen from a menu;
  • Define a series of actions to be performed in sequence, and save this as a Standard Action that can be reused and executed by events on any number of slides;
  • Create IF – THEN – ELSE conditional actions that determine whether or not certain actions (or sets of actions) are executed;
  • Create dynamic content that responds to user input;
  • Manipulate numeric variable values to calculate results or scores;
  • Hide or show objects at run-time;
  • Change the appearance of objects to indicate state;
  • Concatenate strings to assemble sentences or create your own custom date formats from component system variables;
  • Create dynamic navigation menus that indicate which sections a user has completed;
  • Simulate navigation components such as tabs, drop-down or fly-out menus;
  • Store user details in custom variables and then use these later in the content;
  • Create custom quiz interactions;
  • Share actions between projects.
  • Execute a WHILE loop.

The list of what you can do is long and growing as clever Captivate developers come up with new ways to bend the tool to their will.

What you CANNOT do with Advanced Actions

So what are some of the limitations mentioned above?  Here are just a few examples:


Each Captivate variable can only store one value.  This means you cannot create a variable as an indexed array containing multiple values.  Additionally, you cannot assign an object as the value of a variable.


As mentioned above, you can define a series of actions to be performed in sequence, and save this as a Standard Action or Conditional Action to be triggered by screen events or user interaction. But this is not really the same as being able to program with reusable functions.  For example, you cannot call one Advanced Action from another Advanced Action unless you happen to have the Infosemantics CpExtra HTML5 widget in your toolkit.

Complex Loops

A loop is a logic structure where the program asks a question, and if the answer requires an action, then it is performed and the original question is asked again and again until the assigned action is no longer required. Though Captivate does now allow you to create a simple WHILE loop as part of a Conditional Action, it has many limitations. So, if you need to do something more complex, you’d usually need to resort to JavaScript

Nesting of Advanced Actions

You cannot build an Advanced Action inside another Advanced Action.  If you need to have the same code in more than one action, you have to manually recreate the code in other clauses of the action, or copy and paste lines one at a time.  Trust me. It gets tedious fast.


This is an important programming concept that allows you to save code when creating new types of objects by appending or extending existing objects. This concept just doesn’t exist in Captivate’s Advanced Actions. So for example, you cannot use Advanced Actions to define a new type of text caption or highlight box. You cannot extend an existing Advanced Actions. Each is a standalone object.

What if I want to go beyond the limitations?

With such a long list of limitations it’s easy to see why hard-core programmers are unimpressed with advanced actions. They’re more accustomed to unlimited creative vistas. But on balance, most Captivate users are NOT programmers.  They’ve usually been thrust into the world of e-learning authoring because they just needed to create or deliver training materials. The truth is, Advanced Actions are really designed for non-programmers.

But, that doesn’t mean serious programmers are left out in the cold.


Once derided by programmers as “just a basic scripting language”, JavaScript has now grown up and is regarded as a cornerstone of web-based technology. It is based on the same international ECMAScript standard as many other languages.  It’s a loosely typed object-oriented language that is now the most popular programming language in the world, thanks in part due to the recent rise in popularity of HTML5.  If by some chance you’ve decided to create widgets for Captivate that will work in HTML5, then you will need to become adept at JavaScript.  This is beyond the scope of this discussion, however, there are many books and online resources available to learn the language.

Before you begin developing in earnest using Captivate’s Variables and Advanced Actions to enhance the interactivity of your Captivate content, I recommend you take a few minutes to set up a debugging environment. Doing so can potentially save you many hours of frustration wondering why your carefully-crafted interactions are not working as you expected.

There are a number of ways you can achieve this, but in the example below I use Smart Shape Buttons because they can be timed to display for Rest of Project and are therefore available for view on any slide after the point where they are inserted.

How to set up a DEBUG slide in Captivate

First we need to insert a Smart Shape timed to display for Rest of Project. This shape displays values of any important User Variables you need to check at some point. We use a Conditional Action (triggered by other Smart Shape Buttons) to toggle the visibility of this shape when it needs to be seen.

  1. Insert a new slide near the beginning of your project file or project template, but not as the very first slide. (Having too much complexity on the very first slide of a Captivate project is never a good idea because too much is happening in the background as that slide is loading.) Use graphics and captions to clearly indicate this slide is a debugging slide.
  2. Create a User Variable called DEBUG_MODE_ON, set to 0 by default, and another called DEBUG_MODE_INDICATOR_TEXT which contains whatever text you want to have showing as the label of the toggle button used to Show or Hide your debug variables. I set mine with a default value of DEBUG IS OFF.
  3. Insert another Smart Shape and select the option in Properties tab to Use as button so that it becomes a Smart Shape Button. Set the button timing to display for Rest of Project. You’ll need to make this button reasonably small and place it in an area at the top or bottom of the slide so that it will not end up in the way of other controls when testing the content at run-time but can still be easily clicked.
  4. Double-click this Smart Shape Button to add text and from the Properties tab, click the Insert Variable button. When the Insert Variable dialog appears, select the DEBUG_MODE_INDICATOR_TEXT variable from the User Variable list and click OK. This variable’s current value will now be displayed as the button label.  We will be changing the value of this variable later when the debug display is being toggled on and off.
  5. Insert a second Smart Shape and resize it to cover most of the slide but place it so that it does not cover your toggle button shape. This object displays any user variables you want to view at run-time. So add some explanatory text at the top to make it obvious.
  6. Both Smart Shapes should be situated at the very top of the layers on the DEBUG slide, and both should be set to display for Rest of Project. Only one is set to Use as Button. To make these objects easier to find, give them meaningful Item Names (as shown below).
  7. Now we need to create the conditional action that will toggle the visibility of the Smart Shape displaying your user variables. That conditional action looks like this:
  8. Test the functionality of the debug slide by clicking the Smart Shape button that triggers the Conditional Action to Show or Hide the Smart Shape that displays variable values.  If clicking the button shows and hides the shape as intended, so far so good. The label text in the button should change from DEBUG IS OFF when the variables are hidden, to DEBUG IS ON when they are visible.

Although your debug slide is ready for use, you may want to simply Hide it in the filmstrip until you actually need it.  Hiding a slide prevents it from being published in the output.  You definitely will NOT want this slide to become visible to your end users when the project eventually goes live.  So, be sure to hide the slide again before the final publishing of your course content for delivery.

How DEBUG MODE works

Now that you have everything setup, if you encounter any issues with Captivate’s interactivity, just go to the debug slide and into the large Smart Shape there (not the button) insert all variables that are related to the problematic functionality.  This would especially include any variables that are directly referenced by Conditional Actions, or that are dynamically assigned values by other Actions, Advanced Actions or Shared Actions.

Then unhide the DEBUG slide, preview your project as HTML or else publish to HTML5, and click the debug Smart Shape button to toggle the visibility of the other Smart Shape that displays the debugging variables.

When you have finished debugging, just hide your DEBUG slide again to turn off DEBUG MODE and immediately disable your debugging environment. That’s all there is to it!

In most cases what you will find is that some variable is not changing to the value you expected and that is why things are not working properly.  In my experience faulty logic in Conditional Actions is the usual reason for unexpected interaction behaviour. The big gotcha for many newbie Captivate developers is that all decision blocks in a Conditional Action get executed, not just the one where the condition evaluates to true. The order of the decisions is particularly important because a later decision may be changing the value of a variable that was correctly assigned by an earlier decision block. So, make sure you correctly understand how these work in Captivate. You can spend many fruitless hours debugging these things unless you can expose the values of the variables.

Can’t fit all your variables in one shape? Use two, or three!

One caption is usually sufficient to display all variables you need to monitor. However, you can add more captions to the debug slide if needed. Just place the rollover areas or toggle buttons side by side at the top of the slide so that you can call up each relevant caption or shape.

Add debugging to your project templates!

Since I started using this approach I’ve found it so useful when creating complex interactivity in Captivate that I now have this debugging environment built into any project templates I set up when working with clients for whom I create courseware.

It’s a little-known trade secret that many issues reported by Adobe Captivate users can be avoided or minimized simply by judicious configuration of Captivate’s Preference options. While some of the modifications recommended below can prevent file corruption or loss of work, other suggested settings just make using Captivate easier and more reliable to work with.  Captivate has hundreds of preference options you can configure.  But in this article I’m only mentioning those preferences that need to be changed to avoid issues, improve performance, or maintain reliability.

Global vs. project preferences

Once you know your PC is set up correctly to work with Captivate and the application itself has been installed correctly without issue, the temptation is to just dive in and start work. But before embarking on serious e-learning development you should set your Preference options.  But…here’s where it gets tricky. Take a look at the screenshots below of the same section of the Preferences dialog.

Unless you look carefully at the wording of the heading in your Preferences dialog you could easily miss the fact that some preferences are Global (applying across all projects) while others are limited to the Project file currently open in Captivate.  The trick here is that you can only set up Global Preferences when no Captivate project is open.  If a project file is open, any changes to preference settings will only apply to that specific file and no others open at the same time, or in the future.

General preferences

This section contains Global preferences. So make sure you set or change them without any project files open at the time, otherwise they will only apply to the CPTX or CPTL file currently being edited.

Generate project backups

Fortunately, it’s rare for a Captivate project file to become corrupted to the point where it becomes impossible to open or use.  For more information, check the topic on my website about recovering Captivate projects from backup.  Perhaps the easiest way to protect your project is just to set the Global Preference > General Settings > Generate Project Backup option (it’s deselected by default), and then make sure you save and close your project often.  This will at least allow you to get back to that last saved state to avoid disaster.

One thing to remember here though is that once you turn on the Generate Project Backup option, the backup file is not created until you save your project for the second time.  So it’s a good idea not to wait too long before doing save-and-close to ensure your backup file exists at all times from then on.

About backing up to a LAN or external drive
On the subject of backups…By all means back up your project files to a network or external drive if available so as to ensure you do not lose work if for some reason your development machine goes belly up, gets stolen, or suffers some other serious fate. But to avoid potential project file corruption, you need to perform this backup AFTER first saving your work in Cp and closing down the project file.  Additionally, never use Save As from within Captivate to back up the project file to the network. Use copy/paste in Windows Explorer to copy the project file over to your preferred backup location. 

Set Default Locations to point to local drive folders

When Captivate is first installed, the Preferences > General Settings > Default Locations > Publish At and Project Cache locations default to special folders inside the My Documents folder of your user profile.  If you work in a corporate networked environment you may be well advised to change these default settings to point to new folders on your C: drive, as shown below. Why would this be necessary? It’s because, more and more corporate IT departments are employing virtualization technologies and roaming user profiles , which means the user’s profile and My Documents folder may actually reside on a LAN server instead of on their PC hard drive. This practice is usually adopted to make it easier for the IT department to manage and protect company information assets. However, while these techniques do not bother most software applications, they will eventually land you in trouble with Adobe Captivate.

Turn off autosize and calculate options

These options are found under Preferences > Default and are usually on by default. Quite frankly they’re a nuisance. They automatically change the size or timing of screen objects such as buttons or captions after editing. If they are on, you can never relax when editing because you have to go back and check the the size of objects as well as their timeline duration anytime you make a change.

Recording preferences

These preferences mostly relate directly to how Captivate behaves when capturing simulations.  You can save yourself a lot of time and angst by changing a few of these settings.

Video Demo Recording

Anytime you use Video Demo Recording  (also known as Full Motion Recording or FMR in Cp versions prior to Cp 6), Captivate stores temporary files in a special folder buried several layers down inside your user profile.  Unless you know this location and periodically clean it out, these files can build up over time to become a significant drain on your hard drive space. So set your Working Folder to a location you can easily find and clean out without having to worry about affecting any other part of your system.

By default the Video Colour Mode is set to 16 bit colour as an attempt to keep capture file sizes smaller. This limits your captured graphics to 256 colours, which might have been fine when software interfaces had lots of flat colour, but is too low to smoothly render the typical gentle gradients used on most modern software interfaces. You should change this to 32 bit for most situations. Additionally, if you start with 32 bit, and find file sizes are an issue, you can always set quality settings lower when publishing.  However, if you start out at 16 bit there’s really no way to improve it after that.

Recording keys

This one is just a personal preference of mine but you might like to try it too. I find that Captivate doesn’t pick up every on screen event during automated capture (especially for certain types of ERP software) and you still need to hit the capture key sometimes to ensure you capture everything you need.  Since I’m right-handed, I use the mouse with my right hand and like to capture manual screens with my left hand.  Captivate’s default manual capture key is the PrintScreen key, which is usually on the right side of the keyboard.  forces right-handed users to reach across the keyboard every time we want to do a manual capture. So, I change the default manual capture key to F2 because it’s closer to my left hand.  Most of the other default recording keys are fine.

Default recording objects

Another personal preference of mine…In practice I end up deleting 90% of the automatically added text captions and highlight boxes in a typical Demonstration mode screen capture session.  So, I find it quicker overall to turn off both of these options and just add in the objects I want later.

Tip: Take care of corporate branding with preferences set in your template
While we’re on the subject of default objects…If you work in corporate e-learning where branding is an issue, I recommend you set up a project template with your logos, look and feel, color swatches, custom Object Styles etc. Then, in that template you can also select your preferred text captions and highlight boxes to be used during screen capture sessions.  Doing this saves a lot of time later because you don’t need to go through and reformat everything to conform to branding.

Tip: Customising the text in added text captions
The default text in text captions added during a capture session is governed by a template with .rdl suffix. There’s one template for each language supported by Captivate and (if you’re using Cp 2019) are all located in the Cp install folder at:

C:\Program Files\Adobe\Adobe Captivate 2019 x64
C:\Program Files (x86)\Adobe\Adobe Captivate 2019 x64

Project preferences

Now that we’ve taken care of global-level preferences, it’s time to look at preferences that only apply to the specific project file currently open in Captivate.  It’s best to set these preferences in any Captivate template file on which you base your projects, otherwise you’ll need to set them up each time you begin a new file.

Project information

This is not something that will necessarily prevent issues in Captivate, but adding appropriate information in the project settings can certainly help the next developer that happens to inherit the job of maintaining or editing your work. For example, if you’ve been really clever with variables, advanced actions, or widgets, but neglected to leave any documentation, the maintenance developer can perhaps at least look in the Project Information fields to identify the Author and then contact you via your Email address to ask any relevant questions about how you set up the project.

WARNING!  Don’t use punctuation marks in Project Information fields

Whatever text you add into these Project Information fields should NOT contain illegal characters, which can include certain punctuation characters that form part of programming languages. If you DO happen to inadvertently add these characters, you may find your project corrupts or refuses to publish. The error message will not indicate the cause of the issue as being anything related to Project Information, but it might mention something about using reserved keywords. I’ve never been able to get a definitive list of words or characters that can cause problems, so it’s just safer to avoid punctuation altogether.

Tip: Try High Quality (24 bit), you may be surprised!

In early Captivate previous versions the default slide quality setting was Low (8bit). But this is limited to just 256 colours and even though it give smaller file sizes, if you happen to be using gradient colours then the low quality becomes very noticeable. The default slide quality for Captivate projects is now set as Optimized. Some authors recommend this setting because it supposedly allows Captivate to choose the best quality but still keep a smaller filesize for output.  I recommend you test both Optimized and High (24bit) quality settings for comparison. Publish with all slides set to Optimized and then again with all slides set to High (24bit) to see which one gives you the best results and smallest overall file size. I’ve often been surprised to find High quality beats Optimized for both clarity and file size.

Publish settings

These affect results in your published file output. Here are my recommendations for each option:

Frames per second

Unless you have a specific requirement for a lower frame rate, leave this set to 30. Increasing it to 60 or whatever to try and make your published content run more smoothly is unlikely to be successful.

Include Mouse

You’ll need this on to see any recorded mouse movements.

Publish Adobe Connect Metadata

Turning it on will increase published file size. If you don’t use Adobe Connect and you don’t believe your content is ever likely to be uploaded to Connect, leave this option deselected.

Enable Accessibility

Leave this turned on by default. 

Restrict Keyboard Tabbing to Slide Items Only

This option restricts keyboard tab actions from affecting anything other than objects added to the slide itself.  If you find that many in your target audience are keyboard-driven users rather than mouse-driven, then you may get complaints that use of the TAB key jumps learners to controls on the player skin with no way for them to tab back to the slide content.  By all means try the option but test for other downsides.

Include audio

Leave this turned on otherwise your sound files will not be published out.

Publish audio as mono

Leave this turned on otherwise audio will be published as stereo and file size will jump.  For most e-learning projects there is no benefit with stereo.

Play tap audio for recorded typing

Some people turn this off because they find the typewriter key sounds to be cheesy or annoying. It’s a personal preference thing.

Start and end

These options control launch and termination behavior of a project, but only to a limited extent.  As you will find in the comments below, when working with web-based technologies some things are simply outside your control and there is little or nothing you can often do about it.

Auto play

This option now is practically redundant because no matter what you select the web browser will decide whether or not the content will automatically start playing.  As a result of the way marketers and advertisers have abused use of multimedia in web pages, playing sound files and videos without the user’s permission browser manufacturers decided to step in and take unilateral action to disable Auto Play of any multimedia.  Though their original targe was web pages, now that e-learning is also HTML5, it gets caught up in the issue as well.  If you need more detail, read this article about the issue.

Preloader settings

The Preloader preferences section is another one of those many areas where Adobe Captivate badly needs some development work.  As you will see, most of these settings are now redundant due to the Death of Flash and the changeover to HTML5.  Hopefully future versions of Captivate will address this issue.

A preloader is intended to delay start of playback until a specified percentage of the content file has already been downloaded.  Captivate’s functioning preloaders were all SWF objects and therefore only really applicable for SWF output (which as of 2020 is now not recommended). In addition to not being compatible with HTML5, they only work if the content is served from a web server over HTTP. That means the preloaders will NOT work if the same content is served up from a LAN server or LAN drive over TCP/IP.  This is due to the fact that SWF preloaders need to communicate with the server to calculate and show the percentage of file currently loaded.  This communication works with web servers, but not with LAN servers.

The bottom line is that Captivate currently has no HTML5-compatible preloaders you can select from the Preferences panel other than Animated GIFs. However GIFs just give the user something to stare at while the content is loading and do not actually make preloading more efficitent in any way.

Preloader path

If you have read the heading above about the Preloader option, you should now realise that setting the Preloader path option is also now largely redundant.  If there is effectively no preloader you can use, what does it matter where the files are?

The problem here is that if you are updating older projects that were originally created for Flash/SWF output, then you may need to check the Preloader settings to avoid issues when moving over to HTML5. This is because if the preloader path is empty, but you have the Preloader option selected, Captivate will just use the default preloader found in the Gallery folder and (depending on your Captivate version) this may be an SWF preloader, which is then not compatible with your HTML5 output, but won’t get picked up by the HTML5 Compatibility Checker tool.

Preloader Percentage

As indicated above, this setting is also now redundant. But let’s assume you do have a working preloader that works with HTML5. Then, if you set the preloader percentage to 100%, the Captivate module is supposed to download everything before initiating playback, which sort of defeats the whole purpose of having a preloader in the first place.  So, how do you work out the right percentage for your preloader? To be honest, this really depends on your end-user’s actual bandwidth and how quickly you want the content to begin playing. In my experience, a preloader value of 25-35% is more than adequate for most projects that contain text, graphics, some animation, and voiceover audio.  However, if your project contains even a modest amount of video, or your bandwidth is somewhat limited, then all bets are off and your preloader may need to be set higher.  You can usually tell if your preloader percentage is not high enough because your project will periodically ‘stall’ or ‘buffer’ (stop and start) while it tries to download more content. Bottom line: test, test, test, test!

Project end options

If you are simply loading your content to a web server or LAN server, there is little impact in selecting any of these options.  It’s largely a matter of personal preference whether the project fades out, closes the window, or simply stops playing.  However, if you happen to be uploading your content to an LMS, it may be a requirement that you DO NOT use Close Project as your ending option.

The reason for this is that many LMSs use a proprietary SCORM player application that runs in the web browser to play and track user interaction with your content.   This usually means the content is playing in a nested frameset. With such an arrangement the player may not allow the window to self-close, because if it did, then the SCORM API connection with the LMS may be broken before all scoring data has been transferred. The result of this would inevitably be incomplete reporting and unhappy clients. So, if your Captivate content is delivered from LMS servers, I recommend leaving the Project End option set to Stop Project, not Close Project

If you’re not serving content from an LMS and you opt to use the Close Project option, your end-user’s browser may still prompt them to allow the window to close, and there’s nothing you can do to over-ride this behavior because it’s controlled by the browser’s current security settings.

What about ‘daisy-chaining’ to the next course module?

Keen-eyed developers often note the Project End options to Open URL or File and Open Another Project. It therefore naturally occurs to them to use these options to call the next module in a course. This practice is known as ‘daisy-chaining’ and can be very useful in some situations. However, it’s not a viable solution if you are delivering the course via an LMS as the server itself must launch each separate module in order to correctly track the user’s interaction, scoring, and completion data.  Trying to sidestep the LMS via daisy-chaining the modules almost always fails.

Project Expiry Date

If you happen to be using a Trial version of Adobe Captivate, be aware that this field will set the content to expire and stop working 30 days after the publish date.  This catches out quite a few newbie developers.  To remove this restriction, you simply need to reopen the CPTX file in a fully licensed version of Captivate and republish again.

If you happen to find that the Project Expiry field is still disabled and uneditable, despite the fact that you now have a fully licensed version of Captivate, you may just need to reset your Preferences.

Quiz Preferences

The final section in the Preferences dialog deals with setting up your project’s quiz.  This can get very complex and really deserves its own page. So, we’ll only deal with the basic settings here and some general recommendations that would apply to all projects regardless of whether or not you were publishing for an LMS.


If your content will be delivered or tracked via a SCORM-compliant LMS, by all means set up your reporting options when you first set up the project file, but my recommendation is that you should then turn off Enable Reporting from then on until you actually need to upload your content to the LMS for integration testing. The reason here is that if you publish for SCORM, then when you try to view the published output on your local hard drive, the course will try to find the LMS SCORM API but won’t be able and will throw an error message. You can just click the Cancel button to view the content, but I guarantee you’ll soon get sick of doing so. By turning off Enable Reporting, you can still keep your settings, but you won’t be wasting development time with these annoying message boxes. 

In reality, the choices in this section are very dependent on the specific output format you have chosen, and in the case of SCORM/AICC output, it’s dependent to a large extent on the quirks of the specific LMS you happen to be using.

Enable reporting for this project

Unless you tick this box you cannot configure anything that will allow you to integrate your published content with an LMS or reporting mechanism of any kind.  As mentioned above, leave it off while developing content because otherwise each time you test publish it will go looking for the SCORM API and that will just slow things down in your development workflow.

LMS (Learning Management System)

From this drop-down list you select the type of LMS you will be using.  In most cases, if your LMS is a fairly typical SCORM-compliant system, you would choose the option shown in the screenshot below.

Although Moodle will accept SCORM 1.2 packages, it has a few quirks of its own that required Adobe to provide it as a separate option.

The Internal Server option is not really an LMS at all. It requires that you have your own web server set up to serve PHP pages that will accept reporting data.  These PHP pages ship with Captivate and are found buried in the Captivate install directory in Program Files.


This drop-down selects the LMS integration standard that will be used to transfer data between the course module and the Learning Management System. 

The most popular choice by far is still SCORM 1.2 and this is despite the fact that SCORM 2004 and xAPI are both much more recent standards that have greater capability. The truth is that SCORM 1.2 delivers what most organisations want, and in many cases is still the only standard their LMS will allow.

Unless your LMS only supports SCORM 1.2, I recommend you use SCORM 2004. It uses separate variables for tracking completion and pass/fail status, which makes it more flexible, and it also offers the ability to specify sequencing of course modules.

Configure (Manifest settings)

After selecting SCORM as an option, cick the Configure button on the Publish dialog to open the Manifest dialog and fine tune the settings further.
SCORM Version

There are actually three different sub-versions (or ‘editions’) of SCORM 2004, but Captivate always initially chooses 3rd Edition. ADL, the organization responsible for SCORM, recommends using 4rth edition, but you’re likely to find most LMSs still don’t support that option.  If using SCORM 2004, I recommend 3rd edition.

Course and SCO Identifiers

These are both required fields. If creating multi-SCORM packages, make sure you configure the manifest settings so that all SCOs (modules) use the same Course Identifier, but have separate SCO Identifiers, as shown in the screenshot.  As you can see, I use the Course ID as a prefix of the SCO ID to ensure uniqueness. In many cases this will make your LMS reporting a lot easier to decipher as you can easily tell from the SCO IDs which courses they belong to.  

The Version field specifies a number that the LMS can use to differentiate between manifests with the same Course Identifier. For example, if you are uploading the same project to your LMS after making edits or regular revisions, use a different version number in this field so that the LMS doesn’t balk (hopefully) and think you must be trying to upload a different course.

The Duration field is optional. If you select this the values are automatically populated by calculating the total playing duration of all slides.  However, this may not be a good guide in all cases because some courses take a lot longer to complete because slides use more interactivity.  So, if your LMS is displaying this field as a guide for learners, you may need to modify the values to give a more accurate guide as to how long users will need to allow for completion.


One reporting option that many people don’t pay enough attention to is the ability to select a template to use for your SCORM LMS.  The default template is usually fine, but it’s worth noting that you can also modify the default SCORM templates located in the Cp install directory under Templates > Publish > LMS > Standard > SCORM > Default and then save the modified template into the Custom folder at the same location.  You may want to consider this if your LMS has special requirements and you have someone that can program these custom modifications for you.


If your LMS servers tends to bog down or even crash when too many users are accessing e-learning courses, then consider using the SendTrackingDataAtEnd template.  It delays sending tracking data to the server until the end of the quiz, which can significantly reduce load on the LMS.

Completion Criteria

This configures how the LMS will determine whether the user completed your course module.  This is really dependent on the structure of your content, but I personally prefer to have it determined by passing a quiz, even if that only amounts to the user clicking a button at the end of the module.

Success Criteria

Again, this is dependent on your specific circumstances, but I usually go with Quiz is Passed. If your module doesn’t have quiz questions, add a scored button that the user can click at some point. Some LMSs will not terminate the course unless they get some kind of a score, even if it is just 1 point.

Data to Report

I generally deselect Interaction Data as this also reduces LMS load.

LMS Advanced Settings

This dialog is reached via the Advanced button at the bottom of the Quiz Reporting screen. 

Send Data On Every Slide

Captivate has always had a reputation in the LMS community for being very ‘verbose’, meaning that it tended to throw large amounts of data at the LMS, and in many cases this proved to be enough to make some of them slow to a crawl when a certain number of users climbed on board to view courses.  This option gives you the ability to specify whether or not Captivate will ping the LMS with interaction data every time a user visits and completes a slide.  I recommend you leave this off as it just adds more load to the LMS.

Never Send Resume Data

This box controls whether or not your course will support LMS bookmarking. In a somewhat counter-intuitive interface design, you select this box to turn off bookmarking. I recommend you do so, because in most cases I’ve found giving users the ability to leave course modules and return at a later date caused more problems than it solved. If you do decide to use LMS Resume Data bookmarking (by deselecting the box), you should do extensive testing to make sure your LMS supports it reliably, and your course participants won’t suffer any adverse experiences.  Issues with this kind of bookmarking account for a huge number of posts on the Adobe Captivate Forum.

Set exit to normal after completion

I recommend you first try having this one set to on. In theory it should mean that once your users have successfully completed a course module they would be allowed to view it from the beginning again should they open it another time.  Without this setting, a user re-entering the module after completion might be taken immediately to the final slide of the published file.

Escape Version and Session ID

This setting really only applies if you happen to be using the older AICC LMS integration standard and not SCORM. In the case of AICC, a lot of interaction data is transferred via the URL query strings and there are sometimes characters that get passed along in the URL which need to be escaped in order for reporting to work. Since I’m always using SCORM (and AICC is almost never used nowadays) I have never had to configure this option for any LMS I’ve worked with. But your mileage might vary.

About LMS bookmarking

So what do we mean by LMS bookmarking and why would anyone choose not to use it?

The SCORM standard specifies a way for LMSs to know at what specific point in a course the user decided to bail out and do something else more interesting.  This mechanism is called Suspend Data (also known as Resume Data). By default, Captivate sends resume data several times during the user’s interaction with the content and when the user terminates their session without completing the content. IF your LMS can correctly interpret this data, then Captivate’s default settings may work fine for you.  However, this is a BIG IF because many LMSs have proven unreliable in this area.

Adobe Captivate uses SCORM drivers supplied by Rustici Software, the acknowledged world experts in SCORM and the company behind the SCORM Cloud online LMS as well as the Tin Can or xAPI standard that was developed as an intended replacement for SCORM.  

If having problems, test on SCORM Cloud!

It’s not uncommon for Captivate developers to experience issues with their LMS of choice not accepting or not playing nicely with their e-learning content. When this happens, the default position of the LMS people is to say that the issue is with your content, not their LMS.

However, when these same Captivate developers log the issue on the Adobe Captivate User Forum, the usual suggestion there is to upload the same course to SCORM Cloud and test. This is because it has been acknowledged for a long time in the Adobe Captivate community that SCORM Cloud is the most SCORM-compliant LMS on the planet. 

If your content works fine on SCORM Cloud (and it usually will), go back to your LMS vendor and ask them why their LMS is not working like SCORM Cloud.  They hate it when you do this, but it usually forces them to come to the table and give you better information as to why their LMS is having issues.  Sometimes they will even give you access to their own technical people to help resolve the issue.  But they only do this as a last resort when you have proven that another LMS with an excellent reputation for quality (i.e. SCORM Cloud) has been able to do what theirs could not.

This page provides some general information about how to set up your computer environment for Captivate e-learning development. Contrary to what some newbie Captivate developers may hope to believe, installing Captivate is only the first thing you need to do in order to really enjoy using it. Many issues reported in the forums are caused by inappropriate system configuration or setup. Following the steps in this section will help you avoid those types of issues.

Launch Captivate using 'Run As Administrator'

Many Captivate users (and IT Departments) mistakenly think that as long the application has been installed correctly then basic user rights are all that should be required to run the application.  After all, you don’t need to be an Administrator just to use Microsoft Office, right?  Unfortunately, with Captivate it’s not quite that simple.

Captivate runs reasonably well on Microsoft Windows 78 or 10. But, be advised that these operating systems have strict user security (known as User Access Controls or UAC for short) that can interfere with some default Captivate functions (such as screen capture).

To install Captivate and set it up correctly on your development computer, you will need full Administrator rights. This won’t be a problem if you own the machine. However, if you work in a corporate environment as an employee or contracted developer, then it is unlikely you will be given such totally unfettered access to your computer’s operating system. The more likely scenario is that Captivate will be installed by authorised technicians from your IT department, and any time you need to update Captivate because a new patch has been released or you need to install add-ons (like Text-to-Speech voices), you’ll need to submit a formal request to the IT department to get this work done. You are therefore well-advised to cultivate a good relationship with the local IT department because the trend nowadays with many applications (Captivate included) is to move toward frequent bug-fixes and updates after release, to resolve issues that once would have been eliminated by more thorough pre-release testing.

In Windows systems it is necessary to always launch Captivate using Run As Administrator privileges.  But please be aware that just having Administrator rights on your PC is NOT the same thing as using Run As Administrator to launch an application. Many users fail to understand this subtle distinction and experience frustrating issues including loss of functionality and even random application crashes that may result in hours or even days of lost work. It’s really very easy to set up (if you have admin privileges). All you need to do is right-mouse-click on the Captivate icon in the Start menu or desktop, navigate to More > Run as administrator via the context menus.

If you don’t see a Captivate icon in your Start menu, an alternative method is to just browse to the Captivate.exe file inside your Program Files > Adobe > Adobe Captivate folder. Right click the main Captivate application EXE file and select the option in the Properties dialog to Run As Administrator.

What if the IT Department won't allow you to use Run As Administrator?

Be warned that when you inform your corporate IT department you need to run Captivate with administrator privileges they are likely to refuse permission, despite providing them with the information that the application will not work properly without this configuration. This is where you find out not just how helpful, but also how knowledgeable, your IT support people really are. 

Their objection will be something along the lines that: “Corporate IT policy states that normal users are not permitted to have full administrator rights…blah…blah…” However, it is technically possible to set up your user profile to have administrator rights for the Captivate application alone, without giving you admin rights over your entire computer. But only the really good IT geeks know the tricks involved in pulling this off. You may be forced to get your manager (or his manager) involved to ‘lean on’ the IT department if necessary.  

The bottom line is that you will all have to come to come kind of compromise, or else you won’t be able to use quite a bit of Captivate’s functionality.

Show hidden files and folders

By default, the Windows operating system hides certain folders and files to try and prevent users from accidentally deleting them and causing system instabilities. However, sooner or later you will need to access some of these files in order to perform certain maintenance and troubleshooting tasks. For example, you may need to modify Captivate’s publishing templates, delete system lock files to open CPTX files after a system crash, or delete/rename a troublesome Captivate preferences folder buried in your user profile. None of these tasks would be possible without being able to see the files or folders in the first place!

Here’s how to show hidden files on a Windows operating system:

  1. Open Windows Explorer and click Tools > Folder Options.(If you do not see the Tools option in Windows Explorer, open the Organize dropdown menu and select Layout > Menu bar.)
  1. In the Folder Options dialog, click the View tab.
  2. Under Files and Folders > Hidden Files and Folders select the option to Show hidden files and folders.
  3. Click OK to save changes.

Why your type of web server hosting matters

Here’s the problem: Captivate Forums will sometimes report a baffling issue where course links that were working fine for months suddenly start failing for no apparent reason. What has usually happened is that behind the scenes someone in the IT department or web hosting service decided to move the course files over to a different web server. Web server technologies differ in the way they handle URL links that have mixed-case filenames.  As a result, developers sometimes waste days before discovering broken links were caused by the change to a new web server, and not some failing in their own course.

Now that Captivate developers are limited to delivering content as HTML5, published course modules will almost always be loaded to a web server or Learning Management System (which is also usually a web server). The developer may not know whether this underlying web server technology is a Windows-based Internet Information Server (IIS) or an open-source Apache web server running on a UNIX or LINUX operating system.

Unfortunately, there is a small but significant difference between the way these differing technologies deal with mixed case text in URL links. The bottom line is that a URL hyperlink that works perfectly well when tested locally on your Windows development computer or on a Windows IIS web server, may fail when uploaded to UNIXLINUX, or FreeBSD web servers. 

Why this failure? It’s all due to the fact that a Windows web server is not case-sensitive and will therefore regard a URL pointing to MyCourse/MyFile.htm as being the same as a URL at mycourse/myfile.htm. By contrast, UNIX and LINUX servers are usually case-sensitive and would resolve see these same URLs as pointing to different locations. This difference can potentially cause havoc if your course files are named in mixed case, but called from URLs that specify the filenames differently.

So, even if you think there’s no chance your environment will change, if you want to avoid maddening issues with broken links, always follow the two rules below.

Rule #1: Always use lower case file/folder names

Although you can certainly use uppercase or mixed case names for folders in the general folder structure where you store your project files, when it comes time to published output, you will avoid a lot of potential issues with broken links if you ONLY use lower case folder and file names. This rule relates to the information above about how different web servers process links.

Rule #2: Never use spaces in file/folder names

Similar to the previous rule, spaces between words in folder names or filenames may result in broken URL links after uploading to a web server or LMS. Though your Windows operating system or LAN server will be able to resolve hyperlinks containing spaces, the rules of the internet are somewhat different. Web servers and web browsers do not expect to find spaces in a URL. They’ll interpret the spaces to mean the end of the URL, and therefore your carefully crafted hyperlinks will break.

The recommended way to separate words in a folder or file name is to use an underscore character or a hyphen. So instead of creating links like my course/my first course module.htm which would break when loaded to a web server, you should replace the spaces with underscore characters so that the link target is my_course/my_first_module.htm or even use hyphens such as in my-course/my-first-module.htm.

In a previous (teenage) life I worked as a technician repairing and servicing domestic electrical appliances. It was there I first learned how to troubleshoot technical issues. Most of the time it just boils down to eliminating all possible causes until you find the one/s causing the issue.  It’s not rocket science; just a process of elimination.  After a while the diagnostic process speeds up because you learn to look for the most of the common causes first and eventually you will even know instantly what the problem will be as soon as you hear the telltale symptoms.

Similarly, some basic troubleshooting tips apply to just about any Captivate issue you need to debug. In the thousands of posts I’ve logged on the Adobe Captivate Forum I often find myself following the same diagnostic process of elimination I used when fixing washing machines and refrigerators back in my teens. This section gives you a quick apprenticeship in Captivate troubleshooting techniques that every Captivate user should know about.

Easy Troubleshooting Techniques

These tips cost nothing to implement, in most cases take moments to perform, and have “saved my bacon” more times than I can count.

1. Start with the most likely causes

Of all the possible causes for an issue, there is usually one that stands out as most likely. Start with this one and work down through the list of possible causes from most likely to the most unlikely ones.  Don’t waste time initially exploring things that rarely turn out to be the cause if you know of more likely reasons that can be checked first.

2. Try to replicate the issue in a new project file

If you’ve been working on an issue that defies explanation, try creating a brand new Captivate project file and see if you can replicate the issue there.  Sometimes you’ll find that a new project does NOT suffer the same issue.  You can then stop blaming Captivate itself and start scrutinising the specific project file, which may have become corrupted in some way. If the project has become corrupted, the following two headings suggest ways to locate and eliminate possible causes of the corruption.

3. Simplify the project to isolate the issue

Very often a user will be unable to debug some baffling issue in a big complex project…simply because it is a big complex project. The larger the number of slides and components, the harder it becomes to know where an issue might be lurking. If you cut out the complexity, the issue may be easier to discern and thereby become easier to debug.

For example, when you publish a project, any hidden slides and their associated objects do not get published in the final output.

So a common debugging trick is to make a copy of a problematic project (thus keeping the original in case you make unforeseen changes to the project file that render it unusable) and then hide or delete half the slides to see if this resolves the issue. If hiding half the slides resolves the issue, then the cause of the issue was likely to be located somewhere in that hidden half of the project. Then you concentrate on that suspect half of the project and hide or delete half of it again. 

Using this simple process of elimination you can often narrow down the problem to a specific slide. Once you have isolated the problem slide, the next step is to find which object (or objects) on that slide cause the problem. So, you can either just start deleting objects from the slide, or drag objects out into the scrap area so that they are still available but don’t get published in final output.  In this way you can locate any object or group of objects that might be causing the issue. It’s the same process of elimination, but at the object level instead of the slide level.

4. Copy and paste slides to reset object IDs

Each object in a Captivate CPTX file is supposed to have a unique identifier. If for any reason multiple objects end up with the same identifier this can cause corruption.  

One way to resolve the issue is by copying entire slides from one project to another. This forces Captivate to assign new unique Item Names to all copied objects.  If the corruption was caused by conflicting identifiers, this will sometimes fix the issue, and it takes only a few moments to test.

5. Don’t just partial Preview. Publish completely!

I wish I had a dollar for every question where someone on the forum has been expressing frustration with Captivate because something is not working as expected and it turned out they were hitting F10 and previewing only the next few slides, and not publishing the entire project. 

Similarly, the basic Play Slide (or F3) preview will only play the slide timeline of the slide you are currently viewing in EDIT mode.  And this won’t show you how everything will look at runtime, especially if you have Effects on any objects.  The issue here is that some functionality will ONLY work properly if you publish the project completely. 

For example, click boxes or buttons set to Jump to Slide will ONLY work if you publish completely or use F12 to Preview In Web Browser.  So if something isn’t working, but you’re only partially previewing, try publishing completely.

6. Clear out your project cache

The Adobe Captivate CPTX file format makes heavy use of XML technologies and dynamic caching. In fact the CPTX file itself is actually a renamed ZIP archive that takes all the graphics, text and data that make up your project and packages it into a conveniently compressed format.  If you don’t believe me, just take a copy of one of your CPTX files, rename it to a ZIP file, and then extract it to somewhere on your computer so that you can inspect the files and folders inside.

But there’s also another benefit of this approach. When Captivate is first installed on a computer, a special folder called Adobe Captivate Cached Projects is created inside the user’s My Documents folder. Captivate uses this Project Cache to store data while working on project files.  The cache is essentially a ‘working folder’ that holds any changes to objects in the project until everything can be packaged up again in the compressed CPTX file when the project is finally saved and closed. The cache also helps to speed up publishing times for Captivate projects. 

The default location of the cache folder can be changed in the Captivate Preference settings.  It is actually highly recommended to change the location from your My Documents folder to another folder specially created for this purpose so as to avoid performance issues on systems where user profiles are virtualized and stored on LAN drives rather than on the user’s local hard drive.  (See this page regarding recommended Preference setup.)

However, the Captivate project cache is not without potential problems. If after working on several projects you happen to take a look inside the cache folder, you’ll find that it maintains separate folders for each Captivate project edited, and inside these folders are zillions of small files that control every aspect of every object in each project.

Where this becomes a problem is that the cache folder can eventually accumulate several gigabytes of files and cause Captivate to become unstable.  The solution is to do some ‘housekeeping’ and clean out the cache from time to time. There’s a Clear Cache button in the Preferences screen for this purpose.

Adobe recommends you clear your cache folder after completing each project and before you begin the next one.  I tend to feel that it’s not necessarily a good idea to jump in too early and delete all folders in the cache because the cache folders can also be used to resurrect entire CPTX project files if for any reason your main project file is lost or becomes corrupted.  So, I prefer to clean out the cache once I am sure there is no chance I might need those folders as a backup.

Never use Windows Explorer or the MAC Finder tool to delete the files in the cache folder while Captivate is still open or you may crash the program. The recommended method is to always use the Clear Cache button under Edit > Preferences > General section.  

7. Reset Captivate preferences

One of the most common ‘fixes’ for a wide array of issues entails renaming or deleting a specific hidden folder buried deep within your user profile.  This folder happens to be the one that stores all of the Captivate data relevant to the options you select under Preferences and Workspaces.  Unfortunately, if for any reason you are forced (or choose) to ignore recommendations about Captivate’s setup, then this preference data can end up becoming corrupted, leading to a wide variety of issues. When that happens, the quickest solution is to either reset or delete the Preference folder, forcing Captivate to create a new default set of preferences the next time the app is launched.

The Preferences folder is not named ‘Preferences’!

It would be wonderful if the Captivate preferences folder was easy to find on your computer, but it is not. In fact, it is buried deep down inside your user profile and that means it is deliberately hidden by default so that it cannot be accidentally deleted. Even when you do finally locate the folder, it’s not named ‘Preferences’, but instead is named after the specific installed version of Captivate (because each separate version needs to be able to maintain different preference settings).

Do it the easy way: Use the CleanPreferences files

All current Captivate versions provides a very simple and effective way to reset preferences via special files buried in the Utils folder of your Captivate install directory under Program Files.

For example, on a 64bit Windows 10 system with Captivate 2019 installed, the files you need to use are found here:

C:\Program Files\Adobe\Adobe Captivate 2019 x64\utils

  • CleanPreferencesWin.bat (for PCs), and
  • CleanPreferencesMac (for Apple Mac computers).

All you have to do is close down Captivate and execute (i.e. double-click) the relevant CleanPreference file at this location to reset your preferences folder in a matter of a second or two. 

Some users that experience preference corruption issues often even set up a custom shortcut on their desktop so that they can execute a reset at any time without even navigating down to the Utils directory.

Do it the hard way: Find and Delete the Preference folder

As noted above, the easy way to reset Preferences is by using the CleanPreferences files Adobe provides.  However, if you happen to be working in a corporate office environment with a ‘locked-down’ operating system, you may not have the necessary Administrator permissions required to enter the Program Files directory and execute the reset.  If this is the case, and your IT department is also unwilling to even set up the convenient desktop shortcut that would give you the ability to do this yourself, then your only solution for a corrupted Preference issue might be to find and delete the preference folder itsel.

To find the elusive Preferences folder, here’s what you need to do:

Show all hidden files and folders – Files in your PC user profile are normally hidden from view to prevent you from inadvertently deleting something essential, thus rendering you incapable of logging into your own computer.  So, in order to locate the Captivate Preferences folder you need to make a change to default system settings and show these hidden files or folders.  If your PC is not already set up this way, we cover this step in more detail in the section elsewhere on this website that discusses how to set up your computer to work with Captivate.

Close down Captivate – You cannot rename or delete the Preferences folder while Captivate is currently open.  So, close down Captivate before performing the next steps.

Navigate to the Preferences folder in your user profile – Your user profile path to the folder will vary depending on your specific computer operating system. (In paths shown below for Captivate 2019, replace [user] with your own profile name.)

  • Win10: C:\Users\[user]\AppData\Local\Adobe\Captivate [version#]
  • Apple MAC: /Users/[user]/Library/Preferences/Captivate [version#]

Rename or delete the preferences folder – As mentioned above, the preferences folder is not conveniently named ‘preferences’. In the example paths above, the Captivate [version#] folder is the preferences folder.

Once you’ve found the correct folder, all you need to do now is delete it, or just rename it to something else (e.g. add OLD to the end of the name).

Then, when you re-launch Captivate, it will detect that the preferences folder is missing and create a nice fresh (uncorrupted) new one for you.  If your original issue was due to corrupted preferences, then it should now be resolved.  (If it’s not resolved, at least you’re one step closer to finding the real reason.)

Please be aware that killing the preferences file, as described above, will mean you lose any customizations you may have made to preferences or workspaces when Captivate defaults back to original installation settings.  But that’s usually a small price to pay for getting back a fully functional working app that enables you to meet that looming deadline.

8. Step away from the issue!

If you’ve been banging your head against some issue for hours without success, sometimes the best thing you can do is to walk away from it and do something else for a while.  You may have become so close to the issue that you cannot see the solution staring you in the face. When I get stuck on a problem, I like to play my guitar, go for a walk, go for a coffee, or go to the toilet. (You’d be amazed how many times I’ve found sudden inspiration in the ‘smallest room of the house’.)

9. Ask someone else for advice

Again, if you’re too close to the issue to see the solution, ask another person unrelated to the problem for their input.  Many times they will hit on the reason because they don’t share your perspective. If you don’t have another developer in your team, log a question on the Adobe Captivate User Forum.  In most cases you’ll get a reply within hours, sometimes within minutes. However, if you DO expect someone else to help you, please note the next suggestion…

10. Give detailed info about the issue

  • Effective troubleshooting is based on accurate information, otherwise it’s just guesswork.  So, if you expect someone else to help you debug an issue for, you need to give them everything you know about the issue and its context.  It’s often just some minor detail that reveals the underlying cause or causes.  So, if you ever log an issue on the Captivate forum, it will greatly increase your chances of finding a solution if you provide the helpful people there with the kind of basic information outlined here below.

Provide this information:

  • Your Captivate major and minor version numbers, and whether or not all recent patches or updates have been installed.
  • Computer operating system. E.g. whether the computer is PC or MAC and the OS version.
  • Web browser version (if published content is playing in browser).
  • If content is delivered from an LMS, which one and which version.
  • If using an LMS, which integration technology standard (AICC, SCORM, or xAPI / Tin Can) and version (e.g. SCORM 1.2).

Sadly, Captivate developers often post questions on the forum without providing any of this information, which then requires the person offering help to go to the extra trouble of asking all the same questions I have listed above. The more information you supply, the more likely someone can help resolve your issue.

11. Read the user help doco!

And last but not least….when all else has failed and you’ve wasted far too much time searching for answers, do what you should have done when you first installed the application: Read the user help file documentation!

As someone who spent a number of years working in the software industry as a Technical Writer (before becoming an e-learning developer) I can tell you that most people neglect this basic step in learning about the application they just purchased, or where told by their boss to use.  

Large companies never expect their employees to just ‘pick up’ a new business application by playing around with it.  But many newbie Captivate developers somehow expect that they will have no issues by doing exactly that.  They don’t invest in any training (beyond watching a few YouTube videos) and they neglect to look up or download the Adobe Captivate HELP documentation.  The inevitable result is that they strike issues and then label Captivate as not being ‘user-friendly’.

Captivate does have some areas where its usability could certainly be improved.  But it’s never going to be completely idiot-proof.