diff --git a/README.md b/README.md
index 18f2192..8e68d08 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,19 @@ All permissions are listed with a short description in this [plugin.yml](https:/
 
 * **/scompass** visual interface (clickable book)
 * **/scompass-option** will show the menu to choose where and when display the compass
-* **/sctrack** to tracker a position, coordinates or a player
+* **/sctrack** to tracker a position, coordinates or a player (see below)
 * **/scompass-reload** will reload the configuration
 
 You can use **/scompass-option** with arguments directly if you prefer (`/scompass-option <option> <type>`).
+
+## Trackers addons
+
+To use the command **sctrack**, you need at least one tracker addon. You can find them here:
+
+* [CoordsTracker](https://github.com/arboriginal/SCT-CoordsTracker): Allows to track specific coordinates.
+* [DeathPosTracker](https://github.com/arboriginal/SCT-DeathPosTracker): Allows to track the last death position.
+* [PapiPositionTracker](https://github.com/arboriginal/SCT-PapiPositionTracker): Allows to track positions defined using PlaholderAPI placeholders.
+* [PlayerTracker](https://github.com/arboriginal/SCT-PlayerTracker): Allows to track players positions.
+* [PositionTracker](https://github.com/arboriginal/SCT-PositionTracker): Allows to track static positions.
+
+Have a look at the [Spigot plugin thread](https://www.spigotmc.org/threads/simplecompass.351093/), maybe other addon (made by other developers) will be listed.
diff --git a/lang/en.yml b/lang/en.yml
index 15c1e1e..706b4f5 100644
--- a/lang/en.yml
+++ b/lang/en.yml
@@ -10,6 +10,8 @@ prefix: "&8[&eSimpleCompass&8] "  # But you can also decide to remove the {prefi
 
 # Message displayed when using the reload command
 configuration_reloaded: "{prefix}&aConfiguration successfully reloaded"
+# Message displayed when using the reload command and a tracker can't init correctly
+tracker_disabled: "{prefix}&cTracker {tracker} can't be reloaded, it has been disabled."
 
 # Invalid choice in the config file for compasses default settings.
 invalid_choice: "{prefix}&cInvalid default choice for {type} ({key}), using default"
@@ -21,8 +23,8 @@ invalid_bossbar_style: "{prefix}&cInvalid bossbar style, using default"
 invalid_bossbar_color_level: "{prefix}&cInvalid bossbar color found in elytra levels."
 # Mistake in config file for compass requirements
 invalid_items: "{prefix}&cFound invalid items in {section} ({type}) requirement list, &6&l{ignored}&c has been ignored..."
-# Mistake in config file for "tracker_settings"
-invalid_names: "{prefix}&cFound invalid names in tracker_settings, modified: {modified}."
+# Mistake in language file for actions and subcommands names
+invalid_names: "{prefix}&cFound invalid names in your locale file, modified: {modified}."
 # Information message for cardinals if they have not same length, see "filling_char" for more details
 cardinal_length: "{prefix}&eYour cardinal {cardinal} ({key}) has been adjusted to fit the max length of others"
 # If you commit an error in trackers priorities list
@@ -50,8 +52,6 @@ missing_target: "{prefix}&6You must specify a valid target name!"
 target_exists: "{prefix}&e{target} &calready exists."
 # Unknown target for request
 target_not_found: "{prefix}&e{target} &ccannot be found!"
-# When a player try to accept / deny an expired request
-request_expired: "{prefix}&cNo pending request from &e{player}&c."
 
 # Displayed in compasses when the player no more have required items to use the compass
 warnPlayerNoMoreFuel: "&cYou no longer have the necessary items..."
@@ -66,9 +66,11 @@ interface_book_give_cooldown: "{prefix}&cYou have to wait {delay} before another
 
 # You can define your own action names here (choose something short and understandable by your players)
 actions:
+  ACCEPT: accept
   ADD: add
   ASK: ask
   DEL: del
+  DENY: deny
   HELP: help
   START: start
   STOP: stop
@@ -96,13 +98,6 @@ time_display:
   minute: "min"
   second: "s"
 
-# You can define your own tracker names here (choose something short and understandable by your players)
-trackers:
-  COORDS: coords
-  DEATH_POSITION: death
-  PLAYER: player
-  POSITION: position
-
 # Human name for the compass types
 types:
   ACTIONBAR: "Action bar"
@@ -207,131 +202,10 @@ commands:
       &8.
 
   sctrack:
-    COORDS:
-      list: "{prefix}&rNamed coordinates: {list}."
-      list_empty: "{prefix}&rNo named coordinates."
-
-      ADD: "{prefix}&aNamed coordinate &e{target}&a has been created."
-      DEL: "{prefix}&aNamed coordinate &e{target}&a has been deleted."
-      START: "{prefix}&6You are now tracking &e{target}&6 coordinate."
-      STOP: "{prefix}&6You no longer track &e{target}&6 coordinate."
-
-    DEATH_POSITION:
-      list: "{prefix}&rDeath coordinates: {list}&r."
-      list_coord: "&6x: &c{x} &r/ &6z: &c{z}"
-      list_empty: "{prefix}&rNo death coordinates."
-
-      START: "{prefix}&6You are now tracking your &elast death&6 position."
-      STOP: "{prefix}&6You no longer track your &elast death&6 position."
-
-    PLAYER:
-      list: "{prefix}&rTracked players: {list}."
-      list_empty: "{prefix}&rNo player tracked."
-
-      ASK: "{prefix}&rTracking request sent to {target}."
-      START: "{prefix}&6You are now tracking &e{target}&6."
-      STOP: "{prefix}&6You no longer track &e{target}&6."
-
-      request:
-        message: |
-          {prefix}&8--------------------------------------
-          &8|
-          &8|                 &e{player} &7want to track you.
-          &8|
-          &8|                   &8[ {deny} &8] &f/&8 [ {accept} &8] &f?
-          &8|
-          &8----------------------------------------------------
-        accept: "&a&lACCEPT"
-        accept_hover: |
-          Click to &e&laccept
-          &7 -- or type --
-          &c/sctaccept {player}
-        deny: "&c&lDENY"
-        deny_hover: |
-          Click to &e&ldeny
-          &7 -- or type --
-          &c/sctdeny {player}
-        accepted:
-          player: "{prefix}&e{target}&r has &aaccepted&r your request."
-          target: "{prefix}&e{player}&r is now tracking you..."
-          player_limit_reached: "{prefix}&e{target}&r has &aaccepted&r your request, but you cannot track more players."
-          target_limit_reached: "{prefix}&e{player}&r cannot track more players and is NOT tracking you for now..."
-        refused:
-          player: "{prefix}&e{target}&r has &crefused&r your request."
-          target: "{prefix}&e{player}&r will not track you."
-
-    POSITION:
-      list: "{prefix}&rNamed positions: {list}."
-      list_empty: "{prefix}&rNo named positions."
-
-      ADD: "{prefix}&aNamed position &e{target}&a has been created."
-      DEL: "{prefix}&aNamed position &e{target}&a has been deleted."
-      START: "{prefix}&6You are now tracking &e{target}&6 position."
-      STOP: "{prefix}&6You no longer track &e{target}&6 position."
-
-    help: # See tracker_settings for values substitutions
+    help:
       header: "&e|  {prefix} &aHelp &l{tracker} &atracking"
       separator: "&e-----------------------------------------------------"
 
-      COORDS:
-        noargs: |
-          &r- &c/{command} &e{COORDS}
-          &7  Show the list of your named coordinates.
-        ADD: |
-          &r- &c/{command} &e{COORDS} &6{ADD} &3<name> &b<x> <z>
-          &7  Add a new named coordinate.
-        DEL: |
-          &r- &c/{command} &e{COORDS} &6{DEL} &3<name>
-          &7  Delete a named coordinate.
-        START: |
-          &r- &c/{command} &e{COORDS} &6{START} &3<name>
-          &7  Begin the tracking of this named coordinate.
-        STOP: |
-          &r- &c/{command} &e{COORDS} &6{STOP} &3<name>
-          &7  End the tracking of this named coordinate.
-
-      DEATH_POSITION:
-        noargs: |
-          &r- &c/{command} &e{DEATH_POSITION}
-          &7  Show your last death coordinates.
-        START: |
-          &r- &c/{command} &e{DEATH_POSITION} &6{START}
-          &7  Begin the tracking of your last death coordinate.
-        STOP: |
-          &r- &c/{command} &e{DEATH_POSITION} &6{STOP}
-          &7  End the tracking of your last death coordinate.
-
-      PLAYER:
-        noargs: |
-          &r- &c/{command} &e{PLAYER}
-          &7  Show list of players you are currently tracking.
-        ASK: |
-          &r- &c/{command} &e{PLAYER} &6{ASK} &3<name>
-          &7  Ask to a player to track his position.
-        START: |
-          &r- &c/{command} &e{PLAYER} &6{START} &3<name>
-          &7  Begin the tracking of this player (without asking).
-        STOP: |
-          &r- &c/{command} &e{PLAYER} &6{STOP} &3<name>
-          &7  End the tracking of this player.
-
-      POSITION:
-        noargs: |
-          &r- &c/{command} &e{POSITION}
-          &7  Show list of trackable positions.
-        ADD: |
-          &r- &c/{command} &e{POSITION} &6{ADD} &3<name> &b<x> <z>
-          &7  Create a new trackable position.
-        DEL: |
-          &r- &c/{command} &e{POSITION} &6{DEL} &3<name>
-          &7  Remove this trackable position.
-        START: |
-          &r- &c/{command} &e{POSITION} &6{START} &3<name>
-          &7  Begin the tracking of this named position.
-        STOP: |
-          &r- &c/{command} &e{POSITION} &6{STOP} &3<name>
-          &7  End the tracking of this named position.
-
     limits:
       ADD: "{prefix}&cYou have reached the limit of {tracker}."
       START: "{prefix}&cYou cannot track more than {limit} {tracker}."
diff --git a/lang/fr.yml b/lang/fr.yml
index 66d3c3f..c543264 100644
--- a/lang/fr.yml
+++ b/lang/fr.yml
@@ -10,6 +10,8 @@ prefix: "&8[&eSimpleCompass&8] "  # Mais tu peux aussi le décider de retirer la
 
 # Message affiché quand la commande reload est utilisée
 configuration_reloaded: "{prefix}&aConfiguration rechargée"
+# Message affiché quand la commande reload est utilisée et qu'un tracker ne s'initialise pas correctement
+tracker_disabled: "{prefix}&cLe tracker {tracker} n'a pas pu être rechargé, il a été désactivé."
 
 # Choix invalide dans le fichier de config pour les réglages par défaut des boussoles.
 invalid_choice: "{prefix}&cChoix par défaut invalide pour {type} ({key}), utilisation de ceux par défaut"
@@ -21,8 +23,8 @@ invalid_bossbar_style: "{prefix}&cStyle de barre de boss invalide, utilisation d
 invalid_bossbar_color_level: "{prefix}&cCouleur de barre de boss invalide dans les niveaux liés aux élytres."
 # Erreur dans le fichier de config pour les prérequis d'une boussole 
 invalid_items: "{prefix}&cItems invalides trouvés dans les prérequis de {section} ({type}), &6&l{ignored}&c ont été ignorés..."
-# Erreur dans le fichier de config pour "tracker_settings"
-invalid_names: "{prefix}&cNoms invalides trouvés dans tracker_settings, modifié : {modified}."
+# Erreur dans le fichier de langue pour les noms d'actions et de subcommands
+invalid_names: "{prefix}&cNoms invalides trouvés dans le fichier de langue, modifiés : {modified}."
 # Message d'information pour les points cardinaux s'ils n'ont pas la même longueur, voir "filling_char" pour plus de détails
 cardinal_length: "{prefix}&eTon point cardinal {cardinal} ({key}) a été ajusté pour correspondre à la longueur des autres"
 # Si tu as fait une erreur dans la liste de priorité des trackers
@@ -50,8 +52,6 @@ missing_target: "{prefix}&6Tu dois préciser un nom valide !"
 target_exists: "{prefix}&e{target} &cexiste déjà."
 # Cible inconnue pour la requête
 target_not_found: "{prefix}&e{target} &cest introuvable !"
-# Quand un joueur tente d'accepter / refuser une requête expirée
-request_expired: "{prefix}&cPas de requête en cours pour &e{player}&c."
 
 # Affiché dans les boussoles quand le joueur n'a plus les items nécessaires pour l'utiliser
 warnPlayerNoMoreFuel: "&cTu n'as plus les items requis..."
@@ -66,9 +66,11 @@ interface_book_give_cooldown: "{prefix}&cTu dois attendre {delay} avant qu'un au
 
 # Tu peux définir tes propres noms d'action ici (choisis quelque chose de court et compréhensible pour les joueurs)
 actions:
+  ACCEPT: accepter
   ADD: ajouter
   ASK: demander
   DEL: supprimer
+  DENY: refuser
   HELP: aide
   START: commencer
   STOP: stopper
@@ -96,13 +98,6 @@ time_display:
   minute: "min"
   second: "s"
 
-# Tu peux définir tes propres noms de trackers ici (choisis quelque chose de court et compréhensible pour les joueurs)
-trackers:
-  COORDS: coords
-  DEATH_POSITION: mort
-  PLAYER: joueur
-  POSITION: position
-
 # Noms des types de boussoles
 types:
   ACTIONBAR: "Barre d'action"
@@ -207,131 +202,10 @@ commands:
       &8.
 
   sctrack:
-    COORDS:
-      list: "{prefix}&rCoordonnées nommées : {list}."
-      list_empty: "{prefix}&rAucunes coordonnées nommées."
-
-      ADD: "{prefix}&aLes coordonnées &e{target}&a ont été créées."
-      DEL: "{prefix}&aLes coordonnées &e{target}&a ont été supprimée."
-      START: "{prefix}&6Tu pistes maintenant les coordonnées &e{target}&6."
-      STOP: "{prefix}&6Tu ne pistes plus les coordonnées &e{target}&6."
-
-    DEATH_POSITION:
-      list: "{prefix}&rDernière mort: {list}&r."
-      list_coord: "&6x: &c{x} &r/ &6z: &c{z}"
-      list_empty: "{prefix}&rPas de coordinées de mort."
-
-      START: "{prefix}&6Tu pistes maintenant &eta dernière mort&6."
-      STOP: "{prefix}&6Tu ne pistes plus &eta dernière mort&6."
-
-    PLAYER:
-      list: "{prefix}&rJoueurs pistés : {list}."
-      list_empty: "{prefix}&rAucun joueur pisté."
-
-      ASK: "{prefix}&rDemande pistage envoyée à {target}."
-      START: "{prefix}&6Tu pistes maintenant &e{target}&6."
-      STOP: "{prefix}&6Tu ne pistes plus &e{target}&6."
-
-      request:
-        message: |
-          {prefix}&8--------------------------------------
-          &8|
-          &8|                 &e{player} &7veut te pister.
-          &8|
-          &8|                   &8[ {deny} &8] &f/&8 [ {accept} &8] &f?
-          &8|
-          &8----------------------------------------------------
-        accept: "&a&lACCEPTER"
-        accept_hover: |
-          Clique pour &e&laccepter
-          &7 -- ou tape --
-          &c/sctaccept {player}
-        deny: "&c&lREFUSER"
-        deny_hover: |
-          Clique pour &e&lrefuser
-          &7 -- ou tape --
-          &c/sctdeny {player}
-        accepted:
-          player: "{prefix}&e{target}&r a &aaccepté&r ta demande."
-          target: "{prefix}&e{player}&r te pistes à présent..."
-          player_limit_reached: "{prefix}&e{target}&r a &aaccepté&r ta demande, mais tu ne peux pas pister d'autre joueurs."
-          target_limit_reached: "{prefix}&e{player}&r ne peux pas pister d'autre joueurs pour le moment et ne te pistes donc pas..."
-        refused:
-          player: "{prefix}&e{target}&r a &crefusé&r ta requête."
-          target: "{prefix}&e{player}&r ne te pistes plus."
-
-    POSITION:
-      list: "{prefix}&rPositions nommées : {list}."
-      list_empty: "{prefix}&rAucune position nommée."
-
-      ADD: "{prefix}&aLa position &e{target}&a a été créée."
-      DEL: "{prefix}&aLa position &e{target}&a a été supprimée."
-      START: "{prefix}&6Tu pistes maintenant la position &e{target}&6."
-      STOP: "{prefix}&6Tu ne pistes plus la position &e{target}&6."
-
-    help: # Voir tracker_settings pour les valeurs de substitution
+    help:
       header: "&e|  {prefix} &aAide pistage &l{tracker}"
       separator: "&e-----------------------------------------------------"
 
-      COORDS:
-        noargs: |
-          &r- &c/{command} &e{COORDS}
-          &7  Affiche la liste des coordonnées nommées.
-        ADD: |
-          &r- &c/{command} &e{COORDS} &6{ADD} &3<nom> &b<x> <z>
-          &7  Crée une coordonnée nommée.
-        DEL: |
-          &r- &c/{command} &e{COORDS} &6{DEL} &3<nom>
-          &7  Supprime une coordonnée nommée.
-        START: |
-          &r- &c/{command} &e{COORDS} &6{START} &3<nom>
-          &7  Démarre le pistage d'une coordonnée nommée.
-        STOP: |
-          &r- &c/{command} &e{COORDS} &6{STOP} &3<nom>
-          &7  Arrête le pistage d'une coordonnée nommée.
-
-      DEATH_POSITION:
-        noargs: |
-          &r- &c/{command} &e{DEATH_POSITION}
-          &7  Affiche les coordonnées de ta dernière mort.
-        START: |
-          &r- &c/{command} &e{DEATH_POSITION} &6{START}
-          &7  Démarre le pistage de ta dernière mort.
-        STOP: |
-          &r- &c/{command} &e{DEATH_POSITION} &6{STOP}
-          &7  Arrête le pistage de ta dernière mort.
-
-      PLAYER:
-        noargs: |
-          &r- &c/{command} &e{PLAYER}
-          &7  Affiche la liste des joueurs que tu pistes.
-        ASK: |
-          &r- &c/{command} &e{PLAYER} &6{ASK} &3<nom>
-          &7  Demande à un joueur de le pister.
-        START: |
-          &r- &c/{command} &e{PLAYER} &6{START} &3<nom>
-          &7  Démarre le pistage d'un joueur (sans demande).
-        STOP: |
-          &r- &c/{command} &e{PLAYER} &6{STOP} &3<nom>
-          &7  Arrête le pistage d'un joueur.
-
-      POSITION:
-        noargs: |
-          &r- &c/{command} &e{POSITION}
-          &7  Affiche la liste des positions nommées.
-        ADD: |
-          &r- &c/{command} &e{POSITION} &6{ADD} &3<nom> &b<x> <z>
-          &7  Crée une position nommée.
-        DEL: |
-          &r- &c/{command} &e{POSITION} &6{DEL} &3<nom>
-          &7  Supprime une position nommée.
-        START: |
-          &r- &c/{command} &e{POSITION} &6{START} &3<nom>
-          &7  Démarre le pistage d'une position nommée.
-        STOP: |
-          &r- &c/{command} &e{POSITION} &6{STOP} &3<nom>
-          &7  Arrête le pistage d'une position nommée.
-
     limits:
       ADD: "{prefix}&cTu as atteind la limite de {tracker}."
       START: "{prefix}&cTu ne peux pas cibler plus de {limit} {tracker}."
diff --git a/src/config.yml b/src/config.yml
index 3c16688..da2414b 100644
--- a/src/config.yml
+++ b/src/config.yml
@@ -176,48 +176,14 @@ compass:
           50: YELLOW
           20: RED
 
-# Options relative to the track command...
-tracker_settings:
-  priority: # Order in which trackers will be displayed
+ # Order in which trackers will be displayed (if they are installed and activated)
+trackers_priorities:
   - COORDS
   - PLAYER
   - POSITION
   - DEATH_POSITION
-
-  trackers:
-    COORDS:
-      symbol: "§e☉"        # Symbol displayed on the compass for this king of trackers.
-      temp: "ϼ"            # Advanced: Symbol temporary used by the plugin, must be unique, 1 char and not used in "symbol".
-      auto_activated: true # If true, the tracker is automatically activated when a coord is created
-      limits:
-        ADD: 10     # Number of maximum named coords a player can define
-        START: 1    # Number of maximum simultaneous coords a player can track
-
-    DEATH_POSITION:
-      symbol: "§d§l☠"
-      temp: "☙"
-      auto_activated: true # If true, the tracker is automatically activated on death
-
-    PLAYER:
-      symbol: "§a§l♙"
-      temp: "♃"
-      limits:
-        START: 1 # Number of maximum simultaneous players a player can track
-
-    POSITION:
-      symbol: "§c☤"
-      temp: "⚭"
-      auto_activated: false # If true, the tracker is automatically activated when a position is created
-      limits:
-        START: 2 # Number of maximum simultaneous positions a player can track
-
-  request_duration: 120 # Duration in seconds while a player tracking request stays valid.
-
-# Defined positions for players with "scompass.track.POSITION" permission
-positions: # DO NOT use a name you have defined in trackers_settings.trackers
-  spawn: { x: 0, z: 0} # /!\ You need to give permission scompass.track.POSITION.defined.spawn or scompass.track.POSITION.defined.* to use it
-  # random: { x: 1000, z: 1000}    <--- an example on how to add another defined position
-# Those positions can be managed in game with permission "scompass.track.POSITION.manage"
+  # When a new tracker is added, a new entrie is put here. You can prepare this list before if you want:
+  # trackerIDs here which correspond to nothing will be simply ignored.
 
 # Advanced... Delays / cache durations (FYI: 20 ticks = 1 second if your server doesn't lag)
 delays:
diff --git a/src/me/arboriginal/SimpleCompass/commands/AbstractCommand.java b/src/me/arboriginal/SimpleCompass/commands/AbstractCommand.java
index fbad656..b22828c 100644
--- a/src/me/arboriginal/SimpleCompass/commands/AbstractCommand.java
+++ b/src/me/arboriginal/SimpleCompass/commands/AbstractCommand.java
@@ -8,9 +8,9 @@
 import com.google.common.collect.ImmutableMap;
 import me.arboriginal.SimpleCompass.compasses.AbstractCompass.CompassModes;
 import me.arboriginal.SimpleCompass.compasses.AbstractCompass.CompassTypes;
+import me.arboriginal.SimpleCompass.plugin.AbstractTracker;
 import me.arboriginal.SimpleCompass.plugin.SimpleCompass;
-import me.arboriginal.SimpleCompass.trackers.AbstractTracker;
-import me.arboriginal.SimpleCompass.trackers.AbstractTracker.TrackingActions;
+import me.arboriginal.SimpleCompass.plugin.AbstractTracker.TrackingActions;
 
 public abstract class AbstractCommand {
   protected SimpleCompass        sc;
@@ -30,13 +30,8 @@ public enum CompassOptions {
   // ----------------------------------------------------------------------------------------------
 
   public AbstractCommand(SimpleCompass plugin, String command) {
-    this(plugin, command, ImmutableMap.of());
-  }
-
-  public AbstractCommand(SimpleCompass plugin, String command, ImmutableMap<SubCmds, String> subCmdsMap) {
     sc          = plugin;
     mainCommand = command;
-    subCommands = subCmdsMap;
   }
 
   //-----------------------------------------------------------------------------------------------
@@ -167,10 +162,9 @@ public boolean performCommandTrack(Player player, String[] args) {
       List<String> list = tracker.list(player, null, "");
 
       if (list == null || list.isEmpty())
-        sc.sendMessage(player, "commands.sctrack." + tracker.trackerID() + ".list_empty");
+        tracker.sendMessage(player, "list_empty");
       else
-        sc.sendMessage(player, "commands.sctrack." + tracker.trackerID() + ".list",
-            ImmutableMap.of("list", String.join(", ", list)));
+        tracker.sendMessage(player, "list", ImmutableMap.of("list", String.join(", ", list)));
 
       return true;
     }
@@ -204,8 +198,7 @@ protected List<String> completeCommandTrack(Player player, String[] args) {
   }
 
   protected List<TrackingActions> getActionsAvailable(Player player, String trackerID) {
-    if (!player.hasPermission("scompass.track." + trackerID)) return null;
-
+    if (!sc.targets.canUseTracker(player, trackerID)) return null;
     return sc.trackers.get(trackerID).getActionsAvailable(player, false);
   }
 
diff --git a/src/me/arboriginal/SimpleCompass/commands/InterfaceCommand.java b/src/me/arboriginal/SimpleCompass/commands/InterfaceCommand.java
index 327506a..3a0b3e9 100644
--- a/src/me/arboriginal/SimpleCompass/commands/InterfaceCommand.java
+++ b/src/me/arboriginal/SimpleCompass/commands/InterfaceCommand.java
@@ -23,10 +23,10 @@
 import com.google.common.collect.ImmutableMap;
 import me.arboriginal.SimpleCompass.compasses.AbstractCompass.CompassModes;
 import me.arboriginal.SimpleCompass.compasses.AbstractCompass.CompassTypes;
+import me.arboriginal.SimpleCompass.plugin.AbstractTracker;
+import me.arboriginal.SimpleCompass.plugin.AbstractTracker.TargetSelector;
+import me.arboriginal.SimpleCompass.plugin.AbstractTracker.TrackingActions;
 import me.arboriginal.SimpleCompass.plugin.SimpleCompass;
-import me.arboriginal.SimpleCompass.trackers.AbstractTracker;
-import me.arboriginal.SimpleCompass.trackers.AbstractTracker.TargetSelector;
-import me.arboriginal.SimpleCompass.trackers.AbstractTracker.TrackingActions;
 import me.arboriginal.SimpleCompass.utils.NMSUtil;
 import net.md_5.bungee.api.chat.BaseComponent;
 import net.md_5.bungee.api.chat.TextComponent;
@@ -38,9 +38,12 @@ public class InterfaceCommand extends AbstractCommand implements CommandExecutor
   // ----------------------------------------------------------------------------------------------
 
   public InterfaceCommand(SimpleCompass plugin) {
-    super(plugin, "scompass", ImmutableMap.of(
-        SubCmds.OPTION, plugin.locale.getString("subcommands." + SubCmds.OPTION),
-        SubCmds.TRACK, plugin.locale.getString("subcommands." + SubCmds.TRACK)));
+    super(plugin, "scompass");
+
+    subCommands.put(SubCmds.OPTION, plugin.locale.getString("subcommands." + SubCmds.OPTION));
+
+    if (!sc.trackers.isEmpty())
+      subCommands.put(SubCmds.TRACK, plugin.locale.getString("subcommands." + SubCmds.TRACK));
   }
 
   // ----------------------------------------------------------------------------------------------
@@ -96,8 +99,8 @@ public List<String> onTabComplete(CommandSender sender, Command command, String
     if (args.length == 1) {
       List<String> list = new ArrayList<String>();
 
-      for (SubCmds subCommand : SubCmds.values()) {
-        String subCommandName = sc.locale.getString("subcommands." + subCommand);
+      for (SubCmds subCommand : subCommands.keySet()) {
+        String subCommandName = subCommands.get(subCommand);
 
         if (subCommandName.toLowerCase().startsWith(args[0].toLowerCase())) list.add(subCommandName);
       }
@@ -256,7 +259,8 @@ private void giveBook(Player player, ItemStack book) {
   }
 
   private boolean subCommand(Player player, SubCmds command, String argument) {
-    return argument.toLowerCase().equals(subCommands.get(command).toLowerCase())
+    return subCommands.get(command) != null
+        && argument.toLowerCase().equals(subCommands.get(command).toLowerCase())
         && player.hasPermission("scompass." + command.toString().toLowerCase())
         && (command.equals(SubCmds.OPTION) || !sc.trackers.isEmpty());
   }
diff --git a/src/me/arboriginal/SimpleCompass/compasses/AbstractCompass.java b/src/me/arboriginal/SimpleCompass/compasses/AbstractCompass.java
index 4b1bb36..e4840be 100644
--- a/src/me/arboriginal/SimpleCompass/compasses/AbstractCompass.java
+++ b/src/me/arboriginal/SimpleCompass/compasses/AbstractCompass.java
@@ -8,6 +8,7 @@
 import org.bukkit.scheduler.BukkitRunnable;
 import org.bukkit.util.Vector;
 import me.arboriginal.SimpleCompass.managers.TaskManager.TasksTypes;
+import me.arboriginal.SimpleCompass.plugin.AbstractTracker;
 import me.arboriginal.SimpleCompass.plugin.SimpleCompass;
 
 public abstract class AbstractCompass {
@@ -122,7 +123,7 @@ private char getFacing() {
     return Arrays.asList('S', 'W', 'N', 'E').get(Math.round(owner.getLocation().getYaw() / 90f) & 0x3);
   }
 
-  private HashMap<String, ArrayList<double[]>> getActiveTrackers() { // @formatter:off
+  private HashMap<String, ArrayList<double[]>> getActiveTargets() { // @formatter:off
     String cacheKey = "trackers." + type;
     @SuppressWarnings("unchecked")
     HashMap<String, ArrayList<double[]>> trackers
@@ -137,8 +138,8 @@ private HashMap<String, ArrayList<double[]>> getActiveTrackers() { // @formatter
   } // @formatter:on
 
   private String injectActivatedTrackers(String compass, String sepColor) {
-    HashMap<String, ArrayList<double[]>> trackers = getActiveTrackers();
-    if (trackers.isEmpty()) return compass;
+    HashMap<String, ArrayList<double[]>> targets = getActiveTargets();
+    if (targets.isEmpty()) return compass;
 
     Location refPos = owner.getEyeLocation();
     Vector   lookAt = refPos.getDirection().setY(0);
@@ -146,24 +147,21 @@ private String injectActivatedTrackers(String compass, String sepColor) {
     HashMap<String, String> placeholders = new HashMap<String, String>();
 
     for (String type : sc.targets.trackersPriority) {
-      ArrayList<double[]> coords = trackers.get(type);
-
-      if (coords == null) continue;
-
-      String marker = sc.config.getString("tracker_settings.trackers." + type + ".temp");
-      String symbol = sc.config.getString("tracker_settings.trackers." + type + ".symbol");
+      ArrayList<double[]> coords  = targets.get(type);
+      AbstractTracker     tracker = sc.trackers.get(type);
+      if (coords == null || tracker == null) continue;
 
+      String marker = tracker.settings.getString("settings.temp");
+      String symbol = tracker.settings.getString("settings.symbol");
       placeholders.put(marker, symbol + sepColor);
 
-      for (double[] tracker : trackers.get(type)) {
-        Vector blockDirection = new Location(owner.getWorld(), tracker[0], refPos.getY(), tracker[1])
+      for (double[] target : targets.get(type)) {
+        Vector blockDirection = new Location(owner.getWorld(), target[0], refPos.getY(), target[1])
             .subtract(refPos).toVector().normalize();
 
         boolean viewable = (lookAt.dot(blockDirection) > 0);
         double  angle    = Math.toDegrees(blockDirection.angle(lookAt.crossProduct(new Vector(0, 1, 0))));
-
         if (!viewable) angle = (angle > 90) ? 180 : 0;
-
         int start = compass.length() - (int) Math.round(2 * angle * compass.length() / 360);
 
         compass = (start < 2) ? marker + compass.substring(start + 1)
diff --git a/src/me/arboriginal/SimpleCompass/managers/DataManager.java b/src/me/arboriginal/SimpleCompass/managers/DataManager.java
index ae19d95..4626738 100644
--- a/src/me/arboriginal/SimpleCompass/managers/DataManager.java
+++ b/src/me/arboriginal/SimpleCompass/managers/DataManager.java
@@ -117,7 +117,7 @@ public CompassOptions compassOptionGet(Player player, CompassTypes type) {
     String key = compassOptionKey(player, type);
 
     return CompassOptions.valueOf(users.contains(key) ? users.getString(key)
-        : sc.config.getDefaults().getString("compass." + type + ".default.option"));
+        : sc.config.getString("compass." + type + ".default.option"));
   }
 
   public String compassOptionKey(Player player, CompassTypes type) {
diff --git a/src/me/arboriginal/SimpleCompass/managers/TargetManager.java b/src/me/arboriginal/SimpleCompass/managers/TargetManager.java
index 56fb814..fe1cc7c 100644
--- a/src/me/arboriginal/SimpleCompass/managers/TargetManager.java
+++ b/src/me/arboriginal/SimpleCompass/managers/TargetManager.java
@@ -5,8 +5,8 @@
 import java.util.List;
 import java.util.UUID;
 import org.bukkit.entity.Player;
+import me.arboriginal.SimpleCompass.plugin.AbstractTracker;
 import me.arboriginal.SimpleCompass.plugin.SimpleCompass;
-import me.arboriginal.SimpleCompass.trackers.AbstractTracker;
 
 public class TargetManager {
   private SimpleCompass sc;
@@ -27,8 +27,9 @@ public TargetManager(SimpleCompass plugin) {
       activeTargets.put(trackerID, new HashMap<UUID, List<String>>());
 
     trackersPriority = new String[sc.trackers.size()];
-    List<String> priority = sc.config.getStringList("tracker_settings.priority");
+    if (sc.trackers.size() == 0) return;
 
+    List<String> priority = sc.config.getStringList("trackers_priorities");
     for (int i = 0; i < priority.size(); i++) trackersPriority[i] = priority.get(i);
   }
 
@@ -36,12 +37,13 @@ public TargetManager(SimpleCompass plugin) {
   // Trackers methods
   // ----------------------------------------------------------------------------------------------
 
+  public boolean canUseTracker(Player player, String trackerID) {
+    return player.hasPermission("scompass.track.*") || player.hasPermission("scompass.track." + trackerID);
+  }
+
   public List<String> getAvailableTrackers(Player player) {
     List<String> list = new ArrayList<String>();
-
-    for (String trackerID : sc.trackers.keySet())
-      if (player.hasPermission("scompass.track." + trackerID)) list.add(trackerID);
-
+    for (String trackerID : sc.trackers.keySet()) if (canUseTracker(player, trackerID)) list.add(trackerID);
     return list;
   }
 
diff --git a/src/me/arboriginal/SimpleCompass/trackers/AbstractTracker.java b/src/me/arboriginal/SimpleCompass/plugin/AbstractTracker.java
similarity index 64%
rename from src/me/arboriginal/SimpleCompass/trackers/AbstractTracker.java
rename to src/me/arboriginal/SimpleCompass/plugin/AbstractTracker.java
index 196a38b..219f6e9 100644
--- a/src/me/arboriginal/SimpleCompass/trackers/AbstractTracker.java
+++ b/src/me/arboriginal/SimpleCompass/plugin/AbstractTracker.java
@@ -1,37 +1,101 @@
-package me.arboriginal.SimpleCompass.trackers;
+package me.arboriginal.SimpleCompass.plugin;
 
+import java.io.File;
+import java.net.URL;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 import java.util.UUID;
 import org.bukkit.configuration.MemorySection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
 import com.google.common.collect.ImmutableMap;
-import me.arboriginal.SimpleCompass.plugin.SimpleCompass;
+import me.arboriginal.SimpleCompass.utils.LangUtil;
 
 public abstract class AbstractTracker {
-  SimpleCompass sc;
+  protected SimpleCompass sc;
+  protected File          sf;
 
   public enum TrackingActions {
-    ADD, ASK, DEL, HELP, START, STOP,
+    ADD, ACCEPT, ASK, DEL, DENY, HELP, START, STOP,
   }
-  
+
   public enum TargetSelector {
     ACTIVE, AVAILABLE, NEW, NEWCOORDS, NONE,
   }
 
+  public FileConfiguration settings;
+
   // ----------------------------------------------------------------------------------------------
   // Constructor methods
   // ----------------------------------------------------------------------------------------------
 
   public AbstractTracker(SimpleCompass plugin) {
     sc = plugin;
+    sf = new File(sc.getDataFolder(), "trackers/" + getClass().getSimpleName() + ".yml");
+  }
+
+  // ----------------------------------------------------------------------------------------------
+  // Initialization methods
+  // ----------------------------------------------------------------------------------------------
+
+  public boolean init() {
+    if (!sf.exists()) {
+      URL res = getClass().getResource("/settings.yml");
+      if (res == null) return false;
+
+      try {
+        LangUtil.writeResourceToFile(res.openStream(), sf);
+      }
+      catch (Exception e) {
+        return false;
+      }
+    }
+
+    settings = YamlConfiguration.loadConfiguration(sf);
+    return true;
+  }
+
+  // ----------------------------------------------------------------------------------------------
+  // Utils methods
+  // ----------------------------------------------------------------------------------------------
+
+  public void sendMessage(Player player, String key) {
+    sendMessage(player, key, null);
+  }
+
+  public void sendMessage(Player player, String key, Map<String, String> placeholders) {
+    if (key.isEmpty()) return;
+    String message = prepareMessage(key, placeholders);
+    if (!message.isEmpty()) player.sendMessage(message);
+  }
+
+  public String prepareMessage(String key) {
+    return prepareMessage(key, null);
+  }
+
+  public String prepareMessage(String key, Map<String, String> placeholders) {
+    String message = settings.getString("locales." + sc.config.getString("language") + "." + key);
+    if (message == null) message = sc.locale.getString(key);
+    if (message == null) return "";
+
+    if (placeholders != null) {
+      for (Iterator<String> i = placeholders.keySet().iterator(); i.hasNext();) {
+        String placeholder = i.next();
+        message = message.replace("{" + placeholder + "}", placeholders.get(placeholder));
+      }
+    }
+
+    return sc.formatMessage(message.replace("{prefix}", sc.locale.getString("prefix")));
   }
 
   // ----------------------------------------------------------------------------------------------
   // Actions methods
   // ----------------------------------------------------------------------------------------------
-  
+
   public TrackingActions getActionByName(String name) {
     for (TrackingActions action : TrackingActions.values())
       if (name.equalsIgnoreCase(getActionName(action))) return action;
@@ -45,16 +109,13 @@ public String getActionName(TrackingActions action) {
 
   public List<TrackingActions> getActionsAvailable(Player player, boolean keepUnavailable) {
     List<TrackingActions> list = new ArrayList<TrackingActions>();
-
     if (player.hasPermission("scompass.help")) list.add(TrackingActions.HELP);
-
     return list;
   }
 
   public boolean limitReached(Player player, TrackingActions action, boolean showError, Integer current) {
-    if (!sc.config.contains("tracker_settings.trackers." + trackerID() + ".limits." + action)) return false;
-
-    int limit = sc.config.getInt("tracker_settings.trackers." + trackerID() + ".limits." + action), count;
+    if (!settings.contains("settings.limits." + action)) return false;
+    int limit = settings.getInt("settings.limits." + action), count;
 
     if (current == null) {
       UUID uid = player.getUniqueId();
@@ -68,7 +129,7 @@ public boolean limitReached(Player player, TrackingActions action, boolean showE
 
     if (count < limit) return false;
 
-    if (showError) sc.sendMessage(player, "commands.sctrack.limits." + action,
+    if (showError) sendMessage(player, "commands.sctrack.limits." + action,
         ImmutableMap.of("limit", "" + limit, "tracker", trackerName()));
 
     return true;
@@ -78,20 +139,20 @@ public TargetSelector requireTarget(TrackingActions action) {
     switch (action) {
       case ADD:
         return TargetSelector.NEW;
-        
+
       case ASK:
       case DEL:
       case START:
         return TargetSelector.AVAILABLE;
-        
+
       case STOP:
         return TargetSelector.ACTIVE;
-        
-      default: 
+
+      default:
         return TargetSelector.NONE;
     }
   }
-  
+
   // ----------------------------------------------------------------------------------------------
   // Tracker methods
   // ----------------------------------------------------------------------------------------------
@@ -99,7 +160,7 @@ public TargetSelector requireTarget(TrackingActions action) {
   public abstract String trackerID();
 
   public String trackerName() {
-    return sc.locale.getString("trackers." + trackerID());
+    return settings.getString("locales." + sc.config.getString("language") + ".name");
   }
 
   // ----------------------------------------------------------------------------------------------
@@ -108,7 +169,6 @@ public String trackerName() {
 
   public boolean activate(Player player, String name, boolean showError) {
     if (limitReached(player, TrackingActions.START, showError, null)) return false;
-
     sc.targets.activateTarget(player, trackerID(), name);
     return true;
   }
@@ -158,13 +218,29 @@ public double[] get(Player player, String name) {
     return null;
   }
 
+  public double[] getCoords(Player player, String[] args) {
+    double[] coords = null;
+
+    if (args.length == 5)
+      try {
+        coords = new double[] { Double.parseDouble(args[3]), Double.parseDouble(args[4]) };
+      }
+      catch (Exception e) {}
+
+    if (coords == null) coords = new double[] { player.getLocation().getX(), player.getLocation().getZ() };
+
+    return coords;
+  }
+
   public List<String> list(Player player, TrackingActions action, String startWith) {
     if (action == null) return availableTargets(player, startWith);
 
     List<String> list = new ArrayList<String>();
 
     switch (action) {
+      case ACCEPT:
       case ADD:
+      case DENY:
         break;
 
       case ASK:
@@ -181,9 +257,17 @@ public List<String> list(Player player, TrackingActions action, String startWith
     return list;
   }
 
+  public List<String> listFiltered(Player player, List<String> list) {
+    if (player.hasPermission("scompass.track." + trackerID() + ".defined.*")) return list;
+
+    for (String name : list)
+      if (!player.hasPermission("scompass.track." + trackerID() + ".defined." + name)) list.remove(name);
+
+    return list;
+  }
+
   public boolean set(Player player, String name, double[] coords) {
     String key = key(player, name);
-
     if (datas().contains(key)) return false;
 
     String root    = key(player);
@@ -206,14 +290,12 @@ public boolean set(Player player, String name, double[] coords) {
 
   public List<String> commandSuggestions(Player player, String[] args, HashMap<String, Object> parsed) {
     List<String> list = new ArrayList<>();
-
     if (args.length < 1 || args.length > 3) return list;
 
     switch (args.length) {
       case 2:
         for (TrackingActions action : getActionsAvailable(player, false)) {
           String name = getActionName(action);
-
           if (name.toLowerCase().startsWith(args[1].toLowerCase())) list.add(name);
         }
         break;
@@ -227,37 +309,29 @@ public List<String> commandSuggestions(Player player, String[] args, HashMap<Str
   }
 
   public String help(Player player, String command) {
+    String sep  = prepareMessage("commands.sctrack.help.separator") + "\n";
+    String help = sep + prepareMessage("commands.sctrack.help.header", ImmutableMap.of("tracker", trackerName())) + sep;
+
     List<String> list = new ArrayList<String>();
-    String       help = "";
-
-    list.add("separator");
-    list.add("header");
-    list.add("separator");
-    list.add(trackerID() + ".noargs");
-    for (TrackingActions action : getActionsAvailable(player, true))
-      if (!action.equals(TrackingActions.HELP)) list.add(trackerID() + "." + action);
-    list.add("separator");
-
-    for (String key : list) {
-      String message = sc.locale.getString("commands.sctrack.help." + key)
-          .replace("{command}", command).replace("{" + trackerID() + "}", trackerName()) + "\n";
-      if (key.equals("header")) message = message.replace("{tracker}", trackerName());
-      for (TrackingActions action : TrackingActions.values())
-        message = message.replace("{" + action + "}", sc.locale.getString("actions." + action));
-
-      help += sc.formatMessage(message.replace("{prefix}", sc.locale.getString("prefix")));
+    list.add("noargs");
+
+    HashMap<String, String> placeholders = new HashMap<String, String>();
+    placeholders.put("command", command);
+    placeholders.put("tracker", trackerName());
+
+    for (TrackingActions action : getActionsAvailable(player, true)) if (!action.equals(TrackingActions.HELP)) {
+      list.add(action.toString());
+      placeholders.put(action.toString(), sc.locale.getString("actions." + action));
     }
 
-    return help;
+    for (String key : list) help += prepareMessage("help." + key, placeholders) + "\n";
+    return help + sep;
   }
 
   public void parseArguments(Player player, String[] args, HashMap<String, Object> parsed) {
     TrackingActions action = getActionByName(args[1]);
-
     if (action == null || !getActionsAvailable(player, false).contains(action)) return;
-
     parsed.put("action", action);
-
     if (args.length == 2) return;
     if (get(player, args[2]) != null) parsed.put("target", args[2]);
   }
@@ -282,7 +356,6 @@ public String key(Player player, String name) {
 
   public boolean save(String key, Object value) {
     datas().set(key, value);
-
     return sc.datas.saveUserDatas();
   }
 }
diff --git a/src/me/arboriginal/SimpleCompass/plugin/SimpleCompass.java b/src/me/arboriginal/SimpleCompass/plugin/SimpleCompass.java
index d567f2c..3cad3d4 100644
--- a/src/me/arboriginal/SimpleCompass/plugin/SimpleCompass.java
+++ b/src/me/arboriginal/SimpleCompass/plugin/SimpleCompass.java
@@ -1,8 +1,14 @@
 package me.arboriginal.SimpleCompass.plugin;
 
+import java.io.File;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
 import org.apache.commons.lang.time.DurationFormatUtils;
 import org.bukkit.ChatColor;
 import org.bukkit.command.Command;
@@ -10,7 +16,7 @@
 import org.bukkit.command.TabCompleter;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.plugin.java.JavaPlugin;
-import com.google.common.reflect.ClassPath;
+import com.google.common.collect.ImmutableMap;
 import me.arboriginal.SimpleCompass.commands.InterfaceCommand;
 import me.arboriginal.SimpleCompass.commands.OptionCommand;
 import me.arboriginal.SimpleCompass.commands.TrackCommand;
@@ -18,7 +24,6 @@
 import me.arboriginal.SimpleCompass.managers.DataManager;
 import me.arboriginal.SimpleCompass.managers.TargetManager;
 import me.arboriginal.SimpleCompass.managers.TaskManager;
-import me.arboriginal.SimpleCompass.trackers.AbstractTracker;
 import me.arboriginal.SimpleCompass.utils.CacheUtil;
 import me.arboriginal.SimpleCompass.utils.ConfigUtil;
 import me.arboriginal.SimpleCompass.utils.LangUtil;
@@ -95,7 +100,7 @@ public void reloadConfig() {
     isReady = false;
     config  = getConfig();
     config.options().copyDefaults(true);
-    locale = new LangUtil(this).get(config.getString("language"));
+    locale = new LangUtil(this).getLocale(config.getString("language"));
 
     for (ConfigUtil.ConfigError error : new ConfigUtil(this).validate(config))
       getLogger().warning(prepareMessage(error.errorKey, error.placeholders));
@@ -123,8 +128,15 @@ public void reloadConfig() {
   public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
     if (command.getName().toLowerCase().equals("scompass-reload")) {
       reloadConfig();
+      
+      for (String tracker : trackers.keySet()) {
+        if (!trackers.get(tracker).init()) {
+          trackers.remove(tracker);
+          sendMessage(sender, "tracker_disabled", ImmutableMap.of("tracker", tracker));
+        }
+      }
+      
       sendMessage(sender, "configuration_reloaded");
-
       return true;
     }
 
@@ -228,33 +240,62 @@ public TextComponent createClickableMessage(String text, Map<String, Map<String,
   // ----------------------------------------------------------------------------------------------
 
   private void loadTrackers() {
-    trackers = new HashMap<String, AbstractTracker>();
+    File dir = new File(getDataFolder(), "trackers");
+    if (!dir.exists()) dir.mkdirs();
 
-    try {
-      for (ClassPath.ClassInfo classInfo : ClassPath.from(getClassLoader())
-          .getTopLevelClasses(AbstractTracker.class.getPackage().getName())) {
-        if (classInfo.getSimpleName().equals("AbstractTracker")) continue;
+    if (!dir.exists() || !dir.isDirectory()) {
+      getLogger().severe("Unable to create trackers folder...");
+      return;
+    }
 
-        Object tracker = Class.forName(classInfo.getName()).getConstructor(this.getClass()).newInstance(this);
+    trackers = new HashMap<String, AbstractTracker>();
+    for (final File file : dir.listFiles()) {
+      if (file.isDirectory() || !file.getName().endsWith(".jar")) continue;
+
+      try {
+        String         path   = file.getAbsolutePath();
+        JarFile        jar    = new JarFile(path);
+        URLClassLoader loader = new URLClassLoader(
+            new URL[] { new URL("jar:file://" + path + "!/") },
+            getClassLoader());
+
+        Enumeration<JarEntry> entries = jar.entries();
+        while (entries.hasMoreElements()) {
+          JarEntry entry = entries.nextElement();
+          if (entry.isDirectory() || !entry.getName().endsWith(".class")) continue;
+
+          String className = entry.getName().substring(0, entry.getName().length() - 6).replace('/', '.');
+          Object tracker   = null;
+
+          try {
+            tracker = Class.forName(className, true, loader).getConstructor(this.getClass()).newInstance(this);
+          }
+          catch (NoClassDefFoundError e) {}
 
-        if (tracker instanceof AbstractTracker) {
+          if (tracker == null || !(tracker instanceof AbstractTracker)) continue;
           String trackerID = ((AbstractTracker) tracker).trackerID();
 
           if (trackers.containsKey(trackerID)) {
             getLogger().warning(
                 "Tracker {tracker} is using the ID {id} which is already used by {other}, can't load it..."
-                    .replace("{tracker}", classInfo.getSimpleName()).replace("id", trackerID)
+                    .replace("{tracker}", file.getName()).replace("id", trackerID)
                     .replace("{other}", trackers.get(trackerID).getClass().getSimpleName()));
             continue;
           }
 
-          trackers.put(trackerID, (AbstractTracker) tracker);
-          getLogger().info("Tracker {tracker} successfully loaded".replace("{tracker}", classInfo.getSimpleName()));
+          if (((AbstractTracker) tracker).init()) {
+            trackers.put(trackerID, (AbstractTracker) tracker);
+            getLogger().info("Tracker §6{tracker}§r successfully loaded".replace("{tracker}", file.getName()));
+          }
+          else
+            throw new Exception();
         }
+
+        jar.close();
+      }
+      catch (Exception e) {
+        getLogger().severe("Error loading tracker " + file.getName() + "...");
       }
-    }
-    catch (Exception e) {
-      getLogger().severe("Error loading trackers...");
     }
   }
 }
diff --git a/src/me/arboriginal/SimpleCompass/trackers/CoordsTracker.java b/src/me/arboriginal/SimpleCompass/trackers/CoordsTracker.java
deleted file mode 100644
index 542f0d6..0000000
--- a/src/me/arboriginal/SimpleCompass/trackers/CoordsTracker.java
+++ /dev/null
@@ -1,119 +0,0 @@
-package me.arboriginal.SimpleCompass.trackers;
-
-import java.util.List;
-import org.bukkit.entity.Player;
-import com.google.common.collect.ImmutableMap;
-import me.arboriginal.SimpleCompass.plugin.SimpleCompass;
-
-public class CoordsTracker extends AbstractTracker {
-  // ----------------------------------------------------------------------------------------------
-  // Constructor methods
-  // ----------------------------------------------------------------------------------------------
-
-  public CoordsTracker(SimpleCompass plugin) {
-    super(plugin);
-  }
-
-  //----------------------------------------------------------------------------------------------
-  // Actions methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public List<TrackingActions> getActionsAvailable(Player player, boolean keepUnavailable) {
-    List<TrackingActions> list = super.getActionsAvailable(player, keepUnavailable);
-
-    list.add(TrackingActions.ADD);
-
-    if (keepUnavailable || !list(player, null, "").isEmpty()) {
-      list.add(TrackingActions.DEL);
-      list.add(TrackingActions.START);
-      list.add(TrackingActions.STOP);
-    }
-
-    return list;
-  }
-
-  public TargetSelector requireTarget(TrackingActions action) {
-    return action.equals(TrackingActions.ADD) ? TargetSelector.NEWCOORDS : super.requireTarget(action);
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Tracker methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public String trackerID() {
-    return "COORDS";
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Command methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public boolean perform(Player player, String command, TrackingActions action, String target, String[] args) {
-    if (target == null && !action.equals(TrackingActions.ADD)) {
-      sc.sendMessage(player, "missing_target");
-      return true;
-    }
-
-    switch (action) {
-      case ADD:
-        if (args.length < 3)
-          sc.sendMessage(player, "missing_target");
-        else if (set(player, args[2], getCoords(player, args))) {
-          player.sendMessage(sc.prepareMessage("commands." + command + "." + trackerID() + ".ADD",
-              ImmutableMap.of("target", args[2])));
-
-          if (sc.config.getBoolean("tracker_settings.trackers." + trackerID() + ".auto_activated"))
-            activate(player, args[2], false);
-        }
-        else
-          player.sendMessage(sc.prepareMessage("target_exists", ImmutableMap.of("target", args[2])));
-        break;
-
-      case DEL:
-        player.sendMessage(sc.prepareMessage(del(player, args[2])
-            ? "commands.sctrack." + trackerID() + ".DEL"
-            : "target_not_found",
-            ImmutableMap.of("target", args[2])));
-        break;
-
-      case START:
-        if (!activate(player, args[2], true)) break;
-
-        sc.sendMessage(player, "commands." + command + "." + trackerID() + ".START",
-            ImmutableMap.of("target", args[2]));
-        break;
-
-      case STOP:
-        disable(player, args[2]);
-        sc.sendMessage(player, "commands." + command + "." + trackerID() + ".STOP",
-            ImmutableMap.of("target", args[2]));
-        break;
-
-      default:
-        return false;
-    }
-
-    return true;
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Specific methods
-  // ----------------------------------------------------------------------------------------------
-
-  private double[] getCoords(Player player, String[] args) {
-    double[] coords = null;
-
-    if (args.length == 5)
-      try {
-        coords = new double[] { Double.parseDouble(args[3]), Double.parseDouble(args[4]) };
-      }
-      catch (Exception e) {}
-
-    if (coords == null) coords = new double[] { player.getLocation().getX(), player.getLocation().getZ() };
-
-    return coords;
-  }
-}
diff --git a/src/me/arboriginal/SimpleCompass/trackers/DeathPosTracker.java b/src/me/arboriginal/SimpleCompass/trackers/DeathPosTracker.java
deleted file mode 100644
index 78f962f..0000000
--- a/src/me/arboriginal/SimpleCompass/trackers/DeathPosTracker.java
+++ /dev/null
@@ -1,168 +0,0 @@
-package me.arboriginal.SimpleCompass.trackers;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.entity.PlayerDeathEvent;
-import com.google.common.collect.ImmutableMap;
-import me.arboriginal.SimpleCompass.plugin.SimpleCompass;
-import me.arboriginal.SimpleCompass.utils.CacheUtil;
-
-public class DeathPosTracker extends AbstractTracker implements Listener {
-  // ----------------------------------------------------------------------------------------------
-  // Constructor methods
-  // ----------------------------------------------------------------------------------------------
-
-  public DeathPosTracker(SimpleCompass plugin) {
-    super(plugin);
-
-    sc.getServer().getPluginManager().registerEvents(this, sc);
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Listener methods
-  // ----------------------------------------------------------------------------------------------
-
-  @EventHandler
-  public void onPlayerDeath(PlayerDeathEvent event) {
-    Player   player = event.getEntity();
-    double[] coords = new double[] { player.getLocation().getX(), player.getLocation().getZ() };
-    long     target = CacheUtil.now() + sc.config.getInt("delays.death_position") * 1000;
-
-    if (set(player, "" + target, coords)
-        && sc.config.getBoolean("tracker_settings.trackers." + trackerID() + ".auto_activated"))
-      activate(player, "" + target, false);
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Actions methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public List<TrackingActions> getActionsAvailable(Player player, boolean keepUnavailable) {
-    List<TrackingActions> list = super.getActionsAvailable(player, keepUnavailable);
-
-    if (keepUnavailable || lastDeath(player) != null) {
-      list.add(TrackingActions.START);
-      list.add(TrackingActions.STOP);
-    }
-
-    return list;
-  }
-
-  @Override
-  public TargetSelector requireTarget(TrackingActions action) {
-    if (action.equals(TrackingActions.START) || action.equals(TrackingActions.STOP)) 
-      return TargetSelector.NONE;
-    
-    return super.requireTarget(action);
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Tracker methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public String trackerID() {
-    return "DEATH_POSITION";
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Targets methods
-  // ----------------------------------------------------------------------------------------------
-
-  public double[] get(Player player, String name) {
-    double[] coords = super.get(player, name);
-
-    if (coords != null)
-      try {
-        long until = Long.parseLong(name);
-
-        if (CacheUtil.now() > until) return null;
-      }
-      catch (Exception e) {
-        return null;
-      }
-
-    return coords;
-  }
-
-  @Override
-  public List<String> list(Player player, TrackingActions action, String startWith) {
-    List<String> list = new ArrayList<String>();
-
-    for (String name : super.list(player, action, startWith)) {
-      double[] coords = get(player, name);
-
-      if (coords != null) list.add(sc.formatMessage(
-          sc.locale.getString("commands.sctrack." + trackerID() + ".list_coord")
-              .replace("{x}", "" + (int) coords[0]).replace("{z}", "" + (int) coords[1])));
-    }
-
-    return list;
-  }
-
-  public boolean set(Player player, String name, double[] coords) {
-    if (super.set(player, name, coords)) {
-      List<String> list = sc.datas.activeTargetsList(player, trackerID());
-
-      if (!list.isEmpty()) list.forEach(target -> {
-        if (!target.equals(name)) del(player, target);
-      });
-
-      return true;
-    }
-
-    return false;
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Command methods
-  // ----------------------------------------------------------------------------------------------
-
-  public List<String> commandSuggestions(Player player, String[] args, HashMap<String, Object> parsed) {
-    return super.commandSuggestions(player, args, parsed);
-  }
-
-  @Override
-  public boolean perform(Player player, String command, TrackingActions action, String target, String[] args) {
-    if (args.length != 2 || target != null) return false;
-
-    target = lastDeath(player);
-
-    if (target == null) {
-      sc.sendMessage(player, "target_not_found", ImmutableMap.of("target", trackerID()));
-      return true;
-    }
-
-    switch (action) {
-      case START:
-        activate(player, target, false);
-        sc.sendMessage(player, "commands." + command + "." + trackerID() + ".START");
-        break;
-
-      case STOP:
-        disable(player, target);
-        sc.sendMessage(player, "commands." + command + "." + trackerID() + ".STOP");
-        break;
-
-      default:
-        return false;
-    }
-
-    return true;
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Specific methods
-  // ----------------------------------------------------------------------------------------------
-
-  private String lastDeath(Player player) {
-    for (String name : super.list(player, null, "")) if (get(player, name) != null) return name;
-
-    return null;
-  }
-}
diff --git a/src/me/arboriginal/SimpleCompass/trackers/PlayerTracker.java b/src/me/arboriginal/SimpleCompass/trackers/PlayerTracker.java
deleted file mode 100644
index 2a119b2..0000000
--- a/src/me/arboriginal/SimpleCompass/trackers/PlayerTracker.java
+++ /dev/null
@@ -1,351 +0,0 @@
-package me.arboriginal.SimpleCompass.trackers;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.TabCompleter;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerQuitEvent;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import me.arboriginal.SimpleCompass.plugin.SimpleCompass;
-import me.arboriginal.SimpleCompass.utils.CacheUtil;
-
-public class PlayerTracker extends AbstractTracker implements CommandExecutor, Listener, TabCompleter {
-  private HashMap<UUID, HashMap<UUID, Long>> requests;
-
-  // ----------------------------------------------------------------------------------------------
-  // Constructor methods
-  // ----------------------------------------------------------------------------------------------
-
-  public PlayerTracker(SimpleCompass plugin) {
-    super(plugin);
-
-    requests = new HashMap<UUID, HashMap<UUID, Long>>();
-
-    sc.getCommand("scompass-track-accept").setExecutor(this);
-    sc.getCommand("scompass-track-deny").setExecutor(this);
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Listener methods
-  // ----------------------------------------------------------------------------------------------
-
-  @EventHandler
-  public void onPlayerQuit(PlayerQuitEvent event) {
-    cleanPlayerTrackerRequests(event.getPlayer(), true);
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Actions methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public List<TrackingActions> getActionsAvailable(Player player, boolean keepUnavailable) {
-    List<TrackingActions> list = super.getActionsAvailable(player, keepUnavailable);
-
-    if (player.hasPermission("scompass.track." + trackerID() + ".request"))
-      list.add(TrackingActions.ASK);
-
-    if (player.hasPermission("scompass.track." + trackerID() + ".silently")
-        && !availableTargets(player, "").isEmpty())
-      list.add(TrackingActions.START);
-
-    if (!list(player, null, "").isEmpty()) list.add(TrackingActions.STOP);
-
-    return list;
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Tracker methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public String trackerID() {
-    return "PLAYER";
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Targets methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public List<String> availableTargets(Player player, String startWith) {
-    List<String> list = new ArrayList<String>();
-
-    sc.getServer().getOnlinePlayers().forEach(candidate -> {
-      String name = candidate.getName();
-      if (!name.equals(player.getName()))
-        if (startWith.isEmpty() || name.toLowerCase().startsWith(startWith.toLowerCase())) list.add(name);
-    });
-
-    return list;
-  }
-
-  @Override
-  public boolean del(Player player, String name) {
-    return false;
-  }
-
-  @Override
-  public double[] get(Player player, String name) {
-    for (Player target : sc.getServer().getOnlinePlayers())
-      if (target.getName().equalsIgnoreCase(name))
-        return new double[] { target.getLocation().getX(), target.getLocation().getZ() };
-
-    return null;
-  }
-
-  @Override
-  public List<String> list(Player player, TrackingActions action, String startWith) {
-    if (action == null) return activeTargets(player, startWith);
-
-    if (action.equals(TrackingActions.STOP)) {
-      List<String> list = new ArrayList<String>();
-
-      for (OfflinePlayer candidate : sc.getServer().getOfflinePlayers()) {
-        String name = candidate.getName();
-        if (!name.equals(player.getName()))
-          if (startWith.isEmpty() || name.toLowerCase().startsWith(startWith.toLowerCase())) list.add(name);
-      }
-
-      return list;
-    }
-
-    return super.list(player, action, startWith);
-  }
-
-  @Override
-  public boolean set(Player player, String name, double[] coords) {
-    return false;
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Command methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public List<String> commandSuggestions(Player player, String[] args, HashMap<String, Object> parsed) {
-    if (args.length == 3 && parsed.get("action") != null && !parsed.get("action").equals(TrackingActions.STOP))
-      return availableTargets(player, args[2]);
-
-    return super.commandSuggestions(player, args, parsed);
-  }
-
-  @Override
-  public void parseArguments(Player player, String[] args, HashMap<String, Object> parsed) {
-    super.parseArguments(player, args, parsed);
-
-    if (parsed.get("target") != null || parsed.get("action") == null
-        || parsed.get("action").equals(TrackingActions.STOP) || args.length < 3)
-      return;
-
-    for (OfflinePlayer candidate : sc.getServer().getOfflinePlayers())
-      if (candidate.getName().equalsIgnoreCase(args[2])) {
-        parsed.put("target", candidate.getName());
-        return;
-      }
-  }
-
-  @Override
-  public boolean perform(Player player, String command, TrackingActions action, String target, String[] args) {
-    if (target == null) {
-      sc.sendMessage(player, "missing_target");
-      return true;
-    }
-
-    switch (action) {
-      case ASK:
-        if (limitReached(player, TrackingActions.START, true, null)) break;
-
-        Player targetPlayer = sc.getServer().getPlayer(target);
-        if (targetPlayer == null)
-          sc.sendMessage(player, "target_not_found", ImmutableMap.of("target", target));
-        else {
-          sendPlayerTrackerRequest(player, targetPlayer);
-          sc.sendMessage(player, "commands." + command + "." + trackerID() + ".ASK",
-              ImmutableMap.of("target", target));
-        }
-        break;
-
-      case START:
-        if (!activate(player, args[2], true)) break;
-        sc.sendMessage(player, "commands." + command + "." + trackerID() + ".START",
-            ImmutableMap.of("target", args[2]));
-        break;
-
-      case STOP:
-        disable(player, args[2]);
-        sc.sendMessage(player, "commands." + command + "." + trackerID() + ".STOP",
-            ImmutableMap.of("target", target));
-        break;
-
-      default:
-        return false;
-    }
-
-    return true;
-  }
-
-  @Override
-  public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-    String cmd = command.getName().toLowerCase();
-
-    switch (cmd) {
-      case "scompass-track-accept":
-      case "scompass-track-deny":
-        if (!(sender instanceof Player) || args.length != 1) return false;
-        return respondPlayerTrackerRequest((Player) sender, args[0], (cmd.equals("scompass-track-accept")));
-    }
-
-    return false;
-  }
-
-  //----------------------------------------------------------------------------------------------
-  // TabCompleter methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
-    switch (command.getName().toLowerCase()) {
-      case "sctaccept":
-      case "sctdeny":
-        if (!(sender instanceof Player) || args.length != 1) return null;
-
-        Set<UUID> candidates = getPlayerTrackerRequests((Player) sender);
-
-        if (candidates == null) return null;
-
-        List<String> list = new ArrayList<String>();
-
-        for (UUID uid : candidates) {
-          Player candidate = sc.getServer().getPlayer(uid);
-
-          if (candidate != null && candidate.getName().toLowerCase().startsWith(args[0].toLowerCase()))
-            list.add(candidate.getName());
-        }
-
-        return list;
-
-      default:
-        return null;
-    }
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Specific methods
-  // ----------------------------------------------------------------------------------------------
-
-  public void cleanPlayerTrackerRequests(Player player) {
-    cleanPlayerTrackerRequests(player, false);
-  }
-
-  public void cleanPlayerTrackerRequests(Player player, boolean delete) {
-    UUID uid = player.getUniqueId();
-
-    if (!requests.containsKey(uid)) return;
-    if (delete)
-      requests.remove(uid);
-    else {
-      requests.get(uid).forEach((seeker, until) -> {
-        if (CacheUtil.now() > until) requests.get(uid).remove(seeker);
-      });
-    }
-  }
-
-  public Set<UUID> getPlayerTrackerRequests(Player player) {
-    UUID uid = player.getUniqueId();
-
-    return requests.containsKey(uid) ? requests.get(uid).keySet() : null;
-  }
-
-  public long getPlayerTrackerRequest(Player player, Player seeker) {
-    UUID pUid = player.getUniqueId(), sUid = seeker.getUniqueId();
-
-    cleanPlayerTrackerRequests(player);
-
-    if (requests.containsKey(pUid) && requests.get(pUid).containsKey(sUid)) return requests.get(pUid).get(sUid);
-
-    return 0;
-  }
-
-  public void removePlayerTrackerRequest(Player player, Player seeker) {
-    UUID pUid = player.getUniqueId(), sUid = seeker.getUniqueId();
-
-    if (requests.containsKey(pUid) && requests.get(pUid).containsKey(sUid)) requests.get(pUid).remove(sUid);
-  }
-
-  public boolean respondPlayerTrackerRequest(Player player, String seekerName, boolean accept) {
-    Player seeker = sc.getServer().getPlayer(seekerName);
-
-    if (seeker == null || !seeker.isOnline()) return true;
-
-    Long request = getPlayerTrackerRequest(player, seeker);
-
-    if (request == 0) {
-      sc.sendMessage(player, "request_expired", ImmutableMap.of("player", seekerName));
-      return true;
-    }
-
-    removePlayerTrackerRequest(player, seeker);
-
-    ImmutableMap<String, String> placeholders = ImmutableMap.of("player", seekerName, "target", player.getName());
-
-    if (accept) {
-      String[] keys = {
-          "commands.sctrack." + trackerID() + ".request.accepted.target",
-          "commands.sctrack." + trackerID() + ".request.accepted.player" };
-
-      if (!activate(seeker, player.getName(), false))
-        for (int i = 0; i < keys.length; i++) keys[i] += "_limit_reached";
-
-      sc.sendMessage(player, keys[0], placeholders);
-      sc.sendMessage(seeker, keys[1], placeholders);
-    }
-    else {
-      sc.sendMessage(player, "commands.sctrack." + trackerID() + ".request.refused.target", placeholders);
-      sc.sendMessage(seeker, "commands.sctrack." + trackerID() + ".request.refused.player", placeholders);
-    }
-
-    return true;
-  }
-
-  public void sendPlayerTrackerRequest(Player hunter, Player target) {
-    Map<String, Map<String, String>> commands = new HashMap<String, Map<String, String>>();
-
-    for (String action : ImmutableList.of("accept", "deny")) {
-      commands.put("{" + action + "}", ImmutableMap.of(
-          "text", sc.prepareMessage("commands.sctrack." + trackerID() + ".request." + action),
-          "click", "/sct" + action + " " + hunter.getName(),
-          "hover", sc.prepareMessage("commands.sctrack." + trackerID() + ".request." + action + "_hover",
-              ImmutableMap.of("player", hunter.getName()))));
-    }
-
-    setPlayerTrackerRequest(hunter, target);
-
-    target.spigot().sendMessage(sc.createClickableMessage(sc.prepareMessage(
-        "commands.sctrack." + trackerID() + ".request.message", ImmutableMap.of("player", hunter.getName())),
-        commands));
-  }
-
-  public void setPlayerTrackerRequest(Player hunter, Player target) {
-    UUID hUid = hunter.getUniqueId(), tUid = target.getUniqueId();
-
-    if (!requests.containsKey(tUid))
-      requests.put(tUid, new HashMap<UUID, Long>());
-    else
-      cleanPlayerTrackerRequests(target);
-
-    requests.get(tUid).put(hUid,
-        CacheUtil.now() + sc.config.getInt("tracker_settings.request_duration") * 1000);
-  }
-}
diff --git a/src/me/arboriginal/SimpleCompass/trackers/PositionTracker.java b/src/me/arboriginal/SimpleCompass/trackers/PositionTracker.java
deleted file mode 100644
index 1345959..0000000
--- a/src/me/arboriginal/SimpleCompass/trackers/PositionTracker.java
+++ /dev/null
@@ -1,189 +0,0 @@
-package me.arboriginal.SimpleCompass.trackers;
-
-import java.util.ArrayList;
-import java.util.List;
-import org.bukkit.configuration.MemorySection;
-import org.bukkit.entity.Player;
-import com.google.common.collect.ImmutableMap;
-import me.arboriginal.SimpleCompass.plugin.SimpleCompass;
-
-public class PositionTracker extends AbstractTracker {
-  // ----------------------------------------------------------------------------------------------
-  // Constructor methods
-  // ----------------------------------------------------------------------------------------------
-
-  public PositionTracker(SimpleCompass plugin) {
-    super(plugin);
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Actions methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public List<TrackingActions> getActionsAvailable(Player player, boolean keepUnavailable) {
-    List<TrackingActions> list = super.getActionsAvailable(player, keepUnavailable);
-
-    if (player.hasPermission("scompass.track." + trackerID() + ".manage")) {
-      list.add(TrackingActions.ADD);
-      list.add(TrackingActions.DEL);
-    }
-
-    if (keepUnavailable || !sc.config.getConfigurationSection("positions").getKeys(false).isEmpty()) {
-      list.add(TrackingActions.START);
-      list.add(TrackingActions.STOP);
-    }
-
-    return list;
-  }
-
-  public TargetSelector requireTarget(TrackingActions action) {
-    return action.equals(TrackingActions.ADD) ? TargetSelector.NEWCOORDS : super.requireTarget(action);
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Tracker methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public String trackerID() {
-    return "POSITION";
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Targets methods
-  // ----------------------------------------------------------------------------------------------
-
-  public List<String> availableTargets(Player player, String startWith) {
-    List<String> list = new ArrayList<String>();
-
-    datas().getKeys(false).forEach(candidate -> {
-      if (startWith.isEmpty() || candidate.toLowerCase().startsWith(startWith.toLowerCase())) list.add(candidate);
-    });
-
-    return filterByPermission(player, list);
-  }
-
-  @Override
-  public List<String> list(Player player, TrackingActions action, String startWith) {
-    return filterByPermission(player, super.list(player, action, startWith));
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Command methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public boolean perform(Player player, String command, TrackingActions action, String target, String[] args) {
-    if (target == null && !action.equals(TrackingActions.ADD)) return false;
-
-    switch (action) {
-      case ADD:
-        if (args.length < 3)
-          sc.sendMessage(player, "missing_target");
-        else if (set(player, args[2], getCoords(player, args))) {
-          player.sendMessage(sc.prepareMessage("commands." + command + "." + trackerID() + ".ADD",
-              ImmutableMap.of("target", args[2])));
-
-          if (sc.config.getBoolean("tracker_settings.trackers." + trackerID() + ".auto_activated"))
-            activate(player, args[2], false);
-        }
-        else
-          player.sendMessage(sc.prepareMessage("target_exists", ImmutableMap.of("target", args[2])));
-        break;
-
-      case DEL:
-        player.sendMessage(sc.prepareMessage(del(player, args[2])
-            ? "commands." + command + "." + trackerID() + ".DEL"
-            : "target_not_found",
-            ImmutableMap.of("target", args[2])));
-        break;
-
-      case START:
-        if (!activate(player, args[2], true)) break;
-
-        sc.sendMessage(player, "commands." + command + "." + trackerID() + ".START",
-            ImmutableMap.of("target", args[2]));
-        break;
-
-      case STOP:
-        disable(player, args[2]);
-
-        sc.sendMessage(player, "commands." + command + "." + trackerID() + ".STOP",
-            ImmutableMap.of("target", args[2]));
-        break;
-
-      default:
-        return false;
-    }
-
-    return true;
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Targets methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public boolean set(Player player, String name, double[] coords) {
-    String key = key(player, name);
-
-    if (datas().contains(key)) return false;
-    if (limitReached(player, TrackingActions.ADD, true, datas().getKeys(false).size())) return false;
-
-    boolean success = (save(key + ".x", coords[0]) && save(key + ".z", coords[1]));
-    if (success) return true;
-
-    save(key, null);
-    return false;
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Storage methods
-  // ----------------------------------------------------------------------------------------------
-
-  @Override
-  public MemorySection datas() {
-    return (MemorySection) sc.config.getConfigurationSection("positions");
-  }
-
-  @Override
-  public String key(Player player, String name) {
-    return (name == null ? "" : name.toLowerCase());
-  }
-
-  @Override
-  public boolean save(String key, Object value) {
-    if (key.isEmpty()) return false;
-    datas().set(key, value);
-    return true;
-  }
-
-  // ----------------------------------------------------------------------------------------------
-  // Specific methods
-  // ----------------------------------------------------------------------------------------------
-
-  private List<String> filterByPermission(Player player, List<String> list) {
-    if (player.hasPermission("scompass.track.POSITION.defined.*")) return list;
-
-    for (String name : list)
-      if (!player.hasPermission("scompass.track.POSITION.defined." + name)) list.remove(name);
-
-    return list;
-  }
-
-  private double[] getCoords(Player player, String[] args) {
-    double[] coords = null;
-
-    if (args.length == 5)
-      try {
-        coords = new double[] { Double.parseDouble(args[3]), Double.parseDouble(args[4]) };
-      }
-      catch (Exception e) {}
-
-    if (coords == null)
-      coords = new double[] { player.getLocation().getX(), player.getLocation().getZ() };
-
-    return coords;
-  }
-}
diff --git a/src/me/arboriginal/SimpleCompass/utils/ConfigUtil.java b/src/me/arboriginal/SimpleCompass/utils/ConfigUtil.java
index 698d76a..cafb9a9 100644
--- a/src/me/arboriginal/SimpleCompass/utils/ConfigUtil.java
+++ b/src/me/arboriginal/SimpleCompass/utils/ConfigUtil.java
@@ -18,8 +18,8 @@
 import me.arboriginal.SimpleCompass.compasses.AbstractCompass.CompassModes;
 import me.arboriginal.SimpleCompass.compasses.AbstractCompass.CompassTypes;
 import me.arboriginal.SimpleCompass.managers.CompassManager.RequirementsSections;
+import me.arboriginal.SimpleCompass.plugin.AbstractTracker.TrackingActions;
 import me.arboriginal.SimpleCompass.plugin.SimpleCompass;
-import me.arboriginal.SimpleCompass.trackers.AbstractTracker.TrackingActions;
 
 public class ConfigUtil {
   private List<ConfigError> errors;
@@ -43,7 +43,6 @@ public List<ConfigError> validate(FileConfiguration configuration) {
     List<String> modified = new ArrayList<String>();
 
     modified.addAll(validateCustomNames(TrackingActions.values(), "actions"));
-    modified.addAll(validateCustomNames(sc.trackers.keySet().toArray(), "trackers"));
     modified.addAll(validateCustomNames(SubCmds.values(), "subcommands"));
 
     if (!modified.isEmpty())
@@ -223,15 +222,21 @@ private List<String> validateRequiredItems(CompassTypes type, RequirementsSectio
   }
 
   private void validateTrackerSettings() {
-    List<String> priorities = new ArrayList<String>();
+    List<String> userPriorities = sc.config.getStringList("trackers_priorities");
+    List<String> readPriorities = new ArrayList<String>();
 
-    for (String priority : sc.config.getStringList("tracker_settings.priority"))
-      if (!priorities.contains(priority)) priorities.add(priority);
+    for (String priority : sc.config.getStringList("trackers_priorities")) { // @formatter:off
+      if (!sc.trackers.containsKey(priority)) userPriorities.remove(priority);
+      else if (!readPriorities.contains(priority)) readPriorities.add(priority);
+    } // @formatter:on
 
-    if (priorities.size() != sc.trackers.size()) {
-      fixValue("tracker_settings.priority");
+    if (readPriorities.size() != sc.trackers.size()) {
+      fixValue("trackers_priorities");
       addError("invalid_priorities");
     }
+
+    for (String tracker : sc.trackers.keySet()) if (!userPriorities.contains(tracker)) userPriorities.add(tracker);
+    fixValue("trackers_priorities", userPriorities);
   }
 
   // ----------------------------------------------------------------------------------------------
diff --git a/src/me/arboriginal/SimpleCompass/utils/LangUtil.java b/src/me/arboriginal/SimpleCompass/utils/LangUtil.java
index 266d32e..7eb7a14 100644
--- a/src/me/arboriginal/SimpleCompass/utils/LangUtil.java
+++ b/src/me/arboriginal/SimpleCompass/utils/LangUtil.java
@@ -20,12 +20,29 @@ public class LangUtil {
   public LangUtil(SimpleCompass plugin) {
     sc = plugin;
   }
+  
+  // ----------------------------------------------------------------------------------------------
+  // Public static methods
+  // ----------------------------------------------------------------------------------------------
+
+  public static void writeResourceToFile(InputStream in, File file) throws Exception {
+    file.getParentFile().mkdirs();
+
+    OutputStream out = new FileOutputStream(file);
+    byte[]       buf = new byte[1024];
+    int          len;
+
+    while ((len = in.read(buf)) > 0) out.write(buf, 0, len);
 
+    out.close();
+    in.close();
+  }
+  
   // ----------------------------------------------------------------------------------------------
   // Public methods
   // ----------------------------------------------------------------------------------------------
 
-  public FileConfiguration get(String language) {
+  public FileConfiguration getLocale(String language) {
     FileConfiguration locale;
     boolean           newFile;
 
@@ -98,16 +115,6 @@ private void saveConfigToFile(FileConfiguration config, File file, String defaul
   }
 
   private void writeResourceToFile(String resource, File file) throws Exception {
-    file.getParentFile().mkdirs();
-
-    InputStream  in  = sc.getResource(resource);
-    OutputStream out = new FileOutputStream(file);
-    byte[]       buf = new byte[1024];
-    int          len;
-
-    while ((len = in.read(buf)) > 0) out.write(buf, 0, len);
-
-    out.close();
-    in.close();
+    writeResourceToFile(sc.getResource(resource), file);
   }
 }
diff --git a/src/plugin.yml b/src/plugin.yml
index c35ee53..ebd6dfd 100644
--- a/src/plugin.yml
+++ b/src/plugin.yml
@@ -1,6 +1,6 @@
 name: SimpleCompass
 description: Simple compass to help player who don't have sense of direction.
-version: 0.6
+version: 0.7
 
 author: arboriginal
 website: https://www.spigotmc.org/resources/simplecompass.63140/
@@ -38,18 +38,6 @@ commands:
     usage: /<command> <tracker> <action> <target> [<x> <z>]
     aliases: sctrack
 
-  scompass-track-accept: # Only available if tracker PlayerTracker is active
-    description: Accept a tracking request
-    permission: scompass.track.accept
-    usage: /<command> <player>
-    aliases: sctaccept
-
-  scompass-track-deny: # Only available if tracker PlayerTracker is active
-    description: Deny a tracking request
-    permission: scompass.track.accept
-    usage: /<command> <player>
-    aliases: sctdeny
-
 permissions:
   scompass.reload:
     description: Allows to reload the configuration.
@@ -136,88 +124,12 @@ permissions:
     description: Allows to use the option "Disabled".
     default: true
 
-  scompass.track.*: # Require scompass.use
-    description: Allows to use all the trackers.
-    default: op
-    children:
-      scompass.track: true
-      scompass.track.accept: true
-      scompass.track.COORDS: true
-      scompass.track.DEATH_POSITION: true
-      scompass.track.PLAYER.*: true
-      scompass.track.POSITION.*: true
-
   scompass.track: # Require scompass.use
     description: Allows the use of scompass-track command.
-    default: false
-
-#################################################
-# Permission relative to tracker CoordsTracker
-#################################################
-
-  scompass.track.COORDS: # Require scompass.track
-    description: Allows to use the tracker with given coords.
-    default: false
-
-#################################################
-# Permission relative to tracker DeathPosTracker
-#################################################
-
-  scompass.track.DEATH_POSITION: # Require scompass.track
-    description: Allows to use the tracker to the last death location.
-    default: true
-
-#################################################
-# Permission relative to tracker PlayerTracker
-#################################################
-
-  scompass.track.accept:
-    description: Allows to accept tracking request.
-    default: true
-
-  scompass.track.PLAYER.*: # Require scompass.track
-    description: Allows to use the tracker on players.
-    default: op
-    children:
-      scompass.track.PLAYER: true
-      scompass.track.PLAYER.request: true
-      scompass.track.PLAYER.silently: true
-
-  scompass.track.PLAYER: # Require scompass.track
-    description: Allows to use the tracker on players.
-    default: false
-
-  scompass.track.PLAYER.request: # Require scompass.track.player
-    description: Allows to use the tracker on players, with their agreement.
     default: true
 
-  scompass.track.PLAYER.silently: # Require scompass.track.player
-    description: Allows to use the tracker on players, without asking.
-    default: true
-
-#################################################
-# Permission relative to tracker PositionTracker
-#################################################
-
-# All named positions in config.yml use a dynamic permission: scompass.track.POSITION.defined.<name>
-# This permission can be omitted if you give the permission scompass.track.POSITION.defined.* to your players
-
-  scompass.track.POSITION.*: # Require scompass.track
-    description: Allows to use the tracker with defined positions and manage them.
-    default: op
-    children:
-      scompass.track.POSITION: true
-      scompass.track.POSITION.defined.*: true
-      scompass.track.POSITION.manage: true
-
-  scompass.track.POSITION: # Require scompass.track
-    description: Allows to use the tracker with defined positions.
-    default: true
-
-  scompass.track.POSITION.defined.*: # Require scompass.track
-    description: Allows to use track all defined positions.
-    default: false
-
-  scompass.track.POSITION.manage: # Require scompass.track
-    description: Allows to manage defined positions.
+  scompass.track.*: # Require scompass.use
+    description: Allows the use of all installed trackers.
     default: false
+    # Note: To give the permission to use the tracker "foo", give permission "scompass.track.foo"
+    # see trackers addon's README.md files on their github pages for more info.