Performance for Automation

Ok while Ae team figures this out. I've made a little script using AI to find and replace in expressions, so I can update ALL properties across selected comps with the updated csv path in another comp.

So I look for:

thisComp.layer("data.csv")

and I replace with:

comp("data").layer("data")

(function() {
    var proj = app.project;
    var selectedItems = proj.selection;
    var comps = [];

    // Filter out non-composition items from selection
    for (var i = 0; i < selectedItems.length; i++) {
        if (selectedItems[i] instanceof CompItem) {
            comps.push(selectedItems[i]);
        }
    }

    // If no comps are selected, use the active composition
    if (comps.length === 0) {
        var activeComp = app.project.activeItem;
        if (activeComp && activeComp instanceof CompItem) {
            comps.push(activeComp);
        } else {
            alert("No composition selected and no active composition. Please select a composition or make one active.");
            return;
        }
    }

    var instructionText = "Current scope: " + (comps.length > 1 ? comps.length + " selected compositions" : "Active composition") + "\n" +
                          "Tip: To run this script on multiple compositions, select them in the project panel before running the script.\n";

    var findText = prompt(instructionText + "Find:", "");
    if (findText === null) return;

    var replaceText = prompt("Replace With:", "");
    if (replaceText === null) return;

    app.beginUndoGroup("Find and Replace in Compositions");

    var totalReplacements = 0;

    for (var i = 0; i < comps.length; i++) {
        searchAndReplace(comps[i]);
    }

    app.endUndoGroup();

    alert("Replaced " + totalReplacements + " occurrences in " + comps.length + " composition(s).");

    function searchAndReplace(comp) {
        for (var j = 1; j <= comp.numLayers; j++) {
            var layer = comp.layer(j);
            searchAndReplaceInLayer(layer);
        }
    }

    function searchAndReplaceInLayer(layer) {
        for (var j = 1; j <= layer.numProperties; j++) {
            var prop = layer.property(j);
            if (prop.propertyType === PropertyType.PROPERTY) {
                if (prop.expressionEnabled) {
                    var oldExpression = prop.expression;
                    var newExpression = oldExpression.split(findText).join(replaceText);
                    if (newExpression !== oldExpression) {
                        prop.expression = newExpression;
                        totalReplacements += (oldExpression.split(findText).length - 1);
                    }
                }
            } else if (prop.propertyType === PropertyType.INDEXED_GROUP || prop.propertyType === PropertyType.NAMED_GROUP) {
                searchAndReplaceInLayer(prop);
            }
        }
    }
})();

The script searches all expressions and replaces it for me and it's much quicker. Everyone here who has to use this workaround could benefit from this. Love to you all, the Ae team deserves more devs! Adobe wake up!

I've a project that needs localising in several languages. I have managed to rig up the essential properties of various texts across 3 videos, each with 4 formats, in a single aep. The AEP is now over 100MB and these are fairly simple animations.

Autosaves/saves take about 30seconds, and every action I perform, toggling a layer visibility, renaming an essential graphics property, entering/leaving an expression now has a lag of about 2seconds before it happens. 

The properties panel slows things down a lot so I've disabled the Auto-Open panel option for that. It feels like Ae is doing some run-through of all things everytime I perform an action, causing major delays.

When rendering, it's just as fast as usual, 30s render comps export in about 13s.

I wonder if the Essential Graphics panel and the media replacement properties are a factor as it takes a little while for the thumbnails of those properties to refresh. But I think the main factor is the csv linked into Essential Graphics properties all over the place. The codes are simple, no crazy math. Just indexOf() and split(), occasional if statements.

Things feel faster in the beta compared to the official release but it's still slow as hell.