diff --git a/src/com/facebook/buck/android/BUCK b/src/com/facebook/buck/android/BUCK
index ef50c93..7be1768 100644
--- a/src/com/facebook/buck/android/BUCK
+++ b/src/com/facebook/buck/android/BUCK
@@ -55,6 +55,7 @@
   'AndroidTransitiveDependencyGraph.java',
   'ApkGenrule.java',
   'ApkGenruleBuildRuleFactory.java',
+  'DexProducedFromJavaLibraryThatContainsClassFiles.java',
   'GenAidl.java',
   'GenAidlBuildRuleFactory.java',
   'HasAndroidPlatformTarget.java',
diff --git a/src/com/facebook/buck/android/DexProducedFromJavaLibraryThatContainsClassFiles.java b/src/com/facebook/buck/android/DexProducedFromJavaLibraryThatContainsClassFiles.java
new file mode 100644
index 0000000..0073cc6
--- /dev/null
+++ b/src/com/facebook/buck/android/DexProducedFromJavaLibraryThatContainsClassFiles.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright 2013-present Facebook, Inc.
+ *
+ * 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.facebook.buck.android;
+
+import com.facebook.buck.java.AccumulateClassNames;
+import com.facebook.buck.java.JavaLibraryRule;
+import com.facebook.buck.model.BuildTarget;
+import com.facebook.buck.rules.AbstractBuildRuleBuilderParams;
+import com.facebook.buck.rules.AbstractBuildable;
+import com.facebook.buck.rules.BuildContext;
+import com.facebook.buck.rules.BuildRuleParams;
+import com.facebook.buck.rules.BuildRuleResolver;
+import com.facebook.buck.rules.BuildRuleType;
+import com.facebook.buck.rules.Buildable;
+import com.facebook.buck.rules.BuildableContext;
+import com.facebook.buck.rules.OnDiskBuildInfo;
+import com.facebook.buck.step.AbstractExecutionStep;
+import com.facebook.buck.step.CompositeStep;
+import com.facebook.buck.step.ConditionalStep;
+import com.facebook.buck.step.ExecutionContext;
+import com.facebook.buck.step.Step;
+import com.facebook.buck.step.fs.FileExistsAndIsNotEmptyStep;
+import com.facebook.buck.step.fs.MkdirStep;
+import com.facebook.buck.step.fs.RmStep;
+import com.facebook.buck.util.BuckConstant;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Supplier;
+import com.google.common.base.Suppliers;
+import com.google.common.collect.ImmutableList;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+/**
+ * {@link DexProducedFromJavaLibraryThatContainsClassFiles} is a {@link Buildable} that serves a
+ * very specific purpose: it takes a {@link JavaLibraryRule} and the list of classes in the
+ * {@link JavaLibraryRule} (which is represented by an {@link AccumulateClassNames}), and dexes the
+ * output of the {@link JavaLibraryRule} if its list of classes is non-empty. Because it is
+ * expected to be used with pre-dexing, we always pass the {@code --force-jumbo} flag to {@code dx}
+ * in this buildable.
+ * <p>
+ * Most {@link Buildable}s can determine the (possibly null) path to their output file from their
+ * definition. This is an anomaly because we do not know whether this will write a {@code .dex} file
+ * until runtime. Unfortunately, because there is no such thing as an empty {@code .dex} file, we
+ * cannot write a meaningful "dummy .dex" if there are no class files to pass to {@code dx}.
+ */
+public class DexProducedFromJavaLibraryThatContainsClassFiles extends AbstractBuildable {
+
+  /**
+   * Key used with {@link OnDiskBuildInfo} to identify whether this {@link Buildable} has
+   * generated a {@code .dex} files. The only expected value to be associated with this key is
+   * {@code "true"}.
+   */
+  private static final String HAS_DEX_OUTPUT_METADATA = "HAS_DEX_OUTPUT";
+
+  private final BuildTarget buildTarget;
+  private final AccumulateClassNames javaLibraryWithClassesList;
+
+  /** This {@link Supplier} will be defined and determined after this buildable is built. */
+  @Nullable
+  private Supplier<Boolean> hasOutputFile;
+
+  private DexProducedFromJavaLibraryThatContainsClassFiles(BuildTarget buildTarget,
+      AccumulateClassNames javaLibraryWithClassesList) {
+    this.buildTarget = Preconditions.checkNotNull(buildTarget);
+    this.javaLibraryWithClassesList = Preconditions.checkNotNull(javaLibraryWithClassesList);
+  }
+
+  @Override
+  public Iterable<String> getInputsToCompareToOutput() {
+    // The deps of this rule already capture all of the inputs that should affect the cache key.
+    return ImmutableList.of();
+  }
+
+  @Override
+  public List<Step> getBuildSteps(BuildContext context, final BuildableContext buildableContext)
+      throws IOException {
+    ImmutableList.Builder<Step> steps = ImmutableList.builder();
+
+    steps.add(new RmStep(getPathToDex().toString(), /* shouldForceDeletion */ true));
+
+    // Make sure that the buck-out/gen/ directory exists for this.buildTarget.
+    steps.add(new MkdirStep(getPathToDex().getParent()));
+
+    // Check whether the list of class files in the JavaLibraryRule is empty.
+    FileExistsAndIsNotEmptyStep fileExistsStep = new FileExistsAndIsNotEmptyStep(
+        Paths.get(javaLibraryWithClassesList.getPathToOutputFile()));
+    hasOutputFile = fileExistsStep;
+    steps.add(fileExistsStep);
+
+    // To be conservative, use --force-jumbo for these intermediate .dex files so that they can be
+    // merged into a final classes.dex that uses jumbo instructions.
+    JavaLibraryRule javaLibraryRuleToDex = javaLibraryWithClassesList.getJavaLibraryRule();
+    DxStep dx = new DxStep(getPathToDex().toString(),
+        Collections.singleton(Paths.get(javaLibraryRuleToDex.getPathToOutputFile())),
+        EnumSet.of(DxStep.Option.NO_OPTIMIZE, DxStep.Option.FORCE_JUMBO));
+    AbstractExecutionStep recordArtifactStep = new AbstractExecutionStep("record dx success") {
+      @Override
+      public int execute(ExecutionContext context) {
+        buildableContext.recordArtifact(getPathToDex().getFileName());
+        buildableContext.addMetadata(HAS_DEX_OUTPUT_METADATA, "true");
+        return 0;
+      }
+    };
+    CompositeStep dxAndStore = new CompositeStep(ImmutableList.of(dx, recordArtifactStep));
+
+    // Make sure that there are .class files to dex before running dx.
+    ConditionalStep runDxIfThereAreClassFiles = new ConditionalStep(fileExistsStep, dxAndStore);
+    steps.add(runDxIfThereAreClassFiles);
+
+    return steps.build();
+  }
+
+  @Override
+  @Nullable
+  public String getPathToOutputFile() {
+    // A .dex file is not guaranteed to be generated, so we return null to be conservative.
+    return null;
+  }
+
+  public Path getPathToDex() {
+    return Paths.get(
+        BuckConstant.GEN_DIR,
+        buildTarget.getBasePath(),
+        buildTarget.getShortName() + ".dex.jar");
+  }
+
+  public boolean hasOutput() {
+    // TODO(mbolin): Assert that this Buildable has been built. Currently, there is no way to do
+    // that from a Buildable (but there is from an AbstractCachingBuildRule).
+    Preconditions.checkNotNull(hasOutputFile);
+    return hasOutputFile.get();
+  }
+
+  @Override
+  protected void initializeFromDisk(OnDiskBuildInfo onDiskBuildInfo) {
+    boolean hasOutput = "true".equals(onDiskBuildInfo.getValue(HAS_DEX_OUTPUT_METADATA).orNull());
+    this.hasOutputFile = Suppliers.ofInstance(hasOutput);
+  }
+
+  public static Builder newPreDexBuilder(AbstractBuildRuleBuilderParams params) {
+    return new Builder(params);
+  }
+
+  public static class Builder extends AbstractBuildable.Builder {
+
+    private AccumulateClassNames javaLibraryWithClassesList;
+
+    private Builder(AbstractBuildRuleBuilderParams params) {
+      super(params);
+    }
+
+    @Override
+    protected BuildRuleType getType() {
+      return BuildRuleType._PRE_DEX;
+    }
+
+    @Override
+    protected DexProducedFromJavaLibraryThatContainsClassFiles newBuildable(
+        BuildRuleParams params, BuildRuleResolver resolver) {
+      return new DexProducedFromJavaLibraryThatContainsClassFiles(params.getBuildTarget(),
+          javaLibraryWithClassesList);
+    }
+
+    public Builder setPathToClassNamesList(AccumulateClassNames javaLibraryWithClassesList) {
+      this.javaLibraryWithClassesList = javaLibraryWithClassesList;
+      return this;
+    }
+  }
+}
diff --git a/src/com/facebook/buck/java/AccumulateClassNames.java b/src/com/facebook/buck/java/AccumulateClassNames.java
index 880012a..84bfced 100644
--- a/src/com/facebook/buck/java/AccumulateClassNames.java
+++ b/src/com/facebook/buck/java/AccumulateClassNames.java
@@ -67,6 +67,10 @@
     return pathToOutputFile.toString();
   }
 
+  public JavaLibraryRule getJavaLibraryRule() {
+    return javaLibraryRule;
+  }
+
   @Override
   public List<Step> getBuildSteps(BuildContext context, BuildableContext buildableContext)
       throws IOException {
diff --git a/src/com/facebook/buck/rules/AbstractBuildable.java b/src/com/facebook/buck/rules/AbstractBuildable.java
index 696662b..de9fc1b 100644
--- a/src/com/facebook/buck/rules/AbstractBuildable.java
+++ b/src/com/facebook/buck/rules/AbstractBuildable.java
@@ -39,6 +39,14 @@
     return builder;
   }
 
+  /**
+   * @param onDiskBuildInfo Contains metadata that was read from disk.
+   * @see AbstractCachingBuildRule#initializeFromDisk
+   */
+  protected void initializeFromDisk(OnDiskBuildInfo onDiskBuildInfo) {
+
+  }
+
   protected static abstract class Builder extends AbstractBuildRuleBuilder<AbstractCachingBuildRule> {
 
     protected Builder(AbstractBuildRuleBuilderParams params) {
@@ -65,6 +73,13 @@
         public BuildRuleType getType() {
           return type;
         }
+
+        @Override
+        protected void initializeFromDisk(OnDiskBuildInfo onDiskBuildInfo) {
+          if (buildable instanceof AbstractBuildable) {
+            ((AbstractBuildable) buildable).initializeFromDisk(onDiskBuildInfo);
+          }
+        }
       };
     }
   }
diff --git a/src/com/facebook/buck/rules/BuildRuleType.java b/src/com/facebook/buck/rules/BuildRuleType.java
index 385eba5..5995d23 100644
--- a/src/com/facebook/buck/rules/BuildRuleType.java
+++ b/src/com/facebook/buck/rules/BuildRuleType.java
@@ -46,6 +46,7 @@
 
   // Internal rule types. Denoted by leading trailing underscore.
   public static BuildRuleType _CLASS_NAMES = new BuildRuleType("_class_names");
+  public static BuildRuleType _PRE_DEX = new BuildRuleType("_pre_dex");
 
   private final String name;
   private final boolean isTestRule;
diff --git a/src/com/facebook/buck/step/fs/FileExistsAndIsNotEmptyStep.java b/src/com/facebook/buck/step/fs/FileExistsAndIsNotEmptyStep.java
new file mode 100644
index 0000000..9a72c01
--- /dev/null
+++ b/src/com/facebook/buck/step/fs/FileExistsAndIsNotEmptyStep.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2013-present Facebook, Inc.
+ *
+ * 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.facebook.buck.step.fs;
+
+import com.facebook.buck.step.AbstractExecutionStep;
+import com.facebook.buck.step.ConditionalStep;
+import com.facebook.buck.step.ExecutionContext;
+import com.facebook.buck.util.ProjectFilesystem;
+import com.facebook.buck.util.TriState;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Supplier;
+
+import java.io.IOException;
+import java.nio.file.Path;
+
+/**
+ * Step that verifies that a file of non-zero length exists at the specified path. The side effect
+ * of this step is that its {@link #get()} method will return a boolean indicating whether the
+ * file exists. This is designed to be used with a {@link ConditionalStep}.
+ */
+public class FileExistsAndIsNotEmptyStep extends AbstractExecutionStep
+    implements Supplier<Boolean> {
+
+  private final Path pathToFile;
+  private TriState fileExistsAndIsNotEmpty = TriState.UNSPECIFIED;
+
+  public FileExistsAndIsNotEmptyStep(Path pathToFile) {
+    super("test -s " + pathToFile);
+    this.pathToFile = Preconditions.checkNotNull(pathToFile);
+  }
+
+  @Override
+  public Boolean get() {
+    Preconditions.checkState(fileExistsAndIsNotEmpty.isSet());
+    return fileExistsAndIsNotEmpty.asBoolean();
+  }
+
+  @Override
+  public int execute(ExecutionContext context) {
+    ProjectFilesystem filesystem = context.getProjectFilesystem();
+    boolean exists = filesystem.exists(pathToFile.toString());
+
+    try {
+      fileExistsAndIsNotEmpty = TriState.forBooleanValue(exists
+          && filesystem.getFileSize(pathToFile) > 0);
+    } catch (IOException e) {
+      context.logError(e, "Failed to get size for file: %s.", pathToFile);
+      return 1;
+    }
+
+    return 0;
+  }
+
+}