diff --git a/src/backends/default/open.c b/src/backends/default/open.c
index 09eba60..a5faa37 100644
--- a/src/backends/default/open.c
+++ b/src/backends/default/open.c
@@ -13,9 +13,12 @@
 #include <Efreet_Mime.h>
 #include <Eet.h>
 
+#include <stdlib.h>
+#include <string.h>
 #include <sys/types.h>
 #include <pwd.h>
 #include <grp.h>
+#include <limits.h>
 
 #include "cmd.h"
 #include "eina_strbuf.h"
@@ -31,6 +34,7 @@ static const char *home_dir   = NULL;
 static Eina_Bool   auto_exit  = EINA_FALSE;
 static int         child_exes = 0;
 
+
 static Ecore_File_Monitor *mon       = NULL;
 static Eina_Bool           can_write = EINA_FALSE;
 
@@ -119,6 +123,26 @@ static Eina_List *sub_queue = NULL;
 
 static Sub *_sub_open(const char *path, const char *backend);
 
+typedef struct
+{
+  Eina_Stringshare *name;
+  int               index;
+} Order_Item;
+
+static struct
+{
+  Eina_Stringshare *dir;
+  Eina_Hash        *map;
+  Eina_List        *items;
+  int               count;
+} order_state = { 0 };
+
+static void _order_state_clear(void);
+static void _order_state_set_dir(const char *dir);
+static int  _order_state_index_get(const char *name);
+static void _order_state_items_reset(void);
+static void _order_state_write(void);
+
 static Sub *
 _sub_find(const char *path)
 {
@@ -341,6 +365,153 @@ _sub_open(const char *path, const char *backend)
   return sub;
 }
 
+static void
+_order_state_items_reset(void)
+{
+  Order_Item *item;
+
+  EINA_LIST_FREE(order_state.items, item)
+  {
+    eina_stringshare_del(item->name);
+    free(item);
+  }
+  order_state.items = NULL;
+  order_state.count = 0;
+  if (order_state.map)
+    {
+      eina_hash_free(order_state.map);
+      order_state.map = NULL;
+    }
+  order_state.map = eina_hash_stringshared_new(NULL);
+}
+
+static void
+_order_state_clear(void)
+{
+  Order_Item *item;
+
+  EINA_LIST_FREE(order_state.items, item)
+  {
+    eina_stringshare_del(item->name);
+    free(item);
+  }
+  order_state.items = NULL;
+  order_state.count = 0;
+  if (order_state.map)
+    {
+      eina_hash_free(order_state.map);
+      order_state.map = NULL;
+    }
+  if (order_state.dir)
+    {
+      eina_stringshare_del(order_state.dir);
+      order_state.dir = NULL;
+    }
+}
+
+static void
+_order_state_item_add(const char *name, int index)
+{
+  Order_Item *item;
+
+  if ((!name) || (!name[0])) return;
+  if (!order_state.map)
+    {
+      order_state.map = eina_hash_stringshared_new(NULL);
+      if (!order_state.map) return;
+    }
+  if (eina_hash_find(order_state.map, name)) return;
+
+  item = calloc(1, sizeof(Order_Item));
+  if (!item) return;
+  item->name = eina_stringshare_add(name);
+  if (!item->name)
+    {
+      free(item);
+      return;
+    }
+  item->index = index;
+  order_state.items = eina_list_append(order_state.items, item);
+  eina_hash_direct_add(order_state.map, item->name, item);
+  if ((index + 1) > order_state.count) order_state.count = index + 1;
+}
+
+static void
+_order_state_set_dir(const char *dir)
+{
+  FILE *f;
+  char  path[PATH_MAX];
+  int   idx = 0;
+
+  if (!dir) return;
+  if ((order_state.dir) && (!strcmp(order_state.dir, dir))) return;
+
+  _order_state_clear();
+
+  order_state.dir = eina_stringshare_add(dir);
+  if (!order_state.dir) return;
+
+  order_state.map = eina_hash_stringshared_new(NULL);
+  if (!order_state.map) return;
+
+  snprintf(path, sizeof(path), "%s.efm/.efm.order", dir);
+  f = fopen(path, "r");
+  if (!f)
+    {
+      order_state.count = 0;
+      return;
+    }
+
+  while (fgets(path, sizeof(path), f))
+    {
+      char *start = path;
+      size_t len  = strlen(start);
+
+      if ((len > 0) && (start[len - 1] == '\n')) start[--len] = 0;
+      if (!start[0]) continue;
+      if (eina_hash_find(order_state.map, start)) continue;
+      _order_state_item_add(start, idx++);
+    }
+  fclose(f);
+  order_state.count = idx;
+}
+
+static int
+_order_state_index_get(const char *name)
+{
+  Order_Item *item;
+
+  if (!order_state.map) return -1;
+  item = eina_hash_find(order_state.map, name);
+  if (!item) return -1;
+  return item->index;
+}
+
+static void
+_order_state_write(void)
+{
+  Eina_List  *l;
+  Order_Item *item;
+  char        dirbuf[PATH_MAX];
+  char        path[PATH_MAX];
+  FILE       *f;
+
+  if (!order_state.dir) return;
+
+  snprintf(dirbuf, sizeof(dirbuf), "%s.efm", order_state.dir);
+  ecore_file_mkpath(dirbuf);
+  snprintf(path, sizeof(path), "%s/.efm.order", dirbuf);
+
+  f = fopen(path, "w");
+  if (!f) return;
+
+  EINA_LIST_FOREACH(order_state.items, l, item)
+  {
+    if (item->name) fprintf(f, "%s\n", item->name);
+  }
+  fclose(f);
+}
+
 static Eina_Bool _file_add_mod_info(Eina_Strbuf *strbuf, const char *path,
                                     Eina_Bool delay);
 
@@ -801,8 +972,15 @@ _file_add_mod_info(Eina_Strbuf *strbuf, const char *path, Eina_Bool delay)
   const char     *mime, *ext, *icon;
   Efreet_Desktop *desktop;
   Eina_Bool       have_label = EINA_FALSE;
+  const char     *file_name;
+  int             order_index;
 
   if (lstat(path, &st) != 0) return EINA_FALSE;
+  file_name = ecore_file_file_get(path);
+  order_index = -1;
+  if (file_name) order_index = _order_state_index_get(file_name);
+  snprintf(buf, sizeof(buf), "%d", order_index);
+  cmd_strbuf_append(strbuf, "order-index", buf);
   if ((st.st_mode & S_IFMT) == S_IFLNK)
     {
       struct stat stdst;
@@ -1140,6 +1318,8 @@ _monitor(const char *path)
 
   if (abort_list) return;
 
+  _order_state_set_dir(path);
+
   strbuf = eina_strbuf_new();
   eina_strbuf_append(strbuf, path);
   eina_strbuf_append(strbuf, ".efm");
@@ -1325,6 +1505,44 @@ do_handle_cmd(Cmd *c)
       }
       KEY_WALK_END
     }
+  else if (!strcmp(c->command, "order-set"))
+    {
+      Eina_List  *names    = NULL;
+      const char *dir_path = NULL;
+      char       *entry;
+      Eina_List  *ln;
+      int         idx = 0;
+
+      KEY_WALK_BEGIN
+      {
+        if (!strcmp(key, "path")) dir_path = data;
+        else if (!strcmp(key, "entry"))
+          {
+            entry = strdup(data);
+            if (entry) names = eina_list_append(names, entry);
+          }
+      }
+      KEY_WALK_END
+      if (dir_path)
+        {
+          if ((!order_state.dir) || (strcmp(order_state.dir, dir_path)))
+            _order_state_set_dir(dir_path);
+        }
+      if (!order_state.dir) goto order_set_done;
+      _order_state_items_reset();
+      if (!order_state.map) goto order_set_done;
+      idx = 0;
+      EINA_LIST_FOREACH(names, ln, entry)
+      {
+        if (!entry) continue;
+        if (!entry[0]) continue;
+        _order_state_item_add(entry, idx++);
+      }
+      order_state.count = idx;
+      _order_state_write();
+    order_set_done:
+      EINA_LIST_FREE(names, entry) free(entry);
+    }
   else if (!strcmp(c->command, "file-run"))
     {
       const char *open_with_desktop = cmd_key_find(c, "open-with");
@@ -1556,6 +1774,7 @@ do_shutdown(void)
 
   if (mon) ecore_file_monitor_del(mon);
   mon = NULL;
+  _order_state_clear();
 
   meta_shutdown();
 
diff --git a/src/efm/efm.c b/src/efm/efm.c
index 4a5c270..b352516 100644
--- a/src/efm/efm.c
+++ b/src/efm/efm.c
@@ -1408,6 +1408,7 @@ _reset(Smart_Data *sd)
 
       _icon_free(icon);
     }
+  _efm_order_icons_clear(sd);
   if (sd->reblock_job)
     {
       ecore_job_del(sd->reblock_job);
@@ -1916,6 +1917,7 @@ efm_path_sort_mode_set(Evas_Object *obj, Efm_Sort_Mode mode)
 
   if (sd->config.sort_mode == mode) return;
   sd->config.sort_mode = mode;
+  sd->config.explicit_order = !!(mode & EFM_SORT_MODE_EXPLICIT_ORDER);
   _reset(sd);
 }
 
diff --git a/src/efm/efm.h b/src/efm/efm.h
index 46ada84..ce03bc9 100644
--- a/src/efm/efm.h
+++ b/src/efm/efm.h
@@ -22,6 +22,7 @@ typedef enum
   EFM_SORT_MODE_DIRS_FIRST     = (1 << 16), // show dirs first then files
   EFM_SORT_MODE_NOCASE         = (1 << 17), // don't account for case in sort
   EFM_SORT_MODE_LABEL_NOT_PATH = (1 << 18), // use label not filename
+  EFM_SORT_MODE_EXPLICIT_ORDER = (1 << 19), // rely on explicit order index
   // mask for field
   EFM_SORT_MODE_MASK = 0xffff, // lower 16 bits is the sort field
   // fields
diff --git a/src/efm/efm_back_end.c b/src/efm/efm_back_end.c
index 165da13..a7a703a 100644
--- a/src/efm/efm_back_end.c
+++ b/src/efm/efm_back_end.c
@@ -398,6 +398,15 @@ _icon_add_mod_props_get(Icon *icon, Cmd *c, const char *label)
       if (recalc) _max_size_recalc(icon->sd);
       if (queue) _size_bars_update_queue(icon->sd);
     }
+  s = cmd_key_find(c, "order-index");
+  if (s)
+    {
+      int order = atoi(s);
+
+      if (order >= 0) _efm_order_icon_insert(icon->sd, icon, order);
+      else _efm_order_icon_remove(icon->sd, icon);
+    }
+  else _efm_order_icon_remove(icon->sd, icon);
 }
 
 static Eina_Bool
@@ -769,6 +778,7 @@ _cb_thread_notify(void *data, Ecore_Thread *th EINA_UNUSED, void *msg)
         icon->sd        = sd;
         icon->cmd       = c;
         icon->changed   = EINA_TRUE;
+        icon->info.order_index = -1;
         icon->info.file = eina_stringshare_add(file);
 
         _icon_add_mod_props_get(icon, c, label);
@@ -843,6 +853,8 @@ _cb_thread_notify(void *data, Ecore_Thread *th EINA_UNUSED, void *msg)
 
                     if (size == sd->file_max) _size_bars_max_update_queue(sd);
                   }
+                if (icon2->info.order_index >= 0)
+                  _efm_order_icon_remove(sd, icon2);
                 _icon_free(icon2);
                 if (il) icon2 = il->data;
                 else break;
@@ -855,6 +867,13 @@ _cb_thread_notify(void *data, Ecore_Thread *th EINA_UNUSED, void *msg)
               }
           }
         if (!il) sd->icons = eina_list_append(sd->icons, icon);
+        if ((sd->config.explicit_order) && (sd->listing_done)
+            && (icon->info.order_index < 0))
+          {
+            _efm_order_icon_insert(sd, icon, eina_list_count(sd->order_icons));
+            _efm_order_icons_reindex(sd);
+            _efm_order_send(sd);
+          }
       }
     else if (!strcmp(c->command, "file-mod"))
       {
@@ -882,6 +901,7 @@ _cb_thread_notify(void *data, Ecore_Thread *th EINA_UNUSED, void *msg)
       }
     else if (!strcmp(c->command, "file-del"))
       {
+        Eina_Bool order_changed = EINA_FALSE;
         for (found = EINA_FALSE, tries = 0; (!found) && (tries < 2); tries++)
           {
             for (; il; il = il->next)
@@ -897,6 +917,11 @@ _cb_thread_notify(void *data, Ecore_Thread *th EINA_UNUSED, void *msg)
                       {
                         // XXX: select prev or next icon
                       }
+                    if (icon->info.order_index >= 0)
+                      {
+                        _efm_order_icon_remove(sd, icon);
+                        order_changed = EINA_TRUE;
+                      }
                     if (icon->info.size == icon->sd->file_max)
                       { // this icon is at max size in dir
                         _max_size_recalc(icon->sd);        // find new max
@@ -909,6 +934,11 @@ _cb_thread_notify(void *data, Ecore_Thread *th EINA_UNUSED, void *msg)
               }
             if (!il) il = sd->icons;
           }
+        if (order_changed)
+          {
+            _efm_order_icons_reindex(sd);
+            _efm_order_send(sd);
+          }
         cmd_free(c);
         c = NULL;
       }
diff --git a/src/efm/efm_dnd.c b/src/efm/efm_dnd.c
index b6f9579..6182c24 100644
--- a/src/efm/efm_dnd.c
+++ b/src/efm/efm_dnd.c
@@ -7,6 +7,7 @@
 #include "efm_dnd.h"
 #include "efm_private.h"
 #include "esc.h"
+#include <string.h>
 
 // utils for draga and drop handling
 static Eina_Bool
@@ -139,9 +140,14 @@ _dnd_drop_handle(Smart_Data *sd, char *urilist, Elm_Xdnd_Action act)
 {
   char       **plist, **p, *esc;
   Eina_List   *dropicons, *l;
+  Eina_List   *moved_icons = NULL;
   Icon        *icon;
   int          delta_x = 0, delta_y = 0;
+  Eina_Bool    has_internal = EINA_FALSE;
+  Eina_Bool    internal_move = EINA_TRUE;
   Eina_Strbuf *buf = cmd_strbuf_new("dnd-drop");
+  size_t       sd_path_len
+    = (sd->config.path) ? strlen(sd->config.path) : 0;
 
   switch (act) // we ignore ev->action and use local input mods as above
     {
@@ -188,6 +194,12 @@ _dnd_drop_handle(Smart_Data *sd, char *urilist, Elm_Xdnd_Action act)
         {
           esc = unescape(*p);
           if (!esc) continue;
+          if ((sd_path_len > 0)
+              && (!strncmp(esc, sd->config.path, sd_path_len)))
+            {
+              has_internal = EINA_TRUE;
+            }
+          else internal_move = EINA_FALSE;
           dropicons = _icons_path_find(esc);
           free(esc);
           EINA_LIST_FOREACH(dropicons, l, icon)
@@ -197,6 +209,8 @@ _dnd_drop_handle(Smart_Data *sd, char *urilist, Elm_Xdnd_Action act)
               {
                 if ((icon->sd == sd) && (icon->drag))
                   {
+                    if (!eina_list_data_find(moved_icons, icon))
+                      moved_icons = eina_list_append(moved_icons, icon);
                     printf("XXX:   dropicon is %s%s\n", icon->sd->config.path,
                            icon->info.file);
                     delta_x = icon->sd->dnd_x - icon->down_rel_x - icon->geom.x;
@@ -204,6 +218,7 @@ _dnd_drop_handle(Smart_Data *sd, char *urilist, Elm_Xdnd_Action act)
                     icon->drag = EINA_FALSE;
                     break;
                   }
+                else if (icon->sd != sd) internal_move = EINA_FALSE;
               }
           }
           EINA_LIST_FREE(dropicons, icon);
@@ -277,6 +292,65 @@ _dnd_drop_handle(Smart_Data *sd, char *urilist, Elm_Xdnd_Action act)
           free(esc);
         }
     }
+  if ((sd->config.sort_mode & EFM_SORT_MODE_EXPLICIT_ORDER)
+      && has_internal && internal_move && (act == ELM_XDND_ACTION_MOVE))
+    {
+      Icon      *target = sd->drop_over;
+      Eina_List *ordered_moved = NULL;
+      Eina_List *ln;
+
+      if ((target) && (target->info.dir)) target = NULL;
+      if ((target) && eina_list_data_find(moved_icons, target)) target = NULL;
+
+      EINA_LIST_FOREACH(sd->order_icons, ln, icon)
+      {
+        if (eina_list_data_find(moved_icons, icon))
+          ordered_moved = eina_list_append(ordered_moved, icon);
+      }
+      if (ordered_moved)
+        {
+          EINA_LIST_FOREACH(ordered_moved, ln, icon)
+          {
+            sd->order_icons = eina_list_remove(sd->order_icons, icon);
+          }
+          if (target)
+            {
+              Eina_List *pos = NULL;
+              Icon      *it2;
+
+              if (eina_list_data_find(sd->order_icons, target))
+                {
+                  EINA_LIST_FOREACH(sd->order_icons, pos, it2)
+                  {
+                    if (it2 == target) break;
+                  }
+                }
+              if (pos && pos->data == target)
+                {
+                  EINA_LIST_REVERSE_FOREACH(ordered_moved, ln, icon)
+                  {
+                    sd->order_icons = eina_list_prepend_relative_list(
+                      sd->order_icons, icon, pos);
+                  }
+                }
+              else
+                {
+                  EINA_LIST_FOREACH(ordered_moved, ln, icon)
+                    sd->order_icons = eina_list_append(sd->order_icons, icon);
+                }
+            }
+          else
+            {
+              EINA_LIST_FOREACH(ordered_moved, ln, icon)
+                sd->order_icons = eina_list_append(sd->order_icons, icon);
+            }
+          _efm_order_icons_reindex(sd);
+          _efm_order_send(sd);
+          _reset(sd);
+          eina_list_free(ordered_moved);
+        }
+    }
+  eina_list_free(moved_icons);
   sd->relayout = EINA_TRUE;
   sd->drop_over = NULL;
   evas_object_smart_calculate(sd->o_smart);
diff --git a/src/efm/efm_popup_menu.c b/src/efm/efm_popup_menu.c
index efe9957..ba60186 100644
--- a/src/efm/efm_popup_menu.c
+++ b/src/efm/efm_popup_menu.c
@@ -264,6 +264,25 @@ _cb_menu_item_all(void *data, void *data2 EINA_UNUSED,
   ctx->sd->reset_job = ecore_job_add(_cb_job_refresh, ctx->sd);
 }
 
+static void
+_cb_menu_item_explicit_order(void *data, void *data2 EINA_UNUSED,
+                             Evas_Object *efm               EINA_UNUSED,
+                             const Efm_Menu_Item *menu_item EINA_UNUSED)
+{
+  Popup_Context *ctx = data;
+
+  ctx->sd->config.explicit_order = !!(!ctx->sd->config.explicit_order);
+  if (ctx->sd->config.explicit_order)
+    {
+      ctx->sd->config.sort_mode |= EFM_SORT_MODE_EXPLICIT_ORDER;
+      _efm_order_icons_reindex(ctx->sd);
+      _efm_order_send(ctx->sd);
+    }
+  else ctx->sd->config.sort_mode &= ~EFM_SORT_MODE_EXPLICIT_ORDER;
+  if (ctx->sd->reset_job) ecore_job_del(ctx->sd->reset_job);
+  ctx->sd->reset_job = ecore_job_add(_cb_job_refresh, ctx->sd);
+}
+
 static void
 _cb_menu_item_clean_icons(void *data, void *data2 EINA_UNUSED,
                           Evas_Object *efm               EINA_UNUSED,
@@ -431,8 +450,11 @@ _efm_popup_icon_menu_add(Smart_Data *sd, Icon *ic, Evas_Coord x, Evas_Coord y)
     _efm_menu_it_normal(m2, "Select None", NULL, !have_sel,
                         _cb_menu_item_sel_none, ctx, NULL);
     _efm_menu_it_separator(m2);
-    _efm_menu_it_check(m2, "Show All", NULL, sd->config.all_files, EINA_FALSE,
-                       _cb_menu_item_all, ctx, NULL);
+    _efm_menu_it_check(m2, "Show Hidden Files", NULL, sd->config.all_files,
+                       EINA_FALSE, _cb_menu_item_all, ctx, NULL);
+    _efm_menu_it_check(m2, "Explicit Ordering", NULL,
+                       sd->config.explicit_order, EINA_FALSE,
+                       _cb_menu_item_explicit_order, ctx, NULL);
     if ((sd->config.view_mode == EFM_VIEW_MODE_ICONS_CUSTOM)
         || (sd->config.view_mode == EFM_VIEW_MODE_ICONS_CUSTOM_VERTICAL))
       {
diff --git a/src/efm/efm_structs.h b/src/efm/efm_structs.h
index f73b3f6..3dec6b1 100644
--- a/src/efm/efm_structs.h
+++ b/src/efm/efm_structs.h
@@ -62,6 +62,7 @@ struct _Smart_Data
   Ecore_Thread      *thread;
 
   Eina_List *icons;
+  Eina_List *order_icons;
   Eina_List *blocks;
   Ecore_Job *reblock_job;
   Ecore_Job *refocus_job;
@@ -138,6 +139,7 @@ struct _Smart_Data
     Eina_Stringshare *icon_style;
     Eina_Stringshare *detail_heading[7];
     Eina_Bool         all_files;
+    Eina_Bool         explicit_order;
     Eina_Bool         icon_fill;
   } config;
 };
@@ -159,6 +161,7 @@ struct _File_Info
   const char        *pre_lookup_icon;
   const char        *thumb;
   unsigned long long size;
+  int                order_index;
   Eina_Bool          dir     : 1;
   Eina_Bool          link    : 1;
   Eina_Bool          broken  : 1;
diff --git a/src/efm/efm_util.c b/src/efm/efm_util.c
index 02a38dc..dcdd5f1 100644
--- a/src/efm/efm_util.c
+++ b/src/efm/efm_util.c
@@ -2691,3 +2691,103 @@ _efm_icons_custom_xy_reset(Smart_Data *sd)
       }
   }
 }
+
+static void
+_order_cmd_update(Icon *icon)
+{
+  Cmd *cnew;
+  char buf[32];
+
+  if (!icon->cmd) return;
+  snprintf(buf, sizeof(buf), "%d", icon->info.order_index);
+  cnew = cmd_modify(icon->cmd, "order-index", buf);
+  if (!cnew) return;
+  cmd_free(icon->cmd);
+  icon->cmd = cnew;
+}
+
+void
+_efm_order_icon_remove(Smart_Data *sd, Icon *icon)
+{
+  if ((!sd) || (!icon)) return;
+  if (icon->info.order_index < 0) return;
+  sd->order_icons = eina_list_remove(sd->order_icons, icon);
+  icon->info.order_index = -1;
+  _order_cmd_update(icon);
+}
+
+void
+_efm_order_icon_insert(Smart_Data *sd, Icon *icon, int order_index)
+{
+  Eina_List *l;
+  Icon      *it;
+
+  if ((!sd) || (!icon)) return;
+  sd->order_icons = eina_list_remove(sd->order_icons, icon);
+  icon->info.order_index = order_index;
+  if (order_index < 0)
+    {
+      _order_cmd_update(icon);
+      return;
+    }
+  EINA_LIST_FOREACH(sd->order_icons, l, it)
+  {
+    if (it->info.order_index > order_index)
+      {
+        sd->order_icons
+          = eina_list_prepend_relative_list(sd->order_icons, icon, l);
+        _order_cmd_update(icon);
+        return;
+      }
+  }
+  sd->order_icons = eina_list_append(sd->order_icons, icon);
+  _order_cmd_update(icon);
+}
+
+void
+_efm_order_icons_reindex(Smart_Data *sd)
+{
+  Eina_List *l;
+  Icon      *icon;
+  int        idx = 0;
+
+  if (!sd) return;
+  EINA_LIST_FOREACH(sd->order_icons, l, icon)
+  {
+    if (icon->info.order_index != idx)
+      {
+        icon->info.order_index = idx;
+        _order_cmd_update(icon);
+      }
+    idx++;
+  }
+}
+
+void
+_efm_order_icons_clear(Smart_Data *sd)
+{
+  if (!sd) return;
+  sd->order_icons = NULL;
+}
+
+void
+_efm_order_send(Smart_Data *sd)
+{
+  Eina_Strbuf *buf;
+  Icon        *icon;
+  Eina_List   *l;
+
+  if ((!sd) || (!sd->config.explicit_order)) return;
+  if (!sd->config.path) return;
+  if (!sd->exe_open) return;
+
+  buf = cmd_strbuf_new("order-set");
+  if (!buf) return;
+  cmd_strbuf_append(buf, "path", sd->config.path);
+  EINA_LIST_FOREACH(sd->order_icons, l, icon)
+  {
+    if (icon->info.file)
+      cmd_strbuf_append(buf, "entry", icon->info.file);
+  }
+  cmd_strbuf_exe_consume(buf, sd->exe_open);
+}
diff --git a/src/efm/efm_util.h b/src/efm/efm_util.h
index 4397fff..f87c124 100644
--- a/src/efm/efm_util.h
+++ b/src/efm/efm_util.h
@@ -71,5 +71,10 @@ Icon *_efm_sel_last_get(Smart_Data *sd);
 void  _efm_sel_rename(Smart_Data *sd);
 
 void  _efm_icons_custom_xy_reset(Smart_Data *sd);
+void  _efm_order_icon_insert(Smart_Data *sd, Icon *icon, int order_index);
+void  _efm_order_icon_remove(Smart_Data *sd, Icon *icon);
+void  _efm_order_icons_reindex(Smart_Data *sd);
+void  _efm_order_icons_clear(Smart_Data *sd);
+void  _efm_order_send(Smart_Data *sd);
 
 #endif
diff --git a/src/efm/sort.c b/src/efm/sort.c
index 27fd7a7..3019ebc 100644
--- a/src/efm/sort.c
+++ b/src/efm/sort.c
@@ -198,8 +198,18 @@ _sort_cmd_do(const Cmd *c1, const Cmd *c2)
   Efm_Sort_Mode sort_mode;
   int (*cmpfn)(const char *s1, const char *s2) = strcmp;
   Eina_Bool label_sort                         = EINA_FALSE;
+  long long order1                             = -1;
+  long long order2                             = -1;
+  const char *order_str;
 
   sort_mode = c1->sort_mode;
+  if (sort_mode & EFM_SORT_MODE_EXPLICIT_ORDER)
+    {
+      order_str = cmd_key_find(c1, "order-index");
+      if (order_str) order1 = atoll(order_str);
+      order_str = cmd_key_find(c2, "order-index");
+      if (order_str) order2 = atoll(order_str);
+    }
   // handle flags
   if (sort_mode & EFM_SORT_MODE_DIRS_FIRST)
     dir_not_dir = _sort_dir_not_dir(c1, c2);
@@ -210,6 +220,15 @@ _sort_cmd_do(const Cmd *c1, const Cmd *c2)
 
   // if one is a dir and one is not - other sorting compares are not useful
   // so just return this status
+  if ((sort_mode & EFM_SORT_MODE_EXPLICIT_ORDER)
+      && ((order1 >= 0) || (order2 >= 0)))
+    {
+      if (order1 < 0) return SORT_MORE;
+      if (order2 < 0) return SORT_LESS;
+      if (order1 < order2) return SORT_LESS;
+      if (order1 > order2) return SORT_MORE;
+      // fall through if they matched
+    }
   if (dir_not_dir != SORT_INVALID) return dir_not_dir;
 
   // handle the actual specific sort field to use