diff --git a/src/applications/files/transform/PhabricatorFileImageTransform.php b/src/applications/files/transform/PhabricatorFileImageTransform.php
index 4878b9e2c7..3c44825dd5 100644
--- a/src/applications/files/transform/PhabricatorFileImageTransform.php
+++ b/src/applications/files/transform/PhabricatorFileImageTransform.php
@@ -1,302 +1,348 @@
 <?php
 
 abstract class PhabricatorFileImageTransform extends PhabricatorFileTransform {
 
   private $file;
   private $data;
   private $image;
   private $imageX;
   private $imageY;
 
   public function canApplyTransform(PhabricatorFile $file) {
     if (!$file->isViewableImage()) {
       return false;
     }
 
     if (!$file->isTransformableImage()) {
       return false;
     }
 
     return true;
   }
 
   protected function willTransformFile(PhabricatorFile $file) {
     $this->file = $file;
     $this->data = null;
     $this->image = null;
     $this->imageX = null;
     $this->imageY = null;
   }
 
   protected function applyCropAndScale(
     $dst_w, $dst_h,
     $src_x, $src_y,
     $src_w, $src_h,
     $use_w, $use_h) {
 
     // Figure out the effective destination width, height, and offsets. We
     // never want to scale images up, so if we're copying a very small source
     // image we're just going to center it in the destination image.
     $cpy_w = min($dst_w, $src_w, $use_w);
     $cpy_h = min($dst_h, $src_h, $use_h);
     $off_x = ($dst_w - $cpy_w) / 2;
     $off_y = ($dst_h - $cpy_h) / 2;
 
-    // TODO: Support imagemagick for animated GIFs.
+    if ($this->shouldUseImagemagick()) {
+      $argv = array();
+      $argv[] = '-coalesce';
+      $argv[] = '-shave';
+      $argv[] = $src_x.'x'.$src_y;
+      $argv[] = '-resize';
+      $argv[] = $dst_w.'x'.$dst_h.'>';
+      $argv[] = '-bordercolor';
+      $argv[] = 'rgba(255, 255, 255, 0)';
+      $argv[] = '-border';
+      $argv[] = $off_x.'x'.$off_y;
+      return $this->applyImagemagick($argv);
+    }
 
     $src = $this->getImage();
     $dst = $this->newEmptyImage($dst_w, $dst_h);
 
     $trap = new PhutilErrorTrap();
     $ok = @imagecopyresampled(
       $dst,
       $src,
       $off_x, $off_y,
       $src_x, $src_y,
       $cpy_w, $cpy_h,
       $src_w, $src_h);
     $errors = $trap->getErrorsAsString();
     $trap->destroy();
 
     if ($ok === false) {
       throw new Exception(
         pht(
           'Failed to imagecopyresampled() image: %s',
           $errors));
     }
 
     $data = PhabricatorImageTransformer::saveImageDataInAnyFormat(
       $dst,
       $this->file->getMimeType());
 
     return $this->newFileFromData($data);
   }
 
+  protected function applyImagemagick(array $argv) {
+    $tmp = new TempFile();
+    Filesystem::writeFile($tmp, $this->getData());
+
+    $out = new TempFile();
+
+    $future = new ExecFuture('convert %s %Ls %s', $tmp, $argv, $out);
+    // Don't spend more than 10 seconds resizing; just fail if it takes longer
+    // than that.
+    $future->setTimeout(10)->resolvex();
+
+    $data = Filesystem::readFile($out);
+
+    return $this->newFileFromData($data);
+  }
+
 
   /**
    * Create a new @{class:PhabricatorFile} from raw data.
    *
    * @param string Raw file data.
    */
   protected function newFileFromData($data) {
     $name = $this->getTransformKey().'-'.$this->file->getName();
 
     return PhabricatorFile::newFromFileData(
       $data,
       array(
         'name' => $name,
         'canCDN' => true,
       ));
   }
 
 
   /**
    * Create a new image filled with transparent pixels.
    *
    * @param int Desired image width.
    * @param int Desired image height.
    * @return resource New image resource.
    */
   protected function newEmptyImage($w, $h) {
     $w = (int)$w;
     $h = (int)$h;
 
     if (($w <= 0) || ($h <= 0)) {
       throw new Exception(
         pht('Can not create an image with nonpositive dimensions.'));
     }
 
     $trap = new PhutilErrorTrap();
     $img = @imagecreatetruecolor($w, $h);
     $errors = $trap->getErrorsAsString();
     $trap->destroy();
     if ($img === false) {
       throw new Exception(
         pht(
           'Unable to imagecreatetruecolor() a new empty image: %s',
           $errors));
     }
 
     $trap = new PhutilErrorTrap();
     $ok = @imagesavealpha($img, true);
     $errors = $trap->getErrorsAsString();
     $trap->destroy();
     if ($ok === false) {
       throw new Exception(
         pht(
           'Unable to imagesavealpha() a new empty image: %s',
           $errors));
     }
 
     $trap = new PhutilErrorTrap();
     $color = @imagecolorallocatealpha($img, 255, 255, 255, 127);
     $errors = $trap->getErrorsAsString();
     $trap->destroy();
     if ($color === false) {
       throw new Exception(
         pht(
           'Unable to imagecolorallocatealpha() a new empty image: %s',
           $errors));
     }
 
     $trap = new PhutilErrorTrap();
     $ok = @imagefill($img, 0, 0, $color);
     $errors = $trap->getErrorsAsString();
     $trap->destroy();
     if ($ok === false) {
       throw new Exception(
         pht(
           'Unable to imagefill() a new empty image: %s',
           $errors));
     }
 
     return $img;
   }
 
 
   /**
    * Get the pixel dimensions of the image being transformed.
    *
    * @return list<int, int> Width and height of the image.
    */
   protected function getImageDimensions() {
     if ($this->imageX === null) {
       $image = $this->getImage();
 
       $trap = new PhutilErrorTrap();
       $x = @imagesx($image);
       $y = @imagesy($image);
       $errors = $trap->getErrorsAsString();
       $trap->destroy();
 
       if (($x === false) || ($y === false) || ($x <= 0) || ($y <= 0)) {
         throw new Exception(
           pht(
             'Unable to determine image dimensions with '.
             'imagesx()/imagesy(): %s',
             $errors));
       }
 
       $this->imageX = $x;
       $this->imageY = $y;
     }
 
     return array($this->imageX, $this->imageY);
   }
 
 
   /**
    * Get the raw file data for the image being transformed.
    *
    * @return string Raw file data.
    */
   protected function getData() {
     if ($this->data !== null) {
       return $this->data;
     }
 
     $file = $this->file;
 
     $max_size = (1024 * 1024 * 4);
     $img_size = $file->getByteSize();
     if ($img_size > $max_size) {
       throw new Exception(
         pht(
           'This image is too large to transform. The transform limit is %s '.
           'bytes, but the image size is %s bytes.',
           new PhutilNumber($max_size),
           new PhutilNumber($img_size)));
     }
 
     $data = $file->loadFileData();
     $this->data = $data;
     return $this->data;
   }
 
 
   /**
    * Get the GD image resource for the image being transformed.
    *
    * @return resource GD image resource.
    */
   protected function getImage() {
     if ($this->image !== null) {
       return $this->image;
     }
 
     if (!function_exists('imagecreatefromstring')) {
       throw new Exception(
         pht(
           'Unable to transform image: the imagecreatefromstring() function '.
           'is not available. Install or enable the "gd" extension for PHP.'));
     }
 
     $data = $this->getData();
     $data = (string)$data;
 
     // First, we're going to write the file to disk and use getimagesize()
     // to determine its dimensions without actually loading the pixel data
     // into memory. For very large images, we'll bail out.
 
     // In particular, this defuses a resource exhaustion attack where the
     // attacker uploads a 40,000 x 40,000 pixel PNGs of solid white. These
     // kinds of files compress extremely well, but require a huge amount
     // of memory and CPU to process.
 
     $tmp = new TempFile();
     Filesystem::writeFile($tmp, $data);
     $tmp_path = (string)$tmp;
 
     $trap = new PhutilErrorTrap();
     $info = @getimagesize($tmp_path);
     $errors = $trap->getErrorsAsString();
     $trap->destroy();
 
     unset($tmp);
 
     if ($info === false) {
       throw new Exception(
         pht(
           'Unable to get image information with getimagesize(): %s',
           $errors));
     }
 
     list($width, $height) = $info;
     if (($width <= 0) || ($height <= 0)) {
       throw new Exception(
         pht(
           'Unable to determine image width and height with getimagesize().'));
     }
 
     $max_pixels = (4096 * 4096);
     $img_pixels = ($width * $height);
 
     if ($img_pixels > $max_pixels) {
       throw new Exception(
         pht(
           'This image (with dimensions %spx x %spx) is too large to '.
           'transform. The image has %s pixels, but transforms are limited '.
           'to images with %s or fewer pixels.',
           new PhutilNumber($width),
           new PhutilNumber($height),
           new PhutilNumber($img_pixels),
           new PhutilNumber($max_pixels)));
     }
 
     $trap = new PhutilErrorTrap();
     $image = @imagecreatefromstring($data);
     $errors = $trap->getErrorsAsString();
     $trap->destroy();
 
     if ($image === false) {
       throw new Exception(
         pht(
           'Unable to load image data with imagecreatefromstring(): %s',
           $errors));
     }
 
     $this->image = $image;
     return $this->image;
   }
 
+  private function shouldUseImagemagick() {
+    if (!PhabricatorEnv::getEnvConfig('files.enable-imagemagick')) {
+      return false;
+    }
+
+    if ($this->file->getMimeType() != 'image/gif') {
+      return false;
+    }
+
+    // Don't try to preserve the animation in huge GIFs.
+    list($x, $y) = $this->getImageDimensions();
+    if (($x * $y) > (512 * 512)) {
+      return false;
+    }
+
+    return true;
+  }
+
 }