To v1.72

Version 1.72 deprecates scene mode. Previously, scenes were either 'Design' or 'Video', and the mode restricted which engine features were available. Starting with this version, there is a single scene type that supports all features. Mode is legacy metadata that no longer affects engine behavior.

This guide covers how to migrate to the new model and, if you cannot migrate yet, how to keep using legacy mode.

What Changed#

• Scene mode is deprecated. The following APIs still work but will be removed in a future version: engine.scene.getMode(), engine.scene.setMode(), engine.scene.createVideo(), cesdk.createDesignScene(), cesdk.createVideoScene(), and the mode option on the scene.create action.
• New scenes have no mode. Both the scene.create action and engine.scene.create() now create scenes without a mode. engine.scene.getMode() returns null instead of 'Design'.
• The engine no longer restricts features by mode. Methods that previously threw errors on Design-mode scenes (e.g., addVideo(), getBackgroundTrack()) now work on every scene.
• Reading scene/mode via the property system errors on mode-less scenes. Code that reads scene/mode through engine.block.getEnum(scene, 'scene/mode') will throw on scenes without a mode. Either remove mode checks entirely (see Remove Scene Mode Checks) or set a mode explicitly (see How to Keep Using Legacy Mode).
• Browser support checks are no longer automatic. Config plugins that need video decode/encode checks must call editor.checkBrowserSupport explicitly.

How to Migrate#

Migrating means embracing the single scene type. You no longer need to think about mode at all.

Simplify Scene Creation#

The scene.create action no longer requires a mode option. Previously, video editors passed { mode: 'Video' } to get video capabilities. Now every scene has all capabilities by default.

Before:

// Editor instance methods
await cesdk.createDesignScene();
await cesdk.createVideoScene();

// Editor action with mode
await cesdk.actions.run('scene.create', { mode: 'Video' });

// Engine API
const scene = engine.scene.createVideo();

After:

// Editor action, no mode needed
await cesdk.actions.run('scene.create');

// Engine API
const scene = engine.scene.create();

All of the following are deprecated:

• cesdk.createDesignScene() and cesdk.createVideoScene(): use the scene.create action instead.
• engine.scene.createVideo(): use engine.scene.create() instead.
• The mode option on the scene.create action: omit it entirely.
• engine.scene.setMode(): only needed if you must maintain legacy mode (see below).
• engine.scene.getMode(): mode no longer determines available features.

Remove Scene Mode Checks#

Since mode no longer affects behavior, any code that branches on getMode() to decide which features to enable can be removed. All features are always available.

Before:

const mode = engine.scene.getMode();
if (mode === 'Video') {
  // enable video features
}

After:

// No check needed. Video features are always available.

Update Browser Support Checks in Your Config#

Browser capability checks (video decode/encode support) no longer run automatically based on scene mode. They are now triggered explicitly via the editor.checkBrowserSupport action.

If you use a starter kit config (e.g., video editor, advanced video editor): update to the latest version of the config. The v1.72 configs already include the editor.checkBrowserSupport call with the appropriate defaults. No changes needed on your end.

If you have a custom config plugin, add the editor.checkBrowserSupport call to your plugin’s initialize() method:

async initialize({ cesdk }: EditorPluginContext) {
  await cesdk.actions.run('editor.checkBrowserSupport', {
    videoDecode: 'block',
    videoEncode: 'warn'
  });
}

The action accepts an optional parameters object:

When called without parameters, the action falls back to scene mode-based defaults for backward compatibility:

• Video mode scenes: videoDecode: 'block', videoEncode: 'warn'
• No-mode scenes (null): all checks ignored
• Design mode scenes: no checks run

Update TypeScript Types#

The return type of engine.scene.getMode() changed from SceneMode to SceneMode | null. If you still reference this API, update your type annotations.

// Before
const mode: SceneMode = engine.scene.getMode();

// After
const mode: SceneMode | null = engine.scene.getMode();

How to Keep Using Legacy Mode#

If you cannot fully migrate yet, you can continue using scene mode. The deprecated APIs still work and will remain functional until removed in a future version.

The key change is that scene creation no longer sets a mode automatically. To preserve the old behavior, you need to both set the mode explicitly and enable the useLegacySceneModeChecks feature flag.

Enable the Feature Flag#

By default, the editor UI treats all scenes as unified and ignores mode when deciding which features to show. To restore the old behavior where the UI gates features based on scene mode (e.g., hiding video export in Design mode or hiding page resize in Video mode), set useLegacySceneModeChecks to true in your configuration:

CreativeEditorSDK.create(container, {
  featureFlags: {
    useLegacySceneModeChecks: true
  }
});

Without this flag, calling setMode() still stores the mode on the scene, but the editor UI will not restrict any features based on it.

Cross-Platform Compatibility (Web + Mobile)#

Set the mode explicitly when creating scenes that will be shared with mobile:

// Using the scene.create action
await cesdk.actions.run('scene.create', { mode: 'Video' }); // or 'Design'

// Using the engine API
const scene = engine.scene.create();
engine.scene.setMode('Design'); // or 'Video'

Keeping Legacy Behavior on Web#

If your Web integration relies on the editor UI gating features by mode, enable the useLegacySceneModeChecks feature flag (see above) and call setMode() after create(). The engine itself no longer restricts features by mode, but the editor UI will respect mode when the flag is enabled. Your own code can also still read and branch on getMode().

Scene File Compatibility#

Loading Old Scenes in v1.72+#

Scenes saved with older SDK versions contain an explicit mode ('Design' or 'Video'). When loaded in v1.72+, the mode is preserved. engine.scene.getMode() returns the original mode. All features work regardless of the loaded mode.

Loading New Scenes in Older SDKs#

Older SDK versions (pre-v1.72) cannot load mode-less scenes. If you need to support older SDK versions, set an explicit mode with engine.scene.setMode() before saving. See How to Keep Using Legacy Mode.

Cross-Platform Compatibility#

Mobile SDKs (iOS, Android) do not yet support scenes without a mode. If you share scenes between Web and mobile, always set an explicit mode before saving. See How to Keep Using Legacy Mode.

Summary#