diff --git a/src/main/java/com/google/devtools/build/lib/BUILD b/src/main/java/com/google/devtools/build/lib/BUILD
index 2ffe989..d76c556 100644
--- a/src/main/java/com/google/devtools/build/lib/BUILD
+++ b/src/main/java/com/google/devtools/build/lib/BUILD
@@ -29,6 +29,7 @@
         "//src/main/java/com/google/devtools/build/lib/rules/apple:srcs",
         "//src/main/java/com/google/devtools/build/lib/rules/apple/cpp:srcs",
         "//src/main/java/com/google/devtools/build/lib/rules/apple/swift:srcs",
+        "//src/main/java/com/google/devtools/build/lib/rules/config:srcs",
         "//src/main/java/com/google/devtools/build/lib/rules/cpp:srcs",
         "//src/main/java/com/google/devtools/build/lib/rules/cpp/proto:srcs",
         "//src/main/java/com/google/devtools/build/lib/rules/genquery:srcs",
diff --git a/src/main/java/com/google/devtools/build/lib/rules/config/BUILD b/src/main/java/com/google/devtools/build/lib/rules/config/BUILD
new file mode 100644
index 0000000..6e480d9
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/rules/config/BUILD
@@ -0,0 +1,27 @@
+# Description:
+#   Support for rules which enable users to define configuration
+
+package(
+    default_visibility = ["//src:__subpackages__"],
+)
+
+java_library(
+    name = "config",
+    srcs = glob([
+        "*.java",
+    ]),
+    deps = [
+        "//src/main/java/com/google/devtools/build/lib:build-base",
+        "//src/main/java/com/google/devtools/build/lib/actions",
+        "//src/main/java/com/google/devtools/build/lib/cmdline",
+        "//src/main/java/com/google/devtools/common/options",
+        "//third_party:guava",
+        "//third_party:jsr305",
+    ],
+)
+
+filegroup(
+    name = "srcs",
+    testonly = 0,  # All srcs should be not test only, overwrite package default.
+    srcs = glob(["**"]),
+)
diff --git a/src/main/java/com/google/devtools/build/lib/rules/config/ConfigFeatureFlagConfiguration.java b/src/main/java/com/google/devtools/build/lib/rules/config/ConfigFeatureFlagConfiguration.java
new file mode 100644
index 0000000..3d751c1
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/rules/config/ConfigFeatureFlagConfiguration.java
@@ -0,0 +1,148 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// 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.google.devtools.build.lib.rules.config;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedMap;
+import com.google.common.hash.Hasher;
+import com.google.common.hash.Hashing;
+import com.google.devtools.build.lib.actions.ArtifactOwner;
+import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
+import com.google.devtools.build.lib.analysis.config.BuildOptions;
+import com.google.devtools.build.lib.analysis.config.ConfigurationEnvironment;
+import com.google.devtools.build.lib.analysis.config.ConfigurationFragmentFactory;
+import com.google.devtools.build.lib.analysis.config.FragmentOptions;
+import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.common.options.Converter;
+import com.google.devtools.common.options.Option;
+import java.util.Map;
+import java.util.SortedMap;
+import javax.annotation.Nullable;
+
+/**
+ * Configuration fragment for Android's config_feature_flag, flags which can be defined in BUILD
+ * files.
+ */
+public final class ConfigFeatureFlagConfiguration extends BuildConfiguration.Fragment {
+
+  /** A converter used by the flag options which always returns an empty map, ignoring input. */
+  public static final class EmptyImmutableSortedMapConverter
+      implements Converter<ImmutableSortedMap<Label, String>> {
+    @Override
+    public ImmutableSortedMap<Label, String> convert(String input) {
+      return ImmutableSortedMap.<Label, String>of();
+    }
+
+    @Override
+    public String getTypeDescription() {
+      return "n/a (do not set this on the command line)";
+    }
+  }
+
+  /** The options fragment which defines {@link ConfigFeatureFlagConfiguration}. */
+  public static final class Options extends FragmentOptions {
+    /** The mapping from config_feature_flag rules to their values. */
+    @Option(
+        name = "config_feature_flag values (private)",
+        category = "internal",
+        converter = EmptyImmutableSortedMapConverter.class,
+        defaultValue = "{}")
+    public ImmutableSortedMap<Label, String> flagValues = ImmutableSortedMap.of();
+
+    /** Retrieves the set of flag-value pairs. */
+    public ImmutableSortedMap<Label, String> getFlagValues() {
+      return this.flagValues;
+    }
+
+    /**
+     * Replaces the set of flag-value pairs with the given mapping of flag-value pairs.
+     *
+     * <p>Flags not present in the new {@code flagValues} will return to being unset! To set flags
+     * while still retaining the values already set, call {@link #getFlagValues()} and build a map
+     * containing both the old values and the new ones.
+     */
+    public void replaceFlagValues(Map<Label, String> flagValues) {
+      this.flagValues = ImmutableSortedMap.copyOf(flagValues);
+    }
+  }
+
+  /**
+   * A configuration fragment loader able to create instances of {@link
+   * ConfigFeatureFlagConfiguration} from {@link ConfigFeatureFlagConfiguration.Options}.
+   */
+  public static final class Loader implements ConfigurationFragmentFactory {
+    @Override
+    public BuildConfiguration.Fragment create(
+        ConfigurationEnvironment env, BuildOptions buildOptions) {
+      return new ConfigFeatureFlagConfiguration(buildOptions.get(Options.class));
+    }
+
+    @Override
+    public Class<? extends BuildConfiguration.Fragment> creates() {
+      return ConfigFeatureFlagConfiguration.class;
+    }
+
+    @Override
+    public ImmutableSet<Class<? extends FragmentOptions>> requiredOptions() {
+      return ImmutableSet.<Class<? extends FragmentOptions>>of(Options.class);
+    }
+  }
+
+  private final ImmutableSortedMap<Label, String> flagValues;
+  @Nullable private final String flagHash;
+
+  /** Creates a new configuration fragment from the given {@link Options} fragment. */
+  public ConfigFeatureFlagConfiguration(Options options) {
+    this.flagValues = options.getFlagValues();
+    this.flagHash = this.flagValues.isEmpty() ? null : hashFlags(this.flagValues);
+  }
+
+  /** Converts the given flag values into a string hash for use as an output directory fragment. */
+  private static String hashFlags(SortedMap<Label, String> flagValues) {
+    // This hash function is relatively fast and stable between JVM invocations.
+    Hasher hasher = Hashing.murmur3_128().newHasher();
+
+    for (Map.Entry<Label, String> flag : flagValues.entrySet()) {
+      hasher.putUnencodedChars(flag.getKey().toString());
+      hasher.putUnencodedChars(flag.getValue());
+    }
+    return hasher.hash().toString();
+  }
+
+  /**
+   * Retrieves the value of a configuration flag.
+   *
+   * <p>If the flag is not set in the current configuration, then the returned value will be absent.
+   *
+   * <p>This method should only be used by the rule whose label is passed here. Other rules should
+   * depend on that rule and read a provider exported by it. To encourage callers of this method to
+   * do the right thing, this class takes {@link ArtifactOwner} instead of {@link Label}; to get the
+   * ArtifactOwner for a rule, call {@code ruleContext.getOwner()}.
+   */
+  public Optional<String> getFeatureFlagValue(ArtifactOwner owner) {
+    return Optional.fromNullable(flagValues.get(owner.getLabel()));
+  }
+
+  /**
+   * Returns a fragment of the output directory name for this configuration, based on the set of
+   * flags and their values. It will be {@code null} if no flags are set.
+   */
+  @Nullable
+  @Override
+  public String getOutputDirectoryName() {
+    return flagHash;
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/BUILD b/src/test/java/com/google/devtools/build/lib/BUILD
index f3c03d1..0223f7e 100644
--- a/src/test/java/com/google/devtools/build/lib/BUILD
+++ b/src/test/java/com/google/devtools/build/lib/BUILD
@@ -37,6 +37,7 @@
         "//src/test/java/com/google/devtools/build/lib/skylark:srcs",
         "//src/test/java/com/google/devtools/build/lib/skyframe:srcs",
         "//src/test/java/com/google/devtools/build/lib/rules/android:srcs",
+        "//src/test/java/com/google/devtools/build/lib/rules/config:srcs",
         "//src/test/java/com/google/devtools/build/lib/rules/platform:srcs",
         "//src/test/java/com/google/devtools/build/lib/rules/repository:srcs",
         "//src/test/java/com/google/devtools/build/lib/bazel/repository:srcs",
diff --git a/src/test/java/com/google/devtools/build/lib/rules/config/BUILD b/src/test/java/com/google/devtools/build/lib/rules/config/BUILD
new file mode 100644
index 0000000..0083a4d
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/rules/config/BUILD
@@ -0,0 +1,13 @@
+# Description:
+#   Tests for rules which enable users to define configuration
+
+package(
+    default_testonly = 1,
+    default_visibility = ["//src:__subpackages__"],
+)
+
+filegroup(
+    name = "srcs",
+    testonly = 0,  # All srcs should be not test only, overwrite package default.
+    srcs = glob(["**"]),
+)
diff --git a/src/test/java/com/google/devtools/build/lib/rules/config/ConfigFeatureFlagConfigurationTest.java b/src/test/java/com/google/devtools/build/lib/rules/config/ConfigFeatureFlagConfigurationTest.java
new file mode 100644
index 0000000..610ce2d
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/rules/config/ConfigFeatureFlagConfigurationTest.java
@@ -0,0 +1,237 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// 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.google.devtools.build.lib.rules.config;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.common.testing.EqualsTester;
+import com.google.devtools.build.lib.actions.util.LabelArtifactOwner;
+import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.common.options.OptionsParser;
+import com.google.devtools.common.options.OptionsParsingException;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for feature flag configuration fragments. */
+@RunWith(JUnit4.class)
+public final class ConfigFeatureFlagConfigurationTest {
+
+  @Test
+  public void options_getFlagValues_startsEmpty() throws Exception {
+    assertThat(new ConfigFeatureFlagConfiguration.Options().getFlagValues()).isEmpty();
+  }
+
+  @Test
+  public void options_replaceFlagValues_reflectedInGetFlagValues() throws Exception {
+    Map<Label, String> originalMap =
+        ImmutableMap.of(
+            Label.parseAbsoluteUnchecked("//label:a"), "value",
+            Label.parseAbsoluteUnchecked("//label:b"), "otherValue");
+    ConfigFeatureFlagConfiguration.Options options = new ConfigFeatureFlagConfiguration.Options();
+    options.replaceFlagValues(originalMap);
+    assertThat(options.getFlagValues()).containsExactlyEntriesIn(originalMap);
+  }
+
+  @Test
+  public void options_replaceFlagValues_totallyReplacesFlagValuesMap() throws Exception {
+    Map<Label, String> originalMap =
+        ImmutableMap.of(
+            Label.parseAbsoluteUnchecked("//label:a"), "value",
+            Label.parseAbsoluteUnchecked("//label:b"), "otherValue");
+    Map<Label, String> newMap =
+        ImmutableMap.of(
+            Label.parseAbsoluteUnchecked("//label:a"), "differentValue",
+            Label.parseAbsoluteUnchecked("//label:c"), "differentFlag");
+    ConfigFeatureFlagConfiguration.Options options = new ConfigFeatureFlagConfiguration.Options();
+    options.replaceFlagValues(originalMap);
+    options.replaceFlagValues(newMap);
+    assertThat(options.getFlagValues()).containsExactlyEntriesIn(newMap);
+  }
+
+  @Test
+  public void options_getDefault_isEmpty() throws Exception {
+    assertThat(
+            ((ConfigFeatureFlagConfiguration.Options)
+                    new ConfigFeatureFlagConfiguration.Options().getDefault())
+                .getFlagValues())
+        .isEmpty();
+  }
+
+  @Test
+  public void options_getHost_isEmpty() throws Exception {
+    assertThat(
+            ((ConfigFeatureFlagConfiguration.Options)
+                    new ConfigFeatureFlagConfiguration.Options().getHost(false))
+                .getFlagValues())
+        .isEmpty();
+    assertThat(
+            ((ConfigFeatureFlagConfiguration.Options)
+                    new ConfigFeatureFlagConfiguration.Options().getHost(true))
+                .getFlagValues())
+        .isEmpty();
+  }
+
+  @Test
+  public void options_equals_forEquivalentMaps() throws Exception {
+    new EqualsTester()
+        .addEqualityGroup(
+            getOptionsWith(ImmutableMap.of()),
+            new ConfigFeatureFlagConfiguration.Options(),
+            new ConfigFeatureFlagConfiguration.Options().getDefault(),
+            new ConfigFeatureFlagConfiguration.Options().getHost(false),
+            new ConfigFeatureFlagConfiguration.Options().getHost(true))
+        .addEqualityGroup(
+            getOptionsWith(ImmutableMap.of(Label.parseAbsoluteUnchecked("//a:a"), "a")),
+            getOptionsWith(ImmutableMap.of(Label.parseAbsoluteUnchecked("//a:a"), "a")))
+        .addEqualityGroup(
+            getOptionsWith(ImmutableMap.of(Label.parseAbsoluteUnchecked("//b:b"), "a")))
+        .addEqualityGroup(
+            getOptionsWith(ImmutableMap.of(Label.parseAbsoluteUnchecked("//a:a"), "b")))
+        .addEqualityGroup(
+            getOptionsWith(ImmutableMap.of(Label.parseAbsoluteUnchecked("//b:b"), "b")))
+        .addEqualityGroup(
+            getOptionsWith(
+                ImmutableMap.of(
+                    Label.parseAbsoluteUnchecked("//a:a"), "b",
+                    Label.parseAbsoluteUnchecked("//b:b"), "a")),
+            getOptionsWith(
+                ImmutableMap.of(
+                    Label.parseAbsoluteUnchecked("//b:b"), "a",
+                    Label.parseAbsoluteUnchecked("//a:a"), "b")))
+        .testEquals();
+  }
+
+  @Test
+  public void options_doesNotAllowFlagValuesToBeParsed() throws Exception {
+    OptionsParser parser =
+        OptionsParser.newOptionsParser(ConfigFeatureFlagConfiguration.Options.class);
+    try {
+      parser.parse(
+          "--"
+              + Iterables.getOnlyElement(
+                  new ConfigFeatureFlagConfiguration.Options().asMap().keySet())
+              + "={}");
+      fail("Flags successfully parsed despite passing a private flag.");
+    } catch (OptionsParsingException expected) {
+      assertThat(expected).hasMessageThat().contains("Unrecognized option:");
+    }
+  }
+
+  private ConfigFeatureFlagConfiguration.Options getOptionsWith(Map<Label, String> values) {
+    ConfigFeatureFlagConfiguration.Options result = new ConfigFeatureFlagConfiguration.Options();
+    result.replaceFlagValues(values);
+    return result;
+  }
+
+  @Test
+  public void getFeatureFlagValue_returnsValueOfFlagWhenRequestingSetFlag() throws Exception {
+    Label ruleLabel = Label.parseAbsoluteUnchecked("//a:a");
+    Optional<String> flagValue =
+        getConfigurationWithFlags(ImmutableMap.of(ruleLabel, "valued"))
+            .getFeatureFlagValue(new LabelArtifactOwner(ruleLabel));
+    assertThat(flagValue).isPresent();
+    assertThat(flagValue).hasValue("valued");
+  }
+
+  @Test
+  public void getFeatureFlagValue_returnsAbsentOptionalWhenRequestingUnsetFlag() throws Exception {
+    Optional<String> flagValue =
+        getConfigurationWithFlags(ImmutableMap.of(Label.parseAbsoluteUnchecked("//a:a"), "valued"))
+            .getFeatureFlagValue(new LabelArtifactOwner(Label.parseAbsoluteUnchecked("//b:b")));
+    assertThat(flagValue).isAbsent();
+  }
+
+  @Test
+  public void getOutputDirectoryName_returnsNullWhenFlagMapIsEmpty() throws Exception {
+    assertThat(getConfigurationWithFlags(ImmutableMap.of()).getOutputDirectoryName()).isNull();
+  }
+
+  @Test
+  public void getOutputDirectoryName_returnsNonNullWhenFlagMapIsNonEmpty() throws Exception {
+    assertThat(
+            getConfigurationWithFlags(ImmutableMap.of(Label.parseAbsoluteUnchecked("//a:a"), "ok"))
+                .getOutputDirectoryName())
+        .isNotNull();
+  }
+
+  @Test
+  public void getOutputDirectoryName_returnsSameValueForTwoMapsWithSamePairsRegardlessOfOrder()
+      throws Exception {
+    Map<Label, String> firstOrder =
+        ImmutableMap.of(
+            Label.parseAbsoluteUnchecked("//b:b"), "first",
+            Label.parseAbsoluteUnchecked("//a:a"), "second");
+    Map<Label, String> reverseOrder =
+        ImmutableMap.of(
+            Label.parseAbsoluteUnchecked("//a:a"), "second",
+            Label.parseAbsoluteUnchecked("//b:b"), "first");
+    assertThat(getConfigurationWithFlags(reverseOrder).getOutputDirectoryName())
+        .isEqualTo(getConfigurationWithFlags(firstOrder).getOutputDirectoryName());
+  }
+
+  @Test
+  public void getOutputDirectoryName_returnsDifferentValueForDifferentFlags() throws Exception {
+    Map<Label, String> someFlags =
+        ImmutableMap.of(
+            Label.parseAbsoluteUnchecked("//a:a"), "first",
+            Label.parseAbsoluteUnchecked("//b:b"), "second");
+    Map<Label, String> otherFlags =
+        ImmutableMap.of(
+            Label.parseAbsoluteUnchecked("//c:c"), "first",
+            Label.parseAbsoluteUnchecked("//d:d"), "second");
+    assertThat(getConfigurationWithFlags(otherFlags).getOutputDirectoryName())
+        .isNotEqualTo(getConfigurationWithFlags(someFlags).getOutputDirectoryName());
+  }
+
+  @Test
+  public void getOutputDirectoryName_returnsDifferentValueForDifferentValues() throws Exception {
+    Map<Label, String> someFlags =
+        ImmutableMap.of(
+            Label.parseAbsoluteUnchecked("//a:a"), "first",
+            Label.parseAbsoluteUnchecked("//b:b"), "second");
+    Map<Label, String> otherFlags =
+        ImmutableMap.of(
+            Label.parseAbsoluteUnchecked("//a:a"), "worst",
+            Label.parseAbsoluteUnchecked("//b:b"), "heckin");
+    assertThat(getConfigurationWithFlags(otherFlags).getOutputDirectoryName())
+        .isNotEqualTo(getConfigurationWithFlags(someFlags).getOutputDirectoryName());
+  }
+
+  @Test
+  public void getOutputDirectoryName_returnsDifferentValueForSubsetOfFlagValuePairs()
+      throws Exception {
+    Map<Label, String> someFlags = ImmutableMap.of(Label.parseAbsoluteUnchecked("//a:a"), "first");
+    Map<Label, String> moreFlags =
+        ImmutableMap.of(
+            Label.parseAbsoluteUnchecked("//a:a"), "first",
+            Label.parseAbsoluteUnchecked("//b:b"), "second");
+    assertThat(getConfigurationWithFlags(moreFlags).getOutputDirectoryName())
+        .isNotEqualTo(getConfigurationWithFlags(someFlags).getOutputDirectoryName());
+  }
+
+  /** Generates a configuration fragment with the given set of flag-value pairs. */
+  private static ConfigFeatureFlagConfiguration getConfigurationWithFlags(
+      Map<Label, String> flags) {
+    ConfigFeatureFlagConfiguration.Options options = new ConfigFeatureFlagConfiguration.Options();
+    options.replaceFlagValues(flags);
+    return new ConfigFeatureFlagConfiguration(options);
+  }
+}