diff --git a/res/values/custom_arrays.xml b/res/values/custom_arrays.xml
index 3601e49..ad4d58a 100644
--- a/res/values/custom_arrays.xml
+++ b/res/values/custom_arrays.xml
@@ -490,4 +490,16 @@
         <item>7</item>
         <item>5</item>
     </string-array>
+
+    <string-array name="screen_off_animation_entries">
+        <item>@string/screen_off_animation_default</item>
+        <item>@string/screen_off_animation_crt</item>
+        <item>@string/screen_off_animation_scale</item>
+    </string-array>
+
+    <string-array name="screen_off_animation_values" translatable="false">
+        <item>0</item>
+        <item>2</item>
+        <item>3</item>
+    </string-array>
 </resources>
diff --git a/res/values/custom_strings.xml b/res/values/custom_strings.xml
index 133f03d..f981518 100644
--- a/res/values/custom_strings.xml
+++ b/res/values/custom_strings.xml
@@ -632,4 +632,9 @@
 
     <string name="double_tap_sleep_lockscreen_title">Double tap to sleep on lockscreen</string>
     <string name="double_tap_sleep_lockscreen_summary"></string>
+
+    <string name="screen_off_animation_default">Default</string>
+    <string name="screen_off_animation_crt">CRT</string>
+    <string name="screen_off_animation_scale">Scale</string>
+    <string name="screen_off_animation_title">Screen off animation</string>
 </resources>
diff --git a/res/xml/more_settings.xml b/res/xml/more_settings.xml
index 7ba454d..88aaf71 100644
--- a/res/xml/more_settings.xml
+++ b/res/xml/more_settings.xml
@@ -79,5 +79,11 @@
                 android:summary="@string/volume_steps_summary"
                 android:fragment="org.omnirom.omnigears.system.VolumeSteps" />
 
+            <ListPreference
+                android:key="screen_off_animation"
+                android:title="@string/screen_off_animation_title"
+                android:entries="@array/screen_off_animation_entries"
+                android:entryValues="@array/screen_off_animation_values"
+                android:persistent="false"/>
         </PreferenceCategory>
 </PreferenceScreen>
diff --git a/src/org/omnirom/omnigears/moresettings/MoreSettings.java b/src/org/omnirom/omnigears/moresettings/MoreSettings.java
index ea8dd00..ca110da 100644
--- a/src/org/omnirom/omnigears/moresettings/MoreSettings.java
+++ b/src/org/omnirom/omnigears/moresettings/MoreSettings.java
@@ -27,6 +27,7 @@
 import android.support.v7.preference.PreferenceScreen;
 import android.support.v7.preference.Preference.OnPreferenceChangeListener;
 import android.support.v14.preference.SwitchPreference;
+import android.provider.Settings;
 import android.provider.SearchIndexableResource;
 import android.util.Log;
 
@@ -44,12 +45,14 @@
 import java.util.List;
 import java.util.ArrayList;
 
-public class MoreSettings extends SettingsPreferenceFragment implements Indexable {
+public class MoreSettings extends SettingsPreferenceFragment implements OnPreferenceChangeListener, Indexable {
     private static final String TAG = "MoreSettings";
     private static final String KEY_SHOW_DASHBOARD_COLUMNS = "show_dashboard_columns";
     private static final String KEY_HIDE_DASHBOARD_SUMMARY = "hide_dashboard_summary";
+    private static final String KEY_SCREEN_OFF_ANIMATION = "screen_off_animation";
 
     private SharedPreferences mAppPreferences;
+    private ListPreference mScreenOffAnimation;
 
     @Override
     public int getMetricsCategory() {
@@ -92,6 +95,26 @@
                 return true;
             }
         });
+
+        mScreenOffAnimation = (ListPreference) findPreference(KEY_SCREEN_OFF_ANIMATION);
+        int screenOffAnimation = Settings.Global.getInt(getContentResolver(),
+                Settings.Global.SCREEN_OFF_ANIMATION, 0);
+
+        mScreenOffAnimation.setValue(Integer.toString(screenOffAnimation));
+        mScreenOffAnimation.setSummary(mScreenOffAnimation.getEntry());
+        mScreenOffAnimation.setOnPreferenceChangeListener(this);
+    }
+
+    @Override
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        if (preference == mScreenOffAnimation) {
+            int value = Integer.valueOf((String) newValue);
+            int index = mScreenOffAnimation.findIndexOfValue((String) newValue);
+            mScreenOffAnimation.setSummary(mScreenOffAnimation.getEntries()[index]);
+            Settings.Global.putInt(getContentResolver(), Settings.Global.SCREEN_OFF_ANIMATION, value);
+            return true;
+        }
+        return false;
     }
 
     public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
