[Walter Soyka]

The memory requirements for this project are huge. Ae will need 1.4 GB of RAM for each frame of each layer, just to hold the images.

Can you reduce those source images in size at all? Or can your other app output them as vector graphics instead of PNGs? Or break them into pieces and tile them if you don’t need to see the whole thing on-screen at the same time?

Otherwise, you should probably turn off multi-processing, or try working and previewing at quarter-resolution (or lower) — but even in these cases, your renders will take quite a long time.

[Walter Soyka]

That # symbol indicates a guide layer — a non-rendering layer that you can see in your viewer, but that does not appear in renders or downstream comps. It’s super-useful if you want to see how an element aligns or composites with something else, but don’t want it to accidentally render if you forget to turn it off.

You can toggle it on or off from the layer menu, or by right-clicking on the layer and selecting Guide Layer from the context menu.

Here’s a little more information:

https://helpx.adobe.com/after-effects/using/layer-properties.html#guide-layers

[Walter Soyka]

FWIW, I think Roland’s method of obscuration is production-ready and significantly more useful for hiding how your custom expression code actually works.

John’s method is extremely clever, but you can extract the hidden comp name from the current implementation with just two lines of code, and then the user can see everything you’ve done.

I think some kind of native protection for authors with locked-down templates would be a great feature request for Adobe:
https://community.adobe.com/t5/after-effects/ct-p/ct-after-effects?page=1&sort=latest_replies&filter=all&lang=all&tabid=ideas

community.adobe.com

After Effects

Get help and share feedback in our global community.

[Walter Soyka]

I guess if you don’t need any modern JavaScript features in your expressions and can get away with using the legacy ExtendScript expression engine, you can use Adobe’s dev tools to make .jsxbin blobs for all your expressions (and even bake key frame data, wrap them in expressions, and save them as .jsxbin blobs), then in-line them with eval() calls.

It would be pretty limiting, and it would make you as the developer jump through quite a few hoops to publish and maintain, but I guess it could work in some cases.

I also suppose depending on your business model, you could use a tool like DataClay Templater or Modeck, render everything in the cloud, and simply never share your AEP with the end users.

[Walter Soyka]

Unfortunately, there are no features in After Effects that let you lock down a project the way you’re describing. Even MOGRTs can be reopened and inspected in After Effects.

If you want to try to keep your code secret, you might consider obfuscating your expressions — intentionally making them harder to read and understand. You can find a few free tools online for JavaScript obfuscation.

I know that it totally depends on your situation, by personally, in my career, I’ve gone the other way. Since there are no real tools for securing authorship, I’ve kept my expression code and systems clean, documented them, and put my contact information in there. I’d rather build a reputation for solving hard problems and being easy to work with than turning over inscrutable projects.

[Walter Soyka]

Wow, there’s a blast from the past!

Puget Systems has been refining a modern Ae benchmark that stresses different subsystems in Ae over the last few years. They’ve just done a big overhaul on the benchmark and their scoring system, and they’re looking for new data if you’re interested in running it:

https://www.pugetsystems.com/pugetbench/creators/after-effects/

pugetsystems.com

PugetBench for After Effects

PugetBench for After Effects runs on top of your installed copy of Adobe After Effects, providing benchmark data directly from the application.

[Walter Soyka]

I wrote a quick script that does exactly this a few years back:

http://www.renderbreak.com/2014/07/after-effects-script-keen_3dlayertools/

[Walter Soyka]

Not the precomp itself. Apply this to each layer within the precomp that you want to appear randomly. (As a shortcut, you can apply it to the first layer, then copy the opacity property, select all the other layers, and paste.)

[Walter Soyka]

Jessica, this will replace your previous code. Apply just the expression I wrote to the Opacity property of any layer(s) you want to have randomly appear.

[Walter Soyka]

If I’m understanding right and you’d like a layer to randomly appear and stay visible, you could apply this expression to its Opacity property. I’ve tried to make the code as approachable as possible, but I’m happy to answer any questions:

// set the earliest and latest possible appearance times, in seconds
var minTime = 0;
var maxTime = 5;
// use the layer index to seed the random number generator, 
// and make the result timeless (so the random numbers that
// are generated are consistent from frame to frame
seedRandom(index, true);
// randomly choose a time for this layer to appear,
// from the minimum time to the maximum time specified
// above. We'll use "gaussRandom()" instead of "random()"
// for a more pleasing distribution of random values
var appearTime = gaussRandom(minTime, maxTime);
// this layer should start with 0% opacity (invisible)
var visibility = 0;
// if the current time is greater than the appearance time, 
// set visibility to 100%
if (time > appearTime) {
	visibility = 100;
}
// return our "visibility" variable
visibility