diff --git a/quickstep/src/com/android/launcher3/LauncherAppTransitionManagerImpl.java b/quickstep/src/com/android/launcher3/LauncherAppTransitionManagerImpl.java
index 11bc883..2f0cd78 100644
--- a/quickstep/src/com/android/launcher3/LauncherAppTransitionManagerImpl.java
+++ b/quickstep/src/com/android/launcher3/LauncherAppTransitionManagerImpl.java
@@ -47,6 +47,10 @@
 import com.android.launcher3.anim.Interpolators;
 import com.android.launcher3.dragndrop.DragLayer;
 import com.android.launcher3.graphics.DrawableFactory;
+import com.android.quickstep.RecentsAnimationInterpolator;
+import com.android.quickstep.RecentsAnimationInterpolator.TaskWindowBounds;
+import com.android.quickstep.RecentsView;
+import com.android.quickstep.TaskView;
 import com.android.systemui.shared.system.ActivityCompat;
 import com.android.systemui.shared.system.ActivityOptionsCompat;
 import com.android.systemui.shared.system.RemoteAnimationAdapterCompat;
@@ -70,6 +74,7 @@
     private static final String CONTROL_REMOTE_APP_TRANSITION_PERMISSION =
             "android.permission.CONTROL_REMOTE_APP_TRANSITION_ANIMATIONS";
 
+    private static final int RECENTS_LAUNCH_DURATION = 336;
     private static final int LAUNCHER_RESUME_START_DELAY = 150;
     private static final int CLOSING_TRANSITION_DURATION_MS = 350;
 
@@ -139,8 +144,18 @@
                         // Post at front of queue ignoring sync barriers to make sure it gets
                         // processed before the next frame.
                         postAtFrontOfQueueAsynchronously(v.getHandler(), () -> {
-                            LauncherTransitionAnimator animator = new LauncherTransitionAnimator(
-                                    getLauncherAnimators(v), getWindowAnimators(v, targets));
+                            final boolean removeTrackingView;
+                            LauncherTransitionAnimator animator =
+                                    composeRecentsLaunchAnimator(v, targets);
+                            if (animator != null) {
+                                // We are animating the task view directly, do not remove it after
+                                removeTrackingView = false;
+                            } else {
+                                animator = composeAppLaunchAnimator(v, targets);
+                                // A new floating view is created for the animation, remove it after
+                                removeTrackingView = true;
+                            }
+
                             setCurrentAnimator(animator);
                             mAnimator = animator.getAnimatorSet();
                             mAnimator.addListener(new AnimatorListenerAdapter() {
@@ -148,7 +163,10 @@
                                 public void onAnimationEnd(Animator animation) {
                                     // Reset launcher to normal state
                                     v.setVisibility(View.VISIBLE);
-                                    ((ViewGroup) mDragLayer.getParent()).removeView(mFloatingView);
+                                    if (removeTrackingView) {
+                                        ((ViewGroup) mDragLayer.getParent()).removeView(
+                                                mFloatingView);
+                                    }
 
                                     mDragLayer.setAlpha(1f);
                                     mDragLayer.setTranslationY(0f);
@@ -179,6 +197,131 @@
     }
 
     /**
+     * Composes the animations for a launch from the recents list if possible.
+     */
+    private LauncherTransitionAnimator composeRecentsLaunchAnimator(View v,
+            RemoteAnimationTargetCompat[] targets) {
+        // Ensure recents is actually visible
+        if (!mLauncher.isInState(LauncherState.OVERVIEW)) {
+            return null;
+        }
+
+        // Resolve the opening task id
+        int openingTaskId = -1;
+        for (RemoteAnimationTargetCompat target : targets) {
+            if (target.mode == RemoteAnimationTargetCompat.MODE_OPENING) {
+                openingTaskId = target.taskId;
+                break;
+            }
+        }
+
+        // If there is no opening task id, fall back to the normal app icon launch animation
+        if (openingTaskId == -1) {
+            return null;
+        }
+
+        // If the opening task id is not currently visible in overview, then fall back to normal app
+        // icon launch animation
+        RecentsView recentsView = mLauncher.getOverviewPanel();
+        TaskView taskView = recentsView.getTaskView(openingTaskId);
+        if (taskView == null || !recentsView.isTaskViewVisible(taskView)) {
+            return null;
+        }
+
+        // Found a visible recents task that matches the opening app, lets launch the app from there
+        return new LauncherTransitionAnimator(null, getRecentsWindowAnimator(taskView, targets));
+    }
+
+    /**
+     * @return Animator that controls the window of the opening targets for the recents launch
+     * animation.
+     */
+    private ValueAnimator getRecentsWindowAnimator(TaskView v,
+            RemoteAnimationTargetCompat[] targets) {
+        Rect taskViewBounds = new Rect();
+        mDragLayer.getDescendantRectRelativeToSelf(v, taskViewBounds);
+
+        // TODO: Use the actual target insets instead of the current thumbnail insets in case the
+        // device state has changed
+        RecentsAnimationInterpolator recentsInterpolator = new RecentsAnimationInterpolator(
+                new Rect(0, 0, mDeviceProfile.widthPx, mDeviceProfile.heightPx),
+                v.getThumbnail().getInsets(),
+                taskViewBounds, new Rect(0, v.getThumbnail().getTop(), 0, 0));
+
+        Rect crop = new Rect();
+        Matrix matrix = new Matrix();
+
+        ValueAnimator appAnimator = ValueAnimator.ofFloat(0, 1);
+        appAnimator.setDuration(RECENTS_LAUNCH_DURATION);
+        appAnimator.setInterpolator(Interpolators.TOUCH_RESPONSE_INTERPOLATOR);
+        appAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
+            boolean isFirstFrame = true;
+
+            @Override
+            public void onAnimationUpdate(ValueAnimator animation) {
+                final Surface surface = getSurface(v);
+                final long frameNumber = surface != null ? getNextFrameNumber(surface) : -1;
+                if (frameNumber == -1) {
+                    // Booo, not cool! Our surface got destroyed, so no reason to animate anything.
+                    Log.w(TAG, "Failed to animate, surface got destroyed.");
+                    return;
+                }
+                final float percent = animation.getAnimatedFraction();
+                TaskWindowBounds tw = recentsInterpolator.interpolate(percent);
+
+                v.setScaleX(tw.taskScale);
+                v.setScaleY(tw.taskScale);
+                v.setTranslationX(tw.taskX);
+                v.setTranslationY(tw.taskY);
+                // Defer fading out the view until after the app window gets faded in
+                v.setAlpha(getValue(1f, 0f, 75, 75,
+                        appAnimator.getDuration() * percent, Interpolators.LINEAR));
+
+                matrix.setScale(tw.winScale, tw.winScale);
+                matrix.postTranslate(tw.winX, tw.winY);
+                crop.set(tw.winCrop);
+
+                // Fade in the app window.
+                float alphaDelay = 0;
+                float alphaDuration = 75;
+                float alpha = getValue(0f, 1f, alphaDelay, alphaDuration,
+                        appAnimator.getDuration() * percent, Interpolators.LINEAR);
+
+                TransactionCompat t = new TransactionCompat();
+                for (RemoteAnimationTargetCompat target : targets) {
+                    if (target.mode == RemoteAnimationTargetCompat.MODE_OPENING) {
+                        t.setAlpha(target.leash, alpha);
+
+                        // TODO: This isn't correct at the beginning of the animation, but better
+                        // than nothing.
+                        matrix.postTranslate(target.position.x, target.position.y);
+                        t.setMatrix(target.leash, matrix);
+                        t.setWindowCrop(target.leash, crop);
+                        t.deferTransactionUntil(target.leash, surface, getNextFrameNumber(surface));
+                    }
+                    if (isFirstFrame) {
+                        t.show(target.leash);
+                    }
+                }
+                t.apply();
+
+                matrix.reset();
+                isFirstFrame = false;
+            }
+        });
+        return appAnimator;
+    }
+
+    /**
+     * Composes the animations for a launch from an app icon.
+     */
+    private LauncherTransitionAnimator composeAppLaunchAnimator(View v,
+            RemoteAnimationTargetCompat[] targets) {
+        return new LauncherTransitionAnimator(getLauncherAnimators(v),
+                getWindowAnimators(v, targets));
+    }
+
+    /**
      * @return Animators that control the movements of the Launcher and icon of the opening target.
      */
     private AnimatorSet getLauncherAnimators(View v) {
diff --git a/quickstep/src/com/android/launcher3/LauncherTransitionAnimator.java b/quickstep/src/com/android/launcher3/LauncherTransitionAnimator.java
index 80eaef7..aec2869 100644
--- a/quickstep/src/com/android/launcher3/LauncherTransitionAnimator.java
+++ b/quickstep/src/com/android/launcher3/LauncherTransitionAnimator.java
@@ -32,11 +32,15 @@
     private Animator mWindowAnimator;
 
     LauncherTransitionAnimator(Animator launcherAnimator, Animator windowAnimator) {
-        mLauncherAnimator = launcherAnimator;
+        if (launcherAnimator != null) {
+            mLauncherAnimator = launcherAnimator;
+        }
         mWindowAnimator = windowAnimator;
 
         mAnimatorSet = new AnimatorSet();
-        mAnimatorSet.play(launcherAnimator);
+        if (launcherAnimator != null) {
+            mAnimatorSet.play(launcherAnimator);
+        }
         mAnimatorSet.play(windowAnimator);
     }
 
@@ -53,6 +57,8 @@
     }
 
     public void finishLauncherAnimation() {
-        mLauncherAnimator.end();
+        if (mLauncherAnimator != null) {
+            mLauncherAnimator.end();
+        }
     }
 }
diff --git a/quickstep/src/com/android/quickstep/RecentsAnimationInterpolator.java b/quickstep/src/com/android/quickstep/RecentsAnimationInterpolator.java
new file mode 100644
index 0000000..9cc038f
--- /dev/null
+++ b/quickstep/src/com/android/quickstep/RecentsAnimationInterpolator.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.quickstep;
+
+import android.graphics.Rect;
+
+import com.android.launcher3.Utilities;
+
+/**
+ * Helper class to interpolate the animation between a task view representation and an actual
+ * window.
+ */
+public class RecentsAnimationInterpolator {
+
+    public static class TaskWindowBounds {
+        public float taskScale = 1f;
+        public float taskX = 0f;
+        public float taskY = 0f;
+
+        public float winScale = 1f;
+        public float winX = 0f;
+        public float winY = 0f;
+        public Rect winCrop = new Rect();
+
+        @Override
+        public String toString() {
+            return "taskScale=" + taskScale + " taskX=" + taskX + " taskY=" + taskY
+                    + " winScale=" + winScale + " winX=" + winX + " winY=" + winY
+                    + " winCrop=" + winCrop;
+        }
+    }
+
+    private TaskWindowBounds mTmpTaskWindowBounds = new TaskWindowBounds();
+    private Rect mTmpInsets = new Rect();
+
+    private Rect mWindow;
+    private Rect mInsetWindow;
+    private Rect mInsets;
+    private Rect mTask;
+    private Rect mTaskInsets;
+    private Rect mThumbnail;
+
+    private float mTaskScale;
+    private Rect mScaledTask;
+    private Rect mTargetTask;
+    private Rect mSrcWindow;
+
+    public RecentsAnimationInterpolator(Rect window, Rect insets, Rect task, Rect taskInsets) {
+        mWindow = window;
+        mInsets = insets;
+        mTask = task;
+        mTaskInsets = taskInsets;
+        mInsetWindow = new Rect(window);
+        Utilities.insetRect(mInsetWindow, insets);
+
+        mThumbnail = new Rect(task);
+        Utilities.insetRect(mThumbnail, taskInsets);
+        mTaskScale = (float) mInsetWindow.width() / mThumbnail.width();
+        mScaledTask = new Rect(task);
+        Utilities.scaleRectAboutCenter(mScaledTask, mTaskScale);
+        Rect finalScaledTaskInsets = new Rect(taskInsets);
+        Utilities.scaleRect(finalScaledTaskInsets, mTaskScale);
+        mTargetTask = new Rect(mInsetWindow);
+        mTargetTask.offsetTo(window.top + insets.top - finalScaledTaskInsets.top,
+                window.left + insets.left - finalScaledTaskInsets.left);
+
+        float initialWinScale = 1f / mTaskScale;
+        Rect scaledWindow = new Rect(mInsetWindow);
+        Utilities.scaleRectAboutCenter(scaledWindow, initialWinScale);
+        Rect scaledInsets = new Rect(insets);
+        Utilities.scaleRect(scaledInsets, initialWinScale);
+        mSrcWindow = new Rect(scaledWindow);
+        mSrcWindow.offsetTo(mThumbnail.left - scaledInsets.left,
+                mThumbnail.top - scaledInsets.top);
+    }
+
+    public TaskWindowBounds interpolate(float t) {
+        mTmpTaskWindowBounds.taskScale = Utilities.mapRange(t,
+                1, (float) mInsetWindow.width() / mThumbnail.width());
+        mTmpTaskWindowBounds.taskX = Utilities.mapRange(t,
+                0, mTargetTask.left - mScaledTask.left);
+        mTmpTaskWindowBounds.taskY = Utilities.mapRange(t,
+                0, mTargetTask.top - mScaledTask.top);
+
+        mTmpTaskWindowBounds.winScale = mTmpTaskWindowBounds.taskScale / mTaskScale;
+        mTmpTaskWindowBounds.winX = Utilities.mapRange(t,
+                mSrcWindow.left, 0);
+        mTmpTaskWindowBounds.winY = Utilities.mapRange(t,
+                mSrcWindow.top, 0);
+
+        mTmpInsets.set(mInsets);
+        Utilities.scaleRect(mTmpInsets, (1f - t));
+        mTmpTaskWindowBounds.winCrop.set(mWindow);
+        Utilities.insetRect(mTmpTaskWindowBounds.winCrop, mTmpInsets);
+
+        return mTmpTaskWindowBounds;
+    }
+}
diff --git a/quickstep/src/com/android/quickstep/RecentsView.java b/quickstep/src/com/android/quickstep/RecentsView.java
index 8e03f37..26fe54e 100644
--- a/quickstep/src/com/android/quickstep/RecentsView.java
+++ b/quickstep/src/com/android/quickstep/RecentsView.java
@@ -215,6 +215,21 @@
         return mFirstTaskIndex;
     }
 
+    public boolean isTaskViewVisible(TaskView tv) {
+        // For now, just check if it's the active task
+        return indexOfChild(tv) == getNextPage();
+    }
+
+    public TaskView getTaskView(int taskId) {
+        for (int i = getFirstTaskIndex(); i < getChildCount(); i++) {
+            TaskView tv = (TaskView) getChildAt(i);
+            if (tv.getTask().key.id == taskId) {
+                return tv;
+            }
+        }
+        return null;
+    }
+
     public void setStateController(RecentsViewStateController stateController) {
         mStateController = stateController;
     }
@@ -254,11 +269,16 @@
         }
         setLayoutTransition(mLayoutTransition);
 
-        // Rebind all task views
+        // Rebind and reset all task views
         for (int i = tasks.size() - 1; i >= 0; i--) {
             final Task task = tasks.get(i);
             final TaskView taskView = (TaskView) getChildAt(tasks.size() - i - 1 + mFirstTaskIndex);
             taskView.bind(task);
+            taskView.setScaleX(1f);
+            taskView.setScaleY(1f);
+            taskView.setTranslationX(0f);
+            taskView.setTranslationY(0f);
+            taskView.setAlpha(1f);
             loader.loadTaskData(task);
         }
     }
diff --git a/quickstep/src/com/android/quickstep/TaskThumbnailView.java b/quickstep/src/com/android/quickstep/TaskThumbnailView.java
index 36a0601..4f93b1c 100644
--- a/quickstep/src/com/android/quickstep/TaskThumbnailView.java
+++ b/quickstep/src/com/android/quickstep/TaskThumbnailView.java
@@ -28,6 +28,7 @@
 import android.graphics.Matrix;
 import android.graphics.Paint;
 import android.graphics.PorterDuff.Mode;
+import android.graphics.Rect;
 import android.graphics.Shader;
 import android.util.AttributeSet;
 import android.view.View;
@@ -108,6 +109,13 @@
         updateThumbnailPaintFilter();
     }
 
+    public Rect getInsets() {
+        if (mThumbnailData != null) {
+            return mThumbnailData.insets;
+        }
+        return new Rect();
+    }
+
     @Override
     protected void onDraw(Canvas canvas) {
         canvas.drawRoundRect(0, 0, getMeasuredWidth(), getMeasuredHeight(),
diff --git a/src/com/android/launcher3/Utilities.java b/src/com/android/launcher3/Utilities.java
index 158c540..d559b44 100644
--- a/src/com/android/launcher3/Utilities.java
+++ b/src/com/android/launcher3/Utilities.java
@@ -237,16 +237,27 @@
             int cx = r.centerX();
             int cy = r.centerY();
             r.offset(-cx, -cy);
+            scaleRect(r, scale);
+            r.offset(cx, cy);
+        }
+    }
 
+    public static void scaleRect(Rect r, float scale) {
+        if (scale != 1.0f) {
             r.left = (int) (r.left * scale + 0.5f);
             r.top = (int) (r.top * scale + 0.5f);
             r.right = (int) (r.right * scale + 0.5f);
             r.bottom = (int) (r.bottom * scale + 0.5f);
-
-            r.offset(cx, cy);
         }
     }
 
+    public static void insetRect(Rect r, Rect insets) {
+        r.left = Math.min(r.right, r.left + insets.left);
+        r.top = Math.min(r.bottom, r.top + insets.top);
+        r.right = Math.max(r.left, r.right - insets.right);
+        r.bottom = Math.max(r.top, r.bottom - insets.bottom);
+    }
+
     public static float shrinkRect(Rect r, float scaleX, float scaleY) {
         float scale = Math.min(Math.min(scaleX, scaleY), 1.0f);
         if (scale < 1.0f) {
@@ -261,6 +272,10 @@
         return scale;
     }
 
+    public static float mapRange(float value, float min, float max) {
+        return min + (value * (max - min));
+    }
+
     public static boolean isSystemApp(Context context, Intent intent) {
         PackageManager pm = context.getPackageManager();
         ComponentName cn = intent.getComponent();
diff --git a/src/com/android/launcher3/anim/Interpolators.java b/src/com/android/launcher3/anim/Interpolators.java
index 2343654..0dcebe3 100644
--- a/src/com/android/launcher3/anim/Interpolators.java
+++ b/src/com/android/launcher3/anim/Interpolators.java
@@ -50,6 +50,9 @@
 
     public static final Interpolator OVERSHOOT_0 = new OvershootInterpolator(0);
 
+    public static final Interpolator TOUCH_RESPONSE_INTERPOLATOR =
+            new PathInterpolator(0.3f, 0f, 0.1f, 1f);
+
     /**
      * Inversion of zInterpolate, compounded with an ease-out.
      */