"alt" + "⇧" + "="

"⌘" + "alt" + "/"

"+" and "-"

"alt" + "["

"alt" + "]"

"⌘" + "⇧" + "d"

"j"

"k"

"alt" + ","

"alt" + "⇧" + "f"

"alt" + "+" or "-"

"⌘" + "Shift" + "k"

"⌘" + "Option" + "k"

"⇧" + "esc"

ON TERMINAL:
kill ~SEGV #

"Command" + "Option" + "L"

"Shift" + "F3"

"Shift" + "EE"

"x"

In Timeline: Alt-click one keyframe, then another

⌘E

In Graph Editor: ALT-click any curve

In Graph Editor: CTRL-click curve

In Graph Editor: ALT-click any point on curve

In Graph Editor: after selecting keyframe, hold down CTRL while moving key
In Timeline: CTRL-click "Twirl Triangle" of a layer

In Graph Editor: Graph Options

In Graph Editor: Show Properties

In Timeline: CTRL + ALT click keyframe

CTRL+SHIFT+ALT+U
Add it to a null "position"

Ctrl+shift+Alt+right arrow
 Function

Remove Expressions

Remove Expressions

Cut in point

Cut out point

Duplicate Layer in position

next keyframe

previous keyframe

On/Off Proportional Grid

fit to screen

scale (hold shift for +-10)

keyframe velocity
keyframe interpolation

toggle between comps

if AE is froze, saves your project file

Reload selected footage items

toggles between Timeline/Graph Editor

Hides Expressions

Scrolls to first active selected layer.

Info panel shows duration between keyframes

opens selected layer directly in PS, AI, Premiere, Cinema 4D… the original program used
to create it.

Selects all points on the curve

Adds additional points to curve

Toggles between linear point and Bezier

Engages Snap function in curve editor

Folds and unfolds Layer attributes

Options to show Timeline-centric info in the Curve Editor

Filter on/off which curves are viewed

Convert to hold keyframe

Display as wireframe
Create smooth rolling credits (jgadpp.com)

advanced keyframe
 Notes

http://www.shortcutworld.com/en/mac/After-Effects_CS5.html

sc
Go back and forth between actual comp and the previous one opened

find after effects number on monitor. open terminal and put the action, replace # with AE monitor number.

Faster than having to manually step through timeline to count frames

This sometimes ends up being a lot faster than having to marquee select the entire curve.

Faster than scrubbing input to add a point to the curve

Faster than having to open Keyframe Interpolation and encourages unique ease beyond standard Easy Ease

Cool thing about this is that the Snap function includes lots of stuff, like key values, work area, and the CTI. It's annoying to always turn the Sn
on and off — this makes it quick and painless.
I use this to clean-up a layer that has lots of properties that can be twirled (like Particular), basically a reset button for a layer's UI; can also be
complex folder hierarchies in Project window

I turn on Show Layer Markers & Show Layer In/Out in that second dropdown at the bottom of the curve editor so I can make timing notes in th
with Layer Markers, but still see them in the Curve Editor

Ever turn on that little Graph Editor switch next to a properties keyframe — and now no matter what you select, that property is stuck in the GE
Show Graph Editor Set in the first dropdwon at the bottom of the GE to make it go away for the time being.

A little faster than right-clicking and searching for Toggle Hold Keyframe

Quality & Sampling toggle switch in the timeline is weird, only toggles between Best, Draft, and Bicubic. Useful to draw a particularly slow laye
without having to go full-on wireframe mode
Create a null, go to Animation>Add Expression. Paste it. Then parent all your credits to the null
thisComp.layer(“Light 1“).toComp([0,0,0]);

lay = thisComp.layer("Shape Layer 2");

lay.toComp(lay.transform.anchorPoint);
point1=this_layer.position;
point2=this_comp.layer("Drag Me").position;
delta=sub(point1, point2);
distance=length(delta);
linear(distance, 0, 80, [250,250], [75,75]);

loopOut("cycle",0) | loopOut("pingpong",0)

seedRandom(index,true);
myValue = random(50) ;

delay = 5; //number of frames to delay

d = delay*thisComp.frameDuration*(index - 1);
thisComp.layer(1).rotation.valueAtTime(time - d)

lay = thisComp.layer("Null 3")

wrld=lay.toWorld(lay.position);
[wrld[0],wrld[1]]

lay = thisComp.layer("Null 3")

wrld=lay.toWorld(lay.position);
[wrld[2]]

n=thisComp.layer("Null 2")
nullpos=n.toComp(n.anchorPoint);
fromComp(nullpos);
seedRandom(index,true);
freezeTime = random();
Math.min(time,freezeTime)

thisComp.layer("Controller").effect("Controller")("Slider")/50

posterizeTime(12);
value;

In Slider:
effect("Angle Control")(1)%360

In Time Remap:
effect("Angle Control")("Angle")/24;

distance=position[0];
circumference=width*Math.PI;
distance/circumference*360;
fps=15; //frequency
amount=50; //amplitude
wiggle(fps,amount,octaves = 1, amp_mult = 0.5,(Math.round(time*fps))/fps);wiggle(fps,amount,octaves = 1, amp_mult = 0.5,(Math.round(time*fps))/fps);

alt:

x=thisComp.layer("OTHERLAYER").transform.opacity;

posterizeTime(5);
wiggle(5,35)

posterizeTime(12);
value;
w = wiggle(2,50);
[w[0],value[1]]
w = wiggle(2,50);
[value[0],w[1]]
freq = .5;
amp = 20;
loopTime = 3;
t = time % loopTime;
wiggle1 = wiggle(freq, amp, 1, 0.5, t);
wiggle2 = wiggle(freq, amp, 1, 0.5, t - loopTime);
linear(t, 0, loopTime, wiggle1, wiggle2)

L = thisComp.layer("Null 1");
L.toWorld(L.anchorPoint)
x = transform.position[0];
y = transform.position[1];
w = wiggle(3, 200);

[w[0], y];

[position[0], position[1],0.5* thisLayer.index];

s=Math.exp(transform.scale[0]/21.667905)-1;
[s,s]

n=0;if(marker.numKeys>0){n=marker.nearestKey(time).index;if(marker.key(n).time>time){n--;}if(n==0){value;}
else{
t=time-marker.key(n).time; //time since marker
//Do Stuff
}} else value;

i = index-parent.index-1;
valueAtTime(framesToTime(linear(parentslider,0,100,-100,100)));

i = index-parent.index-1; parentproperty.valueAtTime(time+i*offset);

xAmp = 3; //height of undulations (pixels)

xFreq = .3; //undulations per second
xSpeed = 150; //speed of wave (pixels per second)

wl = xSpeed/xFreq; //wavelength (pixels)

phaseOffset = ((position[0]%wl)/wl)*2*Math.PI;
y = xAmp*Math.sin(2*Math.PI*xFreq*time + phaseOffset);
value + [0,y]

damping = 15; //undulation damping factor

wl = xSpeed/xFreq; //wavelength (pixels)

phaseOffset = ((position[0]%wl)/wl)*2*Math.PI;
if (numKeys >1 && time > key(numKeys).time){
t1 = key(1).time;
t2 = key(numKeys).time;
span = t2 - t1;
delta = time - t2;
t = delta%span;
valueAtTime(t1 + t)
}else
value

delta = position - thisComp.layer("TARGET").transform.position;

radians_to_degrees(Math.atan2(delta[1],delta[0]))

(hasParent) ? parent.opacity : value;

(hasParent) ? (parent.opacity/100) * value : value;

p0 = L.transform.position.valueAtTime(0);
p1 = L.transform.position;

[2*p0[0]-p1[0],p1[1]]
nominalDist = 200;

d = length (thisComp.layer("Camera 1").toWorld([0,0,0]),toWorld(anchorPoint));

value*(d/nominalDist)
try{
s = scale [0]/100;
L = thisLayer;
while (L.hasParent){
s *= L.parent.scale[0]/100;
L = L.parent;
}
w = value;
w/s
}catch(e){
value;
};
L.toComp (L.anchorPoint);

for
L = (ithisComp.layer("EPoint");
= 0; i < ps.length; i++){
s[i] = value[i]*100/ps[i];
loopOut("continue");

colors=[
[141,203,235,255]/255,
[187,223,243,255]/255,
[164,213,239,255]/255,
[205,219,143,255]/255
];

amCol = 4 //Number of colours in the list above

colors[Math.floor(random(amCol-0.0001))];

rate = 4; //value in px/sec.

value - [0,rate*timeToFrames(time)]

sliderPos = thisComp.layer("Slider").effect("Slider Control")("Slider");

framesToTime((Math.round(sliderPos)))
w = wiggle(5,30);
[w[0],w[0]]
veloc = -10; //horizontal velocity (pixels per second)
x = position[0] + (time - inPoint) *veloc;
y = position[1];
delay = .05;
leader = thisComp.layer(1);
leader.transform.rotation.valueAtTime(time - delay*(index-leader.index));

.valueAtTime(time - 2*thisComp.frameDuration)

MasterC = "Master";
PreC = thisComp.name;

C = comp(MasterC);
L = C.layer(PreC);
Main_T = time + L.startTime;
Function

2D to 3D Null:

2D to 3D Null (works better)

Apple Magnifying effect (Scales up when it touches Drag Me)

Loop

Frozen random number

Delay

connect to real world position of something (x, y)

connect to real world position of something (z)

connect to real COMP position of something (x, y)

Random Freezed frame

connect timeRemap to slider (0 to 100)

play precomp at 12 fps (even inside a 24fps comp)

connect to timeRemap to Angle Slider

perfect wheel car simulation / rotation

Jumpy Hold Wiggle: wiggle but with hold keyframes

Opposite Transparency from layer to layer

Wiggle with posterize!

Regular posterize to 12 fps

Wiggle only in X

Wiggle only in Y

Loop your wiggle!

loopTime = the length in seconds of your loop

world position

wiggle in one direction

duplicate layer in z space

Exponential Scale

Trigger expression on marker

Use with array expressions to measure the relative index from a layer to its parent/controller.
Remap an animation on the first 100 frames using a slider from -100 to 100.

Delay a property from a controller based on the relative index.

undulating surface: POSITION

undulating surface: ROTATION

Loop Mask Animation

Add to Rotation of 2D null and will aim at "TARGET" layer

Inherits opacity from parent

Inherits opacity from parent but retains the child's editabilty

Takes parents position independently in one or more direction. With abality to adjust speed

add this expression to the stroke width of a 3D shape layer to keep the same width no matter where in Z the layer is
add to stroke width of shape layer to maintain stroke and path width during scale

link Beam effect to two diferrent nulls

Maintain scale when parented

continue value of keyframes

random colours from range

It will make your credits run smooth

TimeRemap to slider
Wiggle Uniform Scale
Wiggle Scale One Axis
Constant move in axys X

Delay 2

add to the end of any espression to offset or delay the expression.

Helpful for precomps

allows you to source a master Audio comp to be nested/updated in all of your precomps. Useful when working with music/ VO
 Notes Useful Plugin/Script

beware! toComp/fromComp/toWorld/fromWorld/etc
https://github.com/chriskelley/work-scripts
are complex and must be used carefully

http://www.smipple.net/tag/ft-toolbar

change 0 to 1 to loop the last two k frames of the

time remap. "cycle" for cycle looping or "pingpong" https://drive.google.com/file/d/0B7LFUuSb6Ow7bmtRQXYwWWxZUTQ/view?usp=sha
for pingpong looping

http://www.batchframe.com/custom_controls/

DELAY FOR SPECIFIC LAYER

lay = thisComp.layer("SquareMoves")
https://www.dropbox.com/s/bgnf9hlxkezj2df/sw_BeatSequencer.jsx?dl=0
delay = 1; //number of frames to delay
d = delay*thisComp.frameDuration;
lay.rotation.valueAtTime(time - d)

IF IT DOESN'T WORK (if you have the layer

connected to a null for example) change it to the
anchorPoint, so:
https://bitbucket.org/snippets/kyletmartinez/
lay = thisComp.layer("Null 3")
wrld=lay.toWorld(lay. anchorPoint);
[wrld[0],wrld[1]]

IF IT DOESN'T WORK (if you have the layer

connected to a null for example) change it to the
anchorPoint, so:
lay = thisComp.layer("Null 3")
wrld=lay.toWorld(lay.anchorPoint);
[wrld[2]]

ESPECIALLY PUPPET TOOL POINT TO NULL

seedRandom(index,true);
freezeTime = random();
freezeTime = random(inPoint,key(2).time -
thisComp.frameDuration)

you can also do this:

posterizeTime(comp("comp").frameDuration)
/24 = frameRate
%360 = frames inside precomp
(1) = sometimes needed before %360

put the radius of your circumference (wheel) in the

"width" spot in the expression
Simple, f - a parameters control speed and
distance of jump

RANDOM each frame:

posterizeTime(0.000001);
wiggle(5,35);

Paste it on the position parameter and start

duplicating the layer

Replace ‘//Do Stuff’ with code to be triggered at a

maker. One use is to trigger keyframed animation
from the begining of the layer (eg.
valueAtTime(inPoint+t))
Replace "parentslider" with the reference to your
slider effect. Really useful for character rigging.

Replace "parentproperty" with the controlling

property.

Apply to mask path of layer to loop keyframed

masks.

delta = toWorld(anchorPoint) -
thisComp.activeCamera.toWorld([0,0,0]);
radiansToDegrees(Math.atan2(delta[0],delta[2]))

The additional bits of code catch any accidental

unparenting
The parent's opacity value acts as a mulitplier for
the child's

value / (length(toComp([0,0]), toComp([1,0])) ||

0.00001)
value/(scale[0]/100)

///If you want to hold colour, add:

amCol = 4 //Number of colours in the list above

seedRandom(1, true);
colors[Math.floor(random(amCol-0.0001))];

You can change the rate value at your will.

found here
 Description

A collection of scripts created for streamlining my

compositing workflow in After Effects and Cinema 4D.

JS for ft-Toolbar

Paul's TypeIn_Interpolate preset. Explained in

Expression comments.

Wrote this for a job i'm on, useful for placing layers or
comps in time with music.

Select the layers you want to dupe, then a layer with

Markers on it and hit the button.