diff --git a/java/src/com/android/inputmethod/latin/settings/DebugSettings.java b/java/src/com/android/inputmethod/latin/settings/DebugSettings.java
index c17e868..c6a7024 100644
--- a/java/src/com/android/inputmethod/latin/settings/DebugSettings.java
+++ b/java/src/com/android/inputmethod/latin/settings/DebugSettings.java
@@ -62,6 +62,8 @@
     public void onCreate(Bundle icicle) {
         super.onCreate(icicle);
         addPreferencesFromResource(R.xml.prefs_for_debug);
+        TwoStatePreferenceHelper.replaceCheckBoxPreferencesBySwitchPreferences(
+                getPreferenceScreen());
         SharedPreferences prefs = getPreferenceManager().getSharedPreferences();
         prefs.registerOnSharedPreferenceChangeListener(this);
 
diff --git a/java/src/com/android/inputmethod/latin/settings/SettingsFragment.java b/java/src/com/android/inputmethod/latin/settings/SettingsFragment.java
index 689f878..5a26a77 100644
--- a/java/src/com/android/inputmethod/latin/settings/SettingsFragment.java
+++ b/java/src/com/android/inputmethod/latin/settings/SettingsFragment.java
@@ -104,10 +104,9 @@
         setSubtypeEnablerTitle(R.string.select_language);
         addPreferencesFromResource(R.xml.prefs);
         final PreferenceScreen preferenceScreen = getPreferenceScreen();
-        if (preferenceScreen != null) {
-            preferenceScreen.setTitle(
-                    ApplicationUtils.getActivityTitleResId(getActivity(), SettingsActivity.class));
-        }
+        TwoStatePreferenceHelper.replaceCheckBoxPreferencesBySwitchPreferences(preferenceScreen);
+        preferenceScreen.setTitle(
+                ApplicationUtils.getActivityTitleResId(getActivity(), SettingsActivity.class));
 
         final Resources res = getResources();
         final Context context = getActivity();
diff --git a/java/src/com/android/inputmethod/latin/settings/TwoStatePreferenceHelper.java b/java/src/com/android/inputmethod/latin/settings/TwoStatePreferenceHelper.java
new file mode 100644
index 0000000..edfcc99
--- /dev/null
+++ b/java/src/com/android/inputmethod/latin/settings/TwoStatePreferenceHelper.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2014 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.inputmethod.latin.settings;
+
+import android.os.Build;
+import android.preference.CheckBoxPreference;
+import android.preference.Preference;
+import android.preference.PreferenceGroup;
+import android.preference.SwitchPreference;
+
+import java.util.ArrayList;
+
+class TwoStatePreferenceHelper {
+    private static final String EMPTY_TEXT = "";
+
+    private TwoStatePreferenceHelper() {
+        // This utility class is not publicly instantiable.
+    }
+
+    static void replaceCheckBoxPreferencesBySwitchPreferences(final PreferenceGroup group) {
+        // The keyboard settings keeps using a CheckBoxPreference on KitKat or previous.
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) {
+            return;
+        }
+        // The keyboard settings starts using a SwitchPreference without switch on/off text on
+        // API versions newer than KitKat.
+        replaceAllCheckBoxPreferencesBySwitchPreferences(group);
+    }
+
+    private static void replaceAllCheckBoxPreferencesBySwitchPreferences(
+            final PreferenceGroup group) {
+        final ArrayList<Preference> preferences = new ArrayList<>();
+        final int count = group.getPreferenceCount();
+        for (int index = 0; index < count; index++) {
+            preferences.add(group.getPreference(index));
+        }
+        group.removeAll();
+        for (int index = 0; index < count; index++) {
+            final Preference preference = preferences.get(index);
+            if (preference instanceof CheckBoxPreference) {
+                addSwitchPreferenceBasedOnCheckBoxPreference((CheckBoxPreference)preference, group);
+            } else {
+                group.addPreference(preference);
+                if (preference instanceof PreferenceGroup) {
+                    replaceAllCheckBoxPreferencesBySwitchPreferences((PreferenceGroup)preference);
+                }
+            }
+        }
+    }
+
+    static void addSwitchPreferenceBasedOnCheckBoxPreference(final CheckBoxPreference checkBox,
+            final PreferenceGroup group) {
+        final SwitchPreference switchPref = new SwitchPreference(checkBox.getContext());
+        switchPref.setTitle(checkBox.getTitle());
+        switchPref.setKey(checkBox.getKey());
+        switchPref.setOrder(checkBox.getOrder());
+        switchPref.setPersistent(checkBox.isPersistent());
+        switchPref.setEnabled(checkBox.isEnabled());
+        switchPref.setChecked(checkBox.isChecked());
+        switchPref.setSummary(checkBox.getSummary());
+        switchPref.setSummaryOn(checkBox.getSummaryOn());
+        switchPref.setSummaryOff(checkBox.getSummaryOff());
+        switchPref.setSwitchTextOn(EMPTY_TEXT);
+        switchPref.setSwitchTextOff(EMPTY_TEXT);
+        group.addPreference(switchPref);
+        switchPref.setDependency(checkBox.getDependency());
+    }
+}
