A question on the SOLIDWORKS 3DEXPERIENCE forum asked whether there is an API method to trigger the Update for 3DEXPERIENCE Compatibility command programmatically. The team needed to process several thousand legacy part files before uploading to a 3DEXPERIENCE tenant — running the command manually was not an option.

The short answer: no such API method exists. The compatibility update command is a UI-level operation with no public IFeatureManager, IModelDocExtension, or ISldWorks equivalent. IModelDocExtension::UpgradeLegacyCustomProperties sounds like it might cover this, but it does something narrower and unrelated to the 3DX compatibility update.

The only supported batch path is the SOLIDWORKS Task Scheduler, which added a dedicated 3DEXPERIENCE Compatibility task in 2024 SP1. Here is a complete explanation of what the command does, what the API gap means in practice, and how to set up a reproducible batch run.

What “Update for 3DEXPERIENCE Compatibility” actually does

The command lives under Tools → Update for 3DEXPERIENCE Compatibility in SOLIDWORKS 2022 and later. When run on a part or assembly, it makes two categories of change to the file:

1. Custom property architecture migration. SOLIDWORKS 2022 introduced a new internal representation for custom and configuration-specific properties. The previous representation (used in all versions before 2022) stored properties in a legacy OLE stream inside the SLDPRT/SLDASM binary. The new representation uses a different storage structure that the 3DEXPERIENCE platform can read directly when the file is checked into a collaborative space.

If you open a pre-2022 file in SOLIDWORKS 2022+ without running the compatibility update, the properties are read and displayed correctly in SOLIDWORKS but the 3DX platform cannot extract them from the file’s raw binary. The compatibility update rewrites them to the new storage structure so the platform indexer can read them without opening SOLIDWORKS.

2. 3DEXPERIENCE revision table mode. Drawings that are stored in a 3DEXPERIENCE collaborative space can have their revision tables driven by the platform’s lifecycle engine: when a change action creates a new revision, the platform updates the drawing’s revision table directly, without requiring the user to open and manually edit the drawing. For this to work, the drawing file must have its Document Properties → Tables → Revision → Driven by 3DEXPERIENCE checkbox enabled.

The compatibility update sets this flag on qualifying drawing files. It does not retroactively add revision table entities — you still need a revision table in the drawing — but it sets the mode so the platform controls future entries.

What UpgradeLegacyCustomProperties does

IModelDocExtension::UpgradeLegacyCustomProperties() was added in SOLIDWORKS 2022. Despite the name, it handles only step 1 above — the property architecture migration — and only for the currently open document. It does not set the 3DX revision table flag. It does not perform any of the background compatibility checks the UI command runs.

The method signature:

' Returns True if upgrade was needed and applied
' Returns False if already in new format or upgrade not applicable
Dim swModel As SldWorks.ModelDoc2
Dim swExt As SldWorks.ModelDocExtension
Set swExt = swModel.Extension

Dim bUpgraded As Boolean
bUpgraded = swExt.UpgradeLegacyCustomProperties()

This is useful in a narrower scenario: you have a SOLIDWORKS 2022+ installation and you need to ensure all open documents use the new property storage before a programmatic property read or write. It is not a substitute for the full compatibility update.

The Codestack documentation covers a clean implementation for upgrading custom properties on open documents, but be clear about what it is: a property storage migration, not a 3DEXPERIENCE platform readiness check.

The API gap

There is no IFeatureManager method, no IModelDocExtension method, and no ISldWorks method that:

  • Triggers the full “Update for 3DEXPERIENCE Compatibility” pipeline
  • Enables the 3DEXPERIENCE-driven revision table mode via code
  • Reads the current 3DX compatibility status of a file

Checking the relevant API objects in SolidWorks.Interop.sldworks.dll (decompiling the interop assembly with ildasm):

ildasm "C:\Program Files\SOLIDWORKS Corp\SOLIDWORKS\api\redist\SolidWorks.Interop.sldworks.dll" /text /item=IModelDocExtension > ext_methods.txt

Searching the output for anything related to “3DX”, “3DEXPERIENCE”, “Compatibility”, or “Transition” returns nothing. The command is implemented entirely in the UI layer with no public API surface.

The IDrawingDoc and ISheet interfaces have no method to set the revision table drive mode programmatically either. IRevisionTableAnnotation and IRevisionTableFeature expose the revision table object model (rows, cells, anchors) but do not expose the drive mode flag.

The closest approximation using available API is this pattern — open the document, run UpgradeLegacyCustomProperties, save:

Sub UpgradeCustomPropertiesOnly(folderPath As String)
    Dim swApp As SldWorks.SldWorks
    Set swApp = Application.SldWorks
    
    Dim fso As Object
    Set fso = CreateObject("Scripting.FileSystemObject")
    
    Dim folder As Object
    Set folder = fso.GetFolder(folderPath)
    
    Dim file As Object
    For Each file In folder.Files
        Dim ext As String
        ext = LCase(fso.GetExtensionName(file.Path))
        If ext = "sldprt" Or ext = "sldasm" Then
            Dim errors As Long, warnings As Long
            Dim swModel As SldWorks.ModelDoc2
            Set swModel = swApp.OpenDoc6(file.Path, _
                swDocumentTypes_e.swDocPART, _
                swOpenDocOptions_e.swOpenDocOptions_Silent, _
                "", errors, warnings)
            
            If Not swModel Is Nothing Then
                Dim swExt As SldWorks.ModelDocExtension
                Set swExt = swModel.Extension
                
                Dim bUpgraded As Boolean
                bUpgraded = swExt.UpgradeLegacyCustomProperties()
                
                If bUpgraded Then
                    swModel.Save3 swSaveAsOptions_e.swSaveAsOptions_Silent, errors, warnings
                    Debug.Print file.Name & ": upgraded and saved"
                Else
                    Debug.Print file.Name & ": already current format"
                End If
                
                swApp.CloseDoc swModel.GetPathName()
            End If
        End If
    Next file
End Sub

This handles the property storage migration but does not touch the 3DX revision table flag. If that is all you need — and for many shops upgrading from 2021 to 2022+ it may be — this macro covers it.

For the full compatibility update including the revision table mode, you need Task Scheduler.

The Task Scheduler “3DExperience Transition” task

SOLIDWORKS Task Scheduler (sldtaskscheduler.exe) added the 3DExperience Compatibility task in 2024 SP1. The task opens each file in a headless SOLIDWORKS instance, runs the full compatibility update, and saves the result. It handles parts, assemblies, and drawings and processes them in dependency order (parts before assemblies before drawings).

Setup via the UI:

  1. Open SOLIDWORKS Task Scheduler from the SOLIDWORKS start menu group.
  2. Click 3DEXPERIENCE Compatibility in the task list.
  3. Add files or folders to the input list. The scheduler will discover all SOLIDWORKS files in subfolders.
  4. Set the schedule (immediate or deferred).
  5. Click OK.

The task runs under the Windows account configured for Task Scheduler. That account must have a valid SOLIDWORKS license. The SOLIDWORKS installation must be 2024 SP1 or later.

Invoking from the command line:

Task Scheduler supports a command-line mode via sldtaskscheduler.exe. For the 3DExperience Compatibility task, the command is:

& "C:\Program Files\SOLIDWORKS Corp\SOLIDWORKS\sldtaskscheduler.exe" `
  /c "3DExperienceCompatibility" `
  /r "C:\VaultFiles\Projects\ProjectAlpha" `
  /l "C:\Logs\3dx_compat_log.txt"
  • /c — task command name. The 3DEXPERIENCE Compatibility task is invoked as 3DExperienceCompatibility (exact string; check Task Scheduler → Help → Command-Line Reference for your version).
  • /r — root folder to process recursively.
  • /l — log file path.

The log file records the per-file outcome: upgraded, skipped (already compatible), or failed (corrupt file, missing references). Parse it to find files that require manual attention.

Batch automation pattern:

If you need to run this as part of a larger migration pipeline — for example, after pulling files from a SOLIDWORKS PDM vault and before uploading to 3DEXPERIENCE — the command-line invocation fits naturally into a PowerShell script:

$taskSchedulerExe = "C:\Program Files\SOLIDWORKS Corp\SOLIDWORKS\sldtaskscheduler.exe"
$inputFolder = "C:\VaultExport\ProjectAlpha"
$logFile = "C:\MigrationLogs\3dx_compat_$(Get-Date -Format 'yyyyMMdd_HHmmss').txt"

# Run compatibility update
$process = Start-Process -FilePath $taskSchedulerExe `
    -ArgumentList "/c 3DExperienceCompatibility /r `"$inputFolder`" /l `"$logFile`"" `
    -Wait -PassThru

if ($process.ExitCode -ne 0) {
    Write-Error "Task Scheduler exited with code $($process.ExitCode)"
    exit $process.ExitCode
}

# Parse log for failures
$failures = Select-String -Path $logFile -Pattern "FAILED|ERROR" | Select-Object -ExpandProperty Line
if ($failures) {
    Write-Warning "The following files failed compatibility update:"
    $failures | ForEach-Object { Write-Warning $_ }
}
else {
    Write-Host "All files processed successfully."
}

This gives you a scriptable, logged, exit-code-aware batch run that can be called from a migration pipeline or scheduled as a Windows Task.

Dependency ordering matters

The 3DEXPERIENCE platform reads part files before assemblies and assembly files before drawings. If an assembly references a part that has not been upgraded, the platform may fail to index the assembly correctly even if the assembly file itself was upgraded.

Task Scheduler’s built-in task handles ordering automatically when you point it at a folder tree — it discovers references and processes leaves before roots. If you build a custom pipeline, the sequence must be:

  1. All referenced parts (bottom-up within assemblies)
  2. Sub-assemblies, from lowest to highest level
  3. Top-level assemblies
  4. Drawings that reference the above

For large vaults, SOLIDWORKS PDM’s IEdmVault5::GetFileByID and the file reference graph API (IEdmFile5::GetReferences5) give you the dependency tree for correct ordering.

What still requires human review

Even after a successful batch run, some files will need manual attention before they are truly 3DX-ready:

Files with external references outside the migration scope. If an assembly references a part that lives outside the folder being migrated, the compatibility check may flag it as needing attention. SOLIDWORKS cannot upgrade an assembly for 3DX compatibility if its referenced parts are not also being migrated.

Drawings with manually managed revision tables. The 3DX revision table flag is set by the compatibility update, but if the revision table template in the drawing template library has not been updated for 3DX compatibility, the revision table will not receive platform-driven updates correctly. Update the drawing template first.

Files with broken or unresolved features. The compatibility update runs with SOLIDWORKS in silent mode. A model with a rebuild error will have the error flagged in the log. You need to resolve the error in SOLIDWORKS and re-run the update for that file.

Relation to existing automation infrastructure

If you are already using the SOLIDWORKS workflow automation patterns — Task Scheduler, PDM tasks, or C# add-ins — the 3DX compatibility batch fits naturally into the Task Scheduler tier. It is a one-time migration step, not a recurring workflow, so it does not belong in a nightly PDM task. The right pattern is: audit files for compatibility status, run the batch on those that need it, verify the log, resolve exceptions, and mark the migration complete.

For teams managing this as part of a CAD data migration to the 3DEXPERIENCE platform, the compatibility update is one step in a larger sequence: dependency audit → local rebuild validation → compatibility update → vault pre-check → platform upload. Treating it as a single script invocation rather than a multi-week manual effort is the difference between a migration that completes on schedule and one that drags into months.