Photoshop Extension Technologies: ExtendScript, CEP, UXP, Hybrid & C++ SDK

By Michael Peters · Published May 8, 2026 · Last updated May 8, 2026 · 9 min read

← Back to Blog

Why five frameworks?

Photoshop has the longest, most varied extension history of any Creative Cloud application. ExtendScript dates to the late 1990s. The C++ SDK predates that. CEP shipped in 2014. UXP arrived in 2021 (Photoshop got it first). Hybrid Plugins arrived in 2024-2025 to bridge UXP and the C++ SDK. None of the older frameworks are deprecated; the production reality is that all five remain in active use, each for a specific job.

The skill is recognising which framework fits the work in front of you. Most extension projects use one primary technology and occasionally combine two. The first-time-build mistake is reaching for the most modern option (UXP) when ExtendScript would do the same job in a tenth of the development time.

The five technologies

ExtendScript

Adobe’s JavaScript-based scripting language — an ES3 dialect saved as .jsx files, run from the Scripts panel or via File → Scripts → Browse… ExtendScript’s strengths:

• Access to the entire Photoshop scripting DOM — documents, layers, channels, paths, history, exports, batch processing
• Automation of repetitive tasks: layer normalisation, batch resizing, format conversion, watermarking, metadata operations
• Inter-application communication via BridgeTalk to Illustrator, InDesign, Bridge, Acrobat
• Quick development — a .jsx file deploys with a drag-and-drop into the Scripts folder
• Cross-platform and remarkably stable across Photoshop versions

ExtendScript covers most production Photoshop automation. We catalogue 100 production-ready scripts in our free Photoshop scripts collection.

UXP — the modern path for new panels

Photoshop has the most mature UXP implementation in the Creative Cloud suite, public since Photoshop 22 (2021). It’s the recommended default for new panel work in 2026:

• Modern JavaScript with async/await, modules, classes
• Direct access to the Photoshop API without an ExtendScript bridge — your panel JavaScript calls Photoshop natively
• Spectrum Web Components for native-looking Adobe UI
• Sandboxed execution with explicit permission requests for filesystem and network access
• Hot reload, Chrome DevTools-style debugging via the UXP Developer Tool
• Distribution as .ccx packages via Adobe Marketplace, direct download, or enterprise side-loading

The full UXP-vs-CEP framing for Photoshop, including architectural differences, API coverage, and migration path, lives in UXP vs CEP extensions in Adobe Photoshop.

CEP HTML panels — the legacy framework

CEP (the Common Extensibility Platform) is the older HTML-panel framework. Most third-party Photoshop panels in production today were originally CEP-based, though the ecosystem has been migrating to UXP for years. CEP still loads in current Photoshop versions; Adobe has signalled eventual deprecation but the timeline keeps extending.

For new Photoshop panel work in 2026, CEP is the wrong default. The cases where it’s still appropriate — legacy panels in production, Node.js dependencies, deep CEP-only APIs — are covered in Photoshop CEP extensions: when CEP is still the right answer.

Hybrid Plugins — UXP + native C++

The Photoshop-specific framework that doesn’t exist for any other Creative Cloud application. Hybrid Plugins combine a UXP front-end with a native C++ back-end: modern JavaScript and Spectrum UI for the panel, compiled C++ for performance-critical operations. The architecture lets you keep:

• UXP’s developer ergonomics (modern JS, hot reload, Spectrum components)
• UXP’s sandbox security model
• The full performance of C++ for image kernels, file format handlers, GPU operations
• The full Photoshop API surface, including the parts UXP’s JavaScript bindings haven’t covered yet

This is the strategic answer for production Photoshop extensions in 2026. We cover the architecture, build pipeline, and when it’s the right choice in Photoshop Hybrid Plugins.

The C++ SDK

The Photoshop C++ SDK provides the deepest integration. Native plugins can:

• Implement custom filters that appear in the Filter menu
• Add new file format support (import and export)
• Process image data at native speed with no scripting overhead
• Hook Photoshop’s notifier system for event-driven extensions
• Integrate with native libraries (OpenCV, ML inference engines, custom hardware)
• Run server-side in headless contexts (Photoshop Server deployments, the Photoshop API)

The C++ SDK is the right choice for filter and file format work, performance-critical batch operations, and any extension that needs to run in production server-side. The cost is a per-Photoshop-version recompile and a more demanding development environment. Increasingly, extensions that would have been pure C++ in 2020 are now Hybrid Plugins (UXP UI + C++ engine) instead.

Choosing your stack

The five-way comparison:

The decision flow most projects converge on:

1. Could it be a script? If the work is automation, batch, or a one-off transformation, ExtendScript is almost always right. It deploys with a drag-and-drop and survives Photoshop upgrades. See Photoshop automation for the practical patterns and batch processing for production folder loops.
2. Could it be an Action? If the operation is a repeated GUI sequence applied to single files, an Action is the right answer for non-developer users — covered in Photoshop Actions and Droplets.
3. Does it need a persistent panel? If users need a panel that stays visible while they work, UXP is the answer. The host API is directly accessible from the panel’s JavaScript.
4. Does it need native performance plus modern UI? A Hybrid Plugin (UXP + C++) gives you both. The right choice for image processing kernels, custom file format handlers, GPU operations behind a Spectrum-styled panel.
5. Is it a filter or a file format plugin? Pure C++ SDK. The Filter Plugin SDK and File Format Plugin SDK are mature; the deployment is per-version compile.

Combining technologies in practice

UXP panel orchestrating ExtendScript batch jobs

A common transitional pattern: a UXP panel provides the user-facing UI (configuration, progress, results), while heavy batch work runs as ExtendScript that the panel invokes. Useful when the batch logic already exists as tested ExtendScript and the new requirement is to put a friendly UI on it. UXP can call ExtendScript via the ExtendScript engine that still ships with Photoshop — the bridge isn’t the same as CEP’s but the result is similar.

Hybrid Plugin (UXP UI + C++ engine)

The modern combined pattern. The UXP front-end handles user interaction, configuration, and orchestration. The C++ back-end is invoked from the JavaScript via UXP’s native module support. The C++ side handles per-pixel work, custom file format reading, integration with native libraries. Most new production extensions that previously would have been "CEP panel + C++ plugin" are now Hybrid Plugins.

C++ filter with companion UXP panel

For filter plugins that benefit from a configuration UI more capable than a modal dialog — preset management, before/after preview, parameter history — a companion UXP panel adds the modern interface without changing the underlying C++ filter. The filter ships as before; the panel ships as a separate UXP plugin that communicates with the filter via Photoshop’s plugin messaging.

Architecture considerations

When designing a multi-technology Photoshop extension:

• Data flow: Plan how image data and metadata move between layers. Crossing the JS/native boundary in a Hybrid Plugin is cheap; crossing the ExtendScript bridge in CEP is not.
• Error handling: Each layer has its own error mechanisms. Surface meaningful messages to the user; log details centrally for debugging.
• Versioning: Native code (C++ SDK, Hybrid Plugin native modules) recompiles per Photoshop major version. UXP and ExtendScript are more forgiving across versions.
• Server-side: If the workflow has any chance of running on the Photoshop API in the future, build the image-processing parts as C++ from day one — the API runs C++ plugins but not UXP or CEP panels.
• Distribution channel: Adobe Marketplace, direct download, and enterprise side-loading all support UXP .ccx packages. CEP .zxp still works but is an older path. Pure C++ plugins use the legacy installer model.

Mapsoft’s approach

At Mapsoft, we’ve built Photoshop extensions across all five frameworks for over twenty years — from C++ filters for medical imaging to UXP panels for editorial workflows to Hybrid Plugins for performance-critical production tools. For deeper coverage of specific topics:

• Photoshop automation: Actions, Scripts, and Plugins
• Photoshop batch processing
• Photoshop Actions and Droplets
• UXP vs CEP extensions in Adobe Photoshop
• Photoshop CEP extensions
• Photoshop Hybrid Plugins
• Photoshop API for cloud-scale image processing

See our Photoshop development page or get in touch to discuss your project.