Adobe Common Extensibility Platform (CEP)

← Back to Blog

What is CEP?

Adobe's Common Extensibility Platform (CEP) is a suite of technologies embedded in Adobe's Creative Cloud desktop applications. CEP, originally known as CSXS, first appeared in Adobe Creative Suite 4 in 2008. It provides the foundation for building extension panels using web technologies — HTML, CSS, and JavaScript — that appear as panels inside applications like InDesign, Photoshop, Illustrator, and Premiere Pro.

CEP is the predecessor to UXP, which Adobe introduced as its modern replacement. While UXP is now the recommended platform for new development in Photoshop and InDesign, CEP remains in use across many applications and extensions.

CEP as an Embedded Browser

Think of CEP as a web browser integrated into Adobe CC applications. Adobe built CEP around a specialised version of Google's Chromium Embedded Framework (CEF), enabling a variant of the Chrome browser to run inside applications with support for Google's V8 JavaScript engine. This makes it straightforward to use JavaScript frameworks and libraries — React, Vue, Angular, and any npm package that works in a browser environment.

The trade-off is resource usage: each CEP panel runs its own browser window, and applications with multiple panels can become memory-intensive.

How CEP Connects to the Host Application

CEP connects to CC applications through interprocess communication via PlugPlug, an Adobe shared technology component. PlugPlug bridges the V8 JavaScript environment in the panel, the ExtendScript DOM in the host application, and any natively compiled C++ plugins.

This means CEP extensions typically have two main parts:

• HTML/JavaScript panel: The user interface, built with standard web technologies. Can connect to the internet and access Node.js APIs.
• ExtendScript files: Scripts that manipulate the host application's document model — creating documents, placing images, modifying text, and so on.

The panel communicates with ExtendScript via the evalScript method:

var csInterface = new CSInterface();
csInterface.evalScript('yourExtendScriptCodeHere', function(result) {
    console.log(result); // Handle the result here
});

Node.js in CEP

CEP extends CEF by adding Node.js, providing APIs for file system access, networking, cryptography, and events. Thousands of Node Package Modules (npm) are available, enabling features such as database connectivity, authentication, and zip packaging — capabilities not available in a standard browser context.

The IPC Toolkit

CEP integrates the Adobe IPC Toolkit, an interprocess communications system that allows communication between different CC applications. With the IPC Toolkit, an InDesign extension can, for example, send commands to Photoshop or Illustrator — enabling cross-application workflows from a single panel.

CEP vs ExtendScript

CEP and ExtendScript are two separate technologies with different roles:

• ExtendScript runs inside the host application and handles backend automation, DOM manipulation, and batch processing.
• CEP runs in the embedded browser context and handles the user interface and frontend logic.

They cannot be merged in a single source file but communicate via the evalScript bridge. See our article on ExtendScript for Adobe Applications for more on the scripting side.

Extension Folder Structure

A standard CEP extension directory looks like this:

MyExtension/
├── CSXS/
│   └── manifest.xml
├── js/
│   └── main.js
├── html/
│   └── index.html
├── css/
│   └── styles.css
└── assets/
    └── (images, fonts, etc.)

The manifest.xml File

The manifest defines the extension's name, version, supported host applications, and required permissions. The <HostList> element specifies which applications and version ranges the extension supports. Each entry includes the application identifier (e.g. IDSN for InDesign, PHXS for Photoshop, ILST for Illustrator), and the minimum and maximum supported versions.

If <HostList> is omitted, the extension is compatible with all versions of the host application supported by that CEP version.

Supporting Multiple Host Applications

When building a CEP extension that targets more than one Adobe application, you need to detect which application is running and load the appropriate ExtendScript. Here is a pattern for doing this:

// Step 1: Detect the host application
function getHostApplicationId() {
    var csInterface = new CSInterface();
    return csInterface.getHostEnvironment().appName;
}

// Step 2: Load the correct ExtendScript
function loadExtendScriptForHostApp() {
    var appId = getHostApplicationId();
    var scriptPath;
    switch (appId) {
        case 'PHXS': // Photoshop
            scriptPath = 'path/to/photoshopScript.jsx';
            break;
        case 'ILST': // Illustrator
            scriptPath = 'path/to/illustratorScript.jsx';
            break;
        case 'IDSN': // InDesign
            scriptPath = 'path/to/indesignScript.jsx';
            break;
        default:
            console.error('Unsupported application');
            return;
    }
    var csInterface = new CSInterface();
    csInterface.evalScript('$.evalFile("' + scriptPath + '")');
}

CEP and the Future: UXP

Adobe has been transitioning from CEP to UXP (Unified Extensibility Platform) since 2021. UXP offers better performance, improved security, direct access to the application API without the ExtendScript bridge, and modern JavaScript with async/await support. For a comparison, see our article on UXP vs CEP in Adobe Photoshop.

CEP extensions will continue to work for the foreseeable future, but new extension development should favour UXP where the target application supports it. For applications that do not yet support UXP, CEP remains the appropriate choice.

Mapsoft and CEP

Mapsoft has extensive experience building CEP extensions across multiple Adobe applications. Whether you need a complex panel that integrates with external systems or a simpler UI layer on top of a C++ plugin, we can help. See our custom development page or contact us to discuss your requirements.