diff --git a/README.md b/README.md
index f2a53cf..7e455b0 100644
--- a/README.md
+++ b/README.md
@@ -6,36 +6,46 @@
 [![CodeFactor](https://www.codefactor.io/repository/github/dev7ex/multiworld/badge)](https://www.codefactor.io/repository/github/dev7ex/multiworld)
 
 ## What is MultiWorld?
+
 MultiWorld is a World Management plugin for Minecraft Server.
 
 * Almost 100% configurable
 * Pvp is adjustable for each world
 * GameMode per World - if you change the world your gamemode change also! (can be deactivated)
+* Link Worlds with each other
+* Whitelist per World
 
 ## Links
+
 * https://www.spigotmc.org/resources/multiworld.92559/
 * https://bstats.org/plugin/bukkit/MultiWorld/15446
 
 # Commands
+
 ```
-* /world                                      [multiworld.command.world]
-* /world back                                 [multiworld.command.world.back]
-* /world clone <Name> <Clone>                 [multiworld.command.world.clone]
-* /world create <Name> <WorldType>            [multiworld.command.world.create]
-* /world delete <Name>                        [multiworld.command.world.delete]
-* /world help                                 [multiworld.command.world]
-* /world import <Name> <WorldType>            [multiworld.command.world.import]
-* /world info <Name>                          [multiworld.command.world.info]
-* /world list                                 [multiworld.command.world.list]
-* /world load <Name>                          [multiworld.command.world.load]
-* /world options <World> <Option> <Value>     [multiworld.command.world.options]
-* /world reload                               [multiworld.command.world.reload]
-* /world teleport <Player> <World>            [multiworld.command.world.teleport]
-* /world unload <World>                       [multiworld.command.world.unload]
+* /world                                                                [multiworld.command.world]
+* /world back                                                           [multiworld.command.world.back]
+* /world backup <World>                                                 [multiworld.command.world.backup]
+* /world clone <World> <Clone>                                          [multiworld.command.world.clone]
+* /world create <Name> <WorldType|Seed|Generator>                       [multiworld.command.world.create]
+* /world delete <World>                                                 [multiworld.command.world.delete]
+* /world flag <World> <Option> <Value>                                  [multiworld.command.world.flag]
+* /world help                                                           [multiworld.command.world]
+* /world import <Name> <WorldType>                                      [multiworld.command.world.import]
+* /world info <World>                                                   [multiworld.command.world.info]
+* /world link <World> <Nether|End> <World>                              [multiworld.command.world.list]
+* /world list                                                           [multiworld.command.world.list]
+* /world load <World>                                                   [multiworld.command.world.load]
+* /world reload                                                         [multiworld.command.world.reload]
+* /world teleport <Player> <World>                                      [multiworld.command.world.teleport]
+* /world unload <World>                                                 [multiworld.command.world.unload]
+* /world whitelist <World> <Enable|Disable|Add|Remove|List> <Name>       [multiworld.command.world.unload]
 ```
 
 # Configuration
+
 ```
+#
 #      __  ___      ____  _ _       __           __    __
 #    /  |/  /_  __/ / /_(_) |     / /___  _____/ /___/ /
 #   / /|_/ / / / / / __/ /| | /| / / __ \/ ___/ / __  /
@@ -48,136 +58,167 @@ config-version: ${project.version}
 # General
 prefix: '§8[§bMultiWorld§8]§r'
 no-permission: '§cIm sorry, but you do not have permission to perform this command. Please contact the server administrators if you believe that is in error.'
-player-not-found: '%prefix% §cThis player cannot be found'
+player-not-found: '%prefix% §cThis player could not be found'
 only-player-command: '%prefix% §cThis command can only performed by a player'
 
-# Worlds that should be loaded when the server starts
-# WARNING: When the world is not registered by MultiWorld the world will not bee loaded
-# The world has to be imported manually! (Attention choose the correct WorldType)
-auto-load: []
-
-# Standard values for new worlds
-defaults:
-  world: world
-  difficulty: PEACEFUL
-  gamemode: SURVIVAL
-  pvp-enabled: true
-  spawn-animals: true
-  spawn-monsters: true
-
-# Settings
 settings:
+  # Worlds that should be loaded when the server starts
+  # WARNING: When the world is not registered by MultiWorld the world will not bee loaded
+  # The world has to be imported manually! (Attention choose the correct WorldType)
+  # Example: auto-load: [world1, world2, world3]
+  auto-load: []
   # Should all players with the permission (multiworld.notify.update)
   # get a message when entering server
   receive-update-message: true
   # Should the auto-gamemode per world work?
-  auto-gamemode: true
+  auto-game-mode-enabled: true
+  # Should you be able to enter Nether/End worlds with the command /world telport <Player> <World>
+  access-nether-world-via-command: true
+  access-end-world-via-command: true
+  # Standard values for new worlds
+  defaults:
+    normal-world: world
+    end-world: world_the_end
+    nether_world: world_nether
+    difficulty: PEACEFUL
+    game-mode: SURVIVAL
+    pvp-enabled: true
+    spawn-animals: false
+    spawn-monsters: false
+    whitelist-enabled: false
 
 messages:
-  back:
-    usage: '%prefix% §cUsage: /world back'
-    world-already-there: '%prefix%§ §7You are already in this world'
-    world-not-loaded: '%prefix% §7This world is not longer active'
-    world-not-found: '%prefix% §7There is no world you can be teleported'
-  clone:
-    usage: '%prefix% §cUsage: /world clone <Name> <Clone>'
-    starting: '%prefix% §7The world §a%world% §7will be cloned..'
-    finished: '%prefix% §7The world §a%world% §7was successfully cloned!'
-  create:
-    usage: '%prefix% §cUsage: /world create <Name> <WorldType | Seed | Generator>'
-    starting: '%prefix% §7The world §a%world% §7is being created...'
-    finished: '%prefix% §7The world §a%world% §7was successfully created!'
-  delete:
-    usage: '%prefix% §cUsage: /world delete <Name>'
-    starting: '%prefix% §7The world §a%world% §7will be deleted...'
-    finished: '%prefix% §7The world §a%world% §7has been deleted!'
-  help:
-    messages:
-      - ''
-      - '§f§m               §r§r %prefix% §f§m               '
-      - ''
-      - '§7» §7/world §bback'
-      - '§7» §7/world §bclone §7<World> <Name>'
-      - '§7» §7/world §bcreate §7<Name> <WorldType | Seed | Generator>'
-      - '§7» §7/world §bdelete §7<World>'
-      - '§7» §7/world §bhelp'
-      - '§7» §7/world §bimport §7<World> <WorldType>'
-      - '§7» §7/world §binfo §7<World>'
-      - '§7» §7/world §blist'
-      - '§7» §7/world §bload §7<World>'
-      - '§7» §7/world §boptions §7<World> <Option> <Value>'
-      - '§7» §7/world §breload'
-      - '§7» §7/world §bteleport §7<Player> <World>'
-      - '§7» §7/world §bunload §7<World>'
-      - ''
-      - '§f§m               §r§r %prefix% §f§m               '
-      - ''
-  import:
-    usage: '%prefix% §cUsage: /world import <Name> <WorldType>'
-    already-imported: '%prefix% §7Skipped §a%world% §7already imported'
-    starting: '%prefix% §7Starting import of §a%world%§7...'
-    finished: '%prefix% §7Finished import of §a%world%§7!'
-  info:
-    usage: '%prefix% §cUsage: /world info <Name>'
-    messages:
-      - ''
-      - '§f§m               §r§r §b%world% §f§m               '
-      - ''
-      - '§7» Creator: §b%worldCreator%'
-      - '§7» CreationTime: §b%creationDate%'
-      - '§7» Loaded: §b%loaded%'
-      - '§7» WorldType: §b%worldType%'
-      - '§7» Environment: §b%environment%'
-      - '§7» Difficulty: §b%difficulty%'
-      - '§7» Gamemode: §b%gamemode%'
-      - '§7» PvP: §b%pvpEnabled%'
-      - ''
-      - '§f§m               §r§r §b%world% §f§m               '
-      - ''
-  list:
-    usage: '%prefix% §cUsage: /world list'
-    message: '%prefix% §7Worlds: %worlds%'
-  load:
-    usage: '%prefix% §cUsage: /world load <Name>'
-    starting: '%prefix% §7The world §a%world% §7is loading...'
-    finished: '%prefix% §7The world §a%world% §7was successfully loaded!'
-    already-loaded: '%prefix% §7This world is loaded'
-    not-registered: '%prefix% §7Couldnt load the world §a%world%§7. Use /world import'
-    not-loaded: '%prefix% §7This world is not loaded!'
-  options:
-    usage: '%prefix% §cUsage: /world options <Name> <Option> <Value>'
-    updating: '%prefix% §7Updating §a%option% §7with value §a%value% §7in §a%world%'
-    value-wrong: '%prefix% §7The value §a%value% §7is not present'
-    not-available: '%prefix% §7This world option does not exist'
-  unload:
-    usage: '%prefix% §cUsage: /world unload <Name>'
-    starting: '%prefix% §7Trying to unload the world §a%world%'
-    finished: '%prefix% §7The World §a%world% §7has been unloaded!'
-    chunk-starting: '%prefix% §7Trying to unload all chunks...'
-    chunk-finished: '%prefix% §7All chunks are unloaded'
-    chunk-teleport: '%prefix% §7This world has been unloaded you will be teleported'
-  reload:
-    usage: '%prefix% §cUsage: /world reload'
-    successfully-reloaded: '%prefix% §7The config was §asuccessfully §7reloaded'
-  teleport:
-    usage: '%prefix% §cUsage: /world teleport <Player> <World>'
-    message: '%prefix% §7Teleporting §a%player% §7to %world%'
-    component-message: '%prefix% §8[§aTeleport§8]'
-    component-hover-text: '%prefix% §7Click to teleport'
-    target-already-in-world: '%prefix% §7Player §a%target% already in this world'
-    sender-already-in-world: '%prefix% §7You already in this world!'
   general:
-    update-message-player: '%prefix% §7There is a new update available. https://www.spigotmc.org/resources/multiworld.92559/'
-    invalid-input: '%prefix% §cThis is not a valid value'
-    already-exists: '%prefix% §7This world already exists!'
-    type-not-available: '%prefix% §7This world type does not exist'
-    waiting: '%prefix% §cPlease wait a moment...'
-    cannot-deleted: '%prefix% §cThis world cannot be deleted!'
-    cannot-unloaded: '%prefix% §cThis world cannot be unloaded!'
-    not-exists: '%prefix% §7This world dont exist!'
-    folder-not-exists: '%prefix% §7World folder %folder% was not found'
-    error-message: '%prefix% §cAn error has occurred! Contact an Administrator!'
+    update-message-player: '%prefix% §7There is a new update available. §8[§bhttps://www.spigotmc.org/resources/multiworld.92559§8]'
+    world-not-exists: '%prefix% §cThe specified world does not exist!'
+    world-not-loaded: '%prefix% §cThe specified world is not loaded!'
+    world-already-exists: '%prefix% §cThe specified world already exists!'
+    world-type-not-exists: '%prefix% §cThe specified WorldType does not exist'
+    world-folder-not-exists: '%prefix% §cNo world folder could be found!'
+    world-whitelist-block-trespassing: '%prefix% §7You are not on the whitelist of this world!'
+  commands:
+    back:
+      usage: '%prefix% §cUsage: /world back'
+      world-not-exists: '%prefix% §cThere is no world you can go!'
+      sender-already-there: '%prefix% §cYou are already in the world §b%world_name%'
+    backup:
+      usage: '%prefix% §cUsage: /world backup <World>'
+      starting: '%prefix% §7A backup of the world §b%world_name% is created...'
+      finished: '%prefix% §7The backup of the world §b%world_name% §7has been successfully created!'
+    clone:
+      usage: '%prefix% §cUsage: /world clone <World> <Name>'
+      starting: '%prefix% §7The world §b%world_name% §7will be copied...'
+      finished: '%prefix% §7The world §b%world_name% §7has been successfully copied!'
+    create:
+      usage: '%prefix% §cUsage: /world create <Name> <Generator | Seed | WorldType>'
+      starting: '%prefix% §7The world §b%world_name% §7will be created...'
+      finished: '%prefix% §7The world §b%world_name% §7was created successfully!'
+    delete:
+      usage: '%prefix% §cUsage: /world delete <World>'
+      world-cannot-deleted: '%prefix% §cThe specified world may not be deleted!'
+      starting: '%prefix% §7The world §b%world_name% §7will be deleted...'
+      finished: '%prefix% §7The world §b%world_name% §7has been successfully deleted!'
+    flag:
+      usage: '%prefix% §cUsage: /world flag <World> <Flag> <Value>'
+      not-existing: '%prefix% §cThis flag does not exist'
+      value-not-existing: '%prefix% §cThis value does not exist for the flag §b%flag%'
+      successfully-set: '%prefix% §7The flag §b%flag% §7was set to §b%value% §7!'
+    help:
+      message:
+        - ''
+        - '§f§m                    §r§r %prefix% §f§m                    '
+        - ''
+        - '§7» §7/world §bback'
+        - '§7» §7/world §bbackup §7<World>'
+        - '§7» §7/world §bclone §7<World> <Name>'
+        - '§7» §7/world §bcreate §7<Name> <WorldType | Seed | Generator>'
+        - '§7» §7/world §bdelete §7<World>'
+        - '§7» §7/world §bflag §7<World> <Property> <Value>'
+        - '§7» §7/world §bhelp'
+        - '§7» §7/world §bimport §7<World> <WorldType>'
+        - '§7» §7/world §binfo §7<World>'
+        - '§7» §7/world §blist'
+        - '§7» §7/world §blink §7<World> <Nether | End> <Welt>'
+        - '§7» §7/world §bload §7<World>'
+        - '§7» §7/world §breload'
+        - '§7» §7/world §bteleport §7<Player> <Welt>'
+        - '§7» §7/world §bunload §7<World>'
+        - '§7» §7/world §bwhitelist §7<World> <Enable | Disable | Add | Remove | List> <Name>'
+        - ''
+        - '§f§m                    §r§r %prefix% §f§m                    '
+        - ''
+    import:
+      usage: '%prefix% §cUsage: /world import <Name> <WorldType | Generator>'
+      world-already-imported: '%prefix% §7The world §b%world_name% §7is already imported!'
+      starting: '%prefix% §7The world §b%world_name% §7will import...'
+      finished: '%prefix% §7The world §b%world_name% §7was successfully imported!'
+    info:
+      usage: '%prefix% §cUsage: /world info <World>'
+      message:
+        - ''
+        - '§f§m               §r§r §b%world_name% §f§m               '
+        - ''
+        - '§7» Creator: §b%world_creator_name%'
+        - '§7» Created at: §b%creation_timestamp%'
+        - '§7» Loaded: §b%loaded%'
+        - '§7» WorldType: §b%world_type%'
+        - '§7» Environment: §b%environment%'
+        - '§7» Difficulty: §b%difficulty%'
+        - '§7» GameMode: §b%gamemode%'
+        - '§7» Pvp: §b%pvp_enabled%'
+        - '§7» Whitelist: §b%whitelist_enabled%'
+        - ''
+        - '§f§m               §r§r §b%world_name% §f§m               '
+        - ''
+    list:
+      usage: '%prefix% §cUsage: /world list'
+      message: '%prefix% §aWorlds: %worlds%'
+    link:
+      usage: '%prefix% §cUsage: /world link <World> <End | Nether> <World>'
+      environment-not-exists: '%prefix% §cThe specified environment does not exist!'
+      successfully-set: '%prefix% §7You have connected the portal of the environment §b%environment_name% §7in the world §b%world_name% §7with the world §b%target_world_name% §7'
+    load:
+      usage: '%prefix% §cUsage: /world load <Name>'
+      world-already-loaded: '%prefix% §7The world §bworld_name% §7is already loaded!'
+      starting: '%prefix% §7The world §b%world_name% §7will loaded...'
+      finished: '%prefix% §7The world §b%world_name% §7was successfully loaded!'
+    reload:
+      usage: '%prefix% §cUsage: /world reload'
+      message: '%prefix% §7The configurations has been reloaded!'
+    teleport:
+      usage: '%prefix% §cUsage: /world teleport <Player> <World>'
+      message: '%prefix% §a%player_name% §7is teleported to the world §b%world_name% §7!'
+      sender-already-there: '%prefix% §7You are already in the world §b%world_name%'
+      target-already-there: '%prefix% §7The player §a%player_name% §7is already in the world §b%world_name%'
+      nether-not-accessible: '%prefix% §cYou cant enter the Nether via the command!'
+      end-not-accessible: '%prefix% §cYou cant enter the end via the command!'
+    unload:
+      usage: '%prefix% §cUsage: /world unload <World>'
+      world-cannot-unloaded: '%prefix% §cThe specified world must not be unloaded!'
+      starting: '%prefix% §7The world §b%world_name% §7will be unloaded...'
+      finished: '%prefix% §7The world §b%world_name% §7was successfully unloaded!'
+      chunk-starting: '%prefix% §7The chunks in §b%world_name% §7are unloaded...'
+      chunk-finished: '%prefix% §7The chunks in §b%world_name% §7were successfully unloaded!'
+      chunk-teleport: '%prefix% §The world you were in will be unloaded. You will be teleported!'
+    whitelist:
+      usage: '%prefix% §cUsage: /world whitelist <World> <On | Off | Add | List | Remove> <Player>'
+      add:
+        already-added: '%prefix% §The player %player_name% §7is already §7on the whitelist!'
+        successfully-added: '%prefix% §7You have added %player_name% §7to the whitelist of world §b%world_name% §7'
+      list:
+        empty: '%prefix% §7The whitelist for world §b%world_name% §7is empty'
+        message: '%prefix% §7Whitelist: %player_names%'
+      disable:
+        already-disabled: '%prefix% §7World whitelist §b%world_name% §7is already disabled!'
+        successfully-disabled: '%prefix% §7You have disabled the whitelist in the world §b%world_name% §7deactivated!'
+      enable:
+        already-enabled: '%prefix% §7The world whitelist §b%world_name% §7is already activated!'
+        successfully-enabled: '%prefix% §7You have activated the whitelist in the world §b%world_name% §7!'
+      remove:
+        already-removed: '%prefix% §7The player %player_name% §7is §not §7on the whitelist!'
+        successfully-removed: '%prefix% §7You have %player_name% §7removed from the §b%world_name% §7whitelist'
 ```
+
 # Developer
 
 1. Install the the project in your local repository
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/MultiWorldBukkitApi.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/MultiWorldBukkitApi.java
new file mode 100644
index 0000000..67c3828
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/MultiWorldBukkitApi.java
@@ -0,0 +1,26 @@
+package com.dev7ex.multiworld.api.bukkit;
+
+import com.dev7ex.multiworld.api.MultiWorldApi;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldConfiguration;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldGeneratorProvider;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldManager;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldProvider;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public interface MultiWorldBukkitApi extends MultiWorldApi {
+
+    @Override
+    BukkitWorldConfiguration getWorldConfiguration();
+
+    @Override
+    BukkitWorldProvider getWorldProvider();
+
+    @Override
+    BukkitWorldGeneratorProvider getWorldGeneratorProvider();
+
+    @Override
+    BukkitWorldManager getWorldManager();
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/MultiWorldListener.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/MultiWorldListener.java
new file mode 100644
index 0000000..c3b4c0d
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/MultiWorldListener.java
@@ -0,0 +1,48 @@
+package com.dev7ex.multiworld.api.bukkit.event;
+
+import com.dev7ex.multiworld.api.MultiWorldApiConfiguration;
+import com.dev7ex.multiworld.api.bukkit.MultiWorldBukkitApi;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldGeneratorProvider;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldManager;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldProvider;
+import com.dev7ex.multiworld.api.user.WorldUserProvider;
+import org.bukkit.event.Listener;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public abstract class MultiWorldListener implements Listener {
+
+    private final MultiWorldBukkitApi multiWorldApi;
+
+    public MultiWorldListener(@NotNull final MultiWorldBukkitApi multiWorldApi) {
+        this.multiWorldApi = multiWorldApi;
+    }
+
+    public MultiWorldApiConfiguration getConfiguration() {
+        return this.multiWorldApi.getConfiguration();
+    }
+
+    public String getPrefix() {
+        return this.multiWorldApi.getConfiguration().getPrefix();
+    }
+
+    public BukkitWorldProvider getWorldProvider() {
+        return this.multiWorldApi.getWorldProvider();
+    }
+
+    public BukkitWorldManager getWorldManager() {
+        return this.multiWorldApi.getWorldManager();
+    }
+
+    public BukkitWorldGeneratorProvider getWorldGeneratorProvider() {
+        return this.multiWorldApi.getWorldGeneratorProvider();
+    }
+
+    protected WorldUserProvider getUserProvider() {
+        return this.multiWorldApi.getUserProvider();
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/plugin/MultiWorldEvent.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/plugin/MultiWorldEvent.java
new file mode 100644
index 0000000..a8614e7
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/plugin/MultiWorldEvent.java
@@ -0,0 +1,22 @@
+package com.dev7ex.multiworld.api.bukkit.event.plugin;
+
+import com.dev7ex.multiworld.api.bukkit.MultiWorldBukkitApi;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+abstract class MultiWorldEvent extends Event {
+
+    private final MultiWorldBukkitApi multiWorldApi;
+
+    MultiWorldEvent(@NotNull final MultiWorldBukkitApi multiWorldApi) {
+        this.multiWorldApi = multiWorldApi;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/plugin/MultiWorldStartupCompleteEvent.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/plugin/MultiWorldStartupCompleteEvent.java
new file mode 100644
index 0000000..a78be8f
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/plugin/MultiWorldStartupCompleteEvent.java
@@ -0,0 +1,33 @@
+package com.dev7ex.multiworld.api.bukkit.event.plugin;
+
+import com.dev7ex.multiworld.api.bukkit.MultiWorldBukkitApi;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author itsTyrion
+ * @since 29.11.2022
+ */
+@Getter(AccessLevel.PUBLIC)
+public class MultiWorldStartupCompleteEvent extends MultiWorldEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+    private final long startupDuration;
+
+    public MultiWorldStartupCompleteEvent(@NotNull final MultiWorldBukkitApi multiWorldApi, final long startupDuration) {
+        super(multiWorldApi);
+        this.startupDuration = startupDuration;
+    }
+
+    public static HandlerList getHandlerList() {
+        return MultiWorldStartupCompleteEvent.HANDLERS;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return MultiWorldStartupCompleteEvent.HANDLERS;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserEnterPortalEvent.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserEnterPortalEvent.java
new file mode 100644
index 0000000..cbabff1
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserEnterPortalEvent.java
@@ -0,0 +1,42 @@
+package com.dev7ex.multiworld.api.bukkit.event.user;
+
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.user.WorldUser;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.PortalType;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 29.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+@Setter(AccessLevel.PUBLIC)
+public class WorldUserEnterPortalEvent extends WorldUserEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+    private boolean cancelled = false;
+    private final BukkitWorldHolder currentWorldHolder;
+    private final BukkitWorldHolder portalWorldHolder;
+    private final PortalType portalType;
+
+    public WorldUserEnterPortalEvent(@NotNull final WorldUser user, @NotNull final BukkitWorldHolder currentWorldHolder, @NotNull final BukkitWorldHolder portalWorldHolder, @NotNull final PortalType portalType) {
+        super(user);
+        this.currentWorldHolder = currentWorldHolder;
+        this.portalWorldHolder = portalWorldHolder;
+        this.portalType = portalType;
+    }
+
+    public static HandlerList getHandlerList() {
+        return WorldUserEnterPortalEvent.HANDLERS;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return WorldUserEnterPortalEvent.HANDLERS;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserEvent.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserEvent.java
new file mode 100644
index 0000000..58b9099
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserEvent.java
@@ -0,0 +1,22 @@
+package com.dev7ex.multiworld.api.bukkit.event.user;
+
+import com.dev7ex.multiworld.api.user.WorldUser;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+abstract class WorldUserEvent extends Event {
+
+    private final WorldUser user;
+
+    WorldUserEvent(@NotNull final WorldUser user) {
+        this.user = user;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserLoginEvent.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserLoginEvent.java
new file mode 100644
index 0000000..9feba57
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserLoginEvent.java
@@ -0,0 +1,31 @@
+package com.dev7ex.multiworld.api.bukkit.event.user;
+
+import com.dev7ex.multiworld.api.user.WorldUser;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+public class WorldUserLoginEvent extends WorldUserEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public WorldUserLoginEvent(@NotNull final WorldUser user) {
+        super(user);
+    }
+
+    public static HandlerList getHandlerList() {
+        return WorldUserLoginEvent.HANDLERS;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return WorldUserLoginEvent.HANDLERS;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserLogoutEvent.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserLogoutEvent.java
new file mode 100644
index 0000000..5efbfba
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserLogoutEvent.java
@@ -0,0 +1,31 @@
+package com.dev7ex.multiworld.api.bukkit.event.user;
+
+import com.dev7ex.multiworld.api.user.WorldUser;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+public class WorldUserLogoutEvent extends WorldUserEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public WorldUserLogoutEvent(@NotNull final WorldUser user) {
+        super(user);
+    }
+
+    public static HandlerList getHandlerList() {
+        return WorldUserLogoutEvent.HANDLERS;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return WorldUserLogoutEvent.HANDLERS;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserTeleportWorldEvent.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserTeleportWorldEvent.java
new file mode 100644
index 0000000..2b0fad9
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/user/WorldUserTeleportWorldEvent.java
@@ -0,0 +1,40 @@
+package com.dev7ex.multiworld.api.bukkit.event.user;
+
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.user.WorldUser;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+@Setter(AccessLevel.PUBLIC)
+public class WorldUserTeleportWorldEvent extends WorldUserEvent implements Cancellable {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+    private boolean cancelled = false;
+    private BukkitWorldHolder lastWorldHolder;
+    private BukkitWorldHolder nextWorldHolder;
+
+    public WorldUserTeleportWorldEvent(@NotNull final WorldUser user, @NotNull final BukkitWorldHolder lastWorldHolder, @NotNull final BukkitWorldHolder nextWorldHolder) {
+        super(user);
+        this.lastWorldHolder = lastWorldHolder;
+        this.nextWorldHolder = nextWorldHolder;
+    }
+
+    public static HandlerList getHandlerList() {
+        return WorldUserTeleportWorldEvent.HANDLERS;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return WorldUserTeleportWorldEvent.HANDLERS;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldCloneEvent.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldCloneEvent.java
new file mode 100644
index 0000000..ccdb164
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldCloneEvent.java
@@ -0,0 +1,47 @@
+package com.dev7ex.multiworld.api.bukkit.event.world;
+
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.command.CommandSender;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+@Setter(AccessLevel.PUBLIC)
+public class WorldCloneEvent extends WorldEvent implements Cancellable {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+    private boolean cancelled = false;
+
+    private final String clonedName;
+    private final File sourceFolder;
+    private final File destinationFolder;
+
+    public WorldCloneEvent(@NotNull final BukkitWorldHolder worldHolder, @NotNull final CommandSender commandSender,
+                           @NotNull final String clonedName, @NotNull final File sourceFolder,
+                           @NotNull final File destinationFolder) {
+        super(worldHolder, commandSender);
+        this.clonedName = clonedName;
+        this.sourceFolder = sourceFolder;
+        this.destinationFolder = destinationFolder;
+    }
+
+    public static HandlerList getHandlerList() {
+        return WorldCloneEvent.HANDLERS;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return WorldCloneEvent.HANDLERS;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldCreateEvent.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldCreateEvent.java
new file mode 100644
index 0000000..40bef86
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldCreateEvent.java
@@ -0,0 +1,36 @@
+package com.dev7ex.multiworld.api.bukkit.event.world;
+
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.command.CommandSender;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+@Setter(AccessLevel.PUBLIC)
+public class WorldCreateEvent extends WorldEvent implements Cancellable {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+    private boolean cancelled = false;
+
+    public WorldCreateEvent(@NotNull final BukkitWorldHolder worldHolder, @NotNull final CommandSender commandSender) {
+        super(worldHolder, commandSender);
+    }
+
+    public static HandlerList getHandlerList() {
+        return WorldCreateEvent.HANDLERS;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return WorldCreateEvent.HANDLERS;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldDeleteEvent.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldDeleteEvent.java
new file mode 100644
index 0000000..1401f0c
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldDeleteEvent.java
@@ -0,0 +1,36 @@
+package com.dev7ex.multiworld.api.bukkit.event.world;
+
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.command.CommandSender;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+@Setter(AccessLevel.PUBLIC)
+public class WorldDeleteEvent extends WorldEvent implements Cancellable {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+    private boolean cancelled = false;
+
+    public WorldDeleteEvent(@NotNull final BukkitWorldHolder worldHolder, @NotNull final CommandSender commandSender) {
+        super(worldHolder, commandSender);
+    }
+
+    public static HandlerList getHandlerList() {
+        return WorldDeleteEvent.HANDLERS;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return WorldDeleteEvent.HANDLERS;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldEvent.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldEvent.java
new file mode 100644
index 0000000..7945719
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldEvent.java
@@ -0,0 +1,25 @@
+package com.dev7ex.multiworld.api.bukkit.event.world;
+
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.bukkit.command.CommandSender;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+abstract class WorldEvent extends Event {
+
+    private final BukkitWorldHolder worldHolder;
+    private final CommandSender commandSender;
+
+    WorldEvent(@NotNull final BukkitWorldHolder worldHolder, @NotNull final CommandSender commandSender) {
+        this.worldHolder = worldHolder;
+        this.commandSender = commandSender;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldFlagChangeEvent.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldFlagChangeEvent.java
new file mode 100644
index 0000000..b8d667b
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/event/world/WorldFlagChangeEvent.java
@@ -0,0 +1,41 @@
+package com.dev7ex.multiworld.api.bukkit.event.world;
+
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.world.WorldFlag;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.command.CommandSender;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 29.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+@Setter(AccessLevel.PUBLIC)
+public class WorldFlagChangeEvent extends WorldEvent implements Cancellable {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+    private boolean cancelled = false;
+    private WorldFlag flag;
+    private String value;
+
+    public WorldFlagChangeEvent(@NotNull final BukkitWorldHolder worldHolder, @NotNull final CommandSender commandSender, @NotNull final WorldFlag flag, @NotNull final String value) {
+        super(worldHolder, commandSender);
+        this.flag = flag;
+        this.value = value;
+    }
+
+    public static HandlerList getHandlerList() {
+        return WorldFlagChangeEvent.HANDLERS;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return WorldFlagChangeEvent.HANDLERS;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/generator/FlatChunkGenerator.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/generator/FlatChunkGenerator.java
new file mode 100644
index 0000000..bcbea6f
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/generator/FlatChunkGenerator.java
@@ -0,0 +1,31 @@
+package com.dev7ex.multiworld.api.bukkit.generator;
+
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.generator.ChunkGenerator;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Random;
+
+/**
+ * @author Dev7ex
+ * @since 20.05.2021
+ */
+public final class FlatChunkGenerator extends ChunkGenerator {
+
+    @Override
+    public @NotNull ChunkData generateChunkData(@NotNull final World world, @NotNull final Random random, final int x, final int z, @NotNull final BiomeGrid biome) {
+        final ChunkData chunkData = super.createChunkData(world);
+        chunkData.setRegion(0, 0, 0, 16, 1, 16, Material.BEDROCK);
+        chunkData.setRegion(0, 1, 0, 16, 64, 16, Material.GRASS_BLOCK);
+
+        for (int chunkX = 0; chunkX < 16; chunkX++) {
+            for (int chunkZ = 0; chunkZ < 16; chunkZ++) {
+                biome.setBiome(x, z, Biome.PLAINS);
+            }
+        }
+        return chunkData;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/generator/VoidChunkGenerator.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/generator/VoidChunkGenerator.java
new file mode 100644
index 0000000..4c0941d
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/generator/VoidChunkGenerator.java
@@ -0,0 +1,34 @@
+package com.dev7ex.multiworld.api.bukkit.generator;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.generator.ChunkGenerator;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Random;
+
+/**
+ * @author Dev7ex
+ * @since 20.05.2021
+ */
+public final class VoidChunkGenerator extends ChunkGenerator {
+
+    @Override
+    public @NotNull ChunkData generateChunkData(@NotNull final World world, @NotNull final Random random, final int x, final int z, @NotNull final BiomeGrid biome) {
+        final ChunkData chunkData = super.createChunkData(world);
+
+        if ((x == 0) && (z == 0)) {
+            chunkData.setBlock(0, 63, 0, Material.STONE);
+            world.setSpawnLocation(new Location(world, 0, 64, 0));
+        }
+        for (int chunkX = 0; chunkX < 16; chunkX++) {
+            for (int chunkZ = 0; chunkZ < 16; chunkZ++) {
+                biome.setBiome(x, z, Biome.PLAINS);
+            }
+        }
+        return chunkData;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldConfiguration.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldConfiguration.java
new file mode 100644
index 0000000..8e985cf
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldConfiguration.java
@@ -0,0 +1,10 @@
+package com.dev7ex.multiworld.api.bukkit.world;
+
+import com.dev7ex.multiworld.api.world.WorldConfiguration;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public interface BukkitWorldConfiguration extends WorldConfiguration<BukkitWorldHolder> {
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldGeneratorProvider.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldGeneratorProvider.java
new file mode 100644
index 0000000..cf3499b
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldGeneratorProvider.java
@@ -0,0 +1,17 @@
+package com.dev7ex.multiworld.api.bukkit.world;
+
+import com.dev7ex.multiworld.api.world.WorldGeneratorProvider;
+import org.bukkit.plugin.Plugin;
+
+import java.util.Map;
+
+/**
+ * @author Dev7ex
+ * @since 29.06.2023
+ */
+public interface BukkitWorldGeneratorProvider extends WorldGeneratorProvider {
+
+    @Override
+    Map<Plugin, String> getCustomGenerators();
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldHolder.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldHolder.java
new file mode 100644
index 0000000..a5429e1
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldHolder.java
@@ -0,0 +1,86 @@
+package com.dev7ex.multiworld.api.bukkit.world;
+
+import com.dev7ex.multiworld.api.world.WorldFlag;
+import com.dev7ex.multiworld.api.world.WorldHolder;
+import com.dev7ex.multiworld.api.world.WorldType;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.Bukkit;
+import org.bukkit.Difficulty;
+import org.bukkit.GameMode;
+import org.bukkit.World;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Dev7ex
+ * @since 29.05.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+@Setter(AccessLevel.PUBLIC)
+@Builder(setterPrefix = "set")
+public class BukkitWorldHolder implements WorldHolder {
+
+    private String name;
+    private String creatorName;
+    private long creationTimeStamp;
+    private WorldType type;
+    private GameMode gameMode;
+    private Difficulty difficulty;
+    private boolean pvpEnabled;
+    private boolean loaded;
+    private boolean spawnAnimals;
+    private boolean spawnMonsters;
+    private String endWorldName;
+    private String netherWorldName;
+    private String normalWorldName;
+    private List<String> whitelist = new ArrayList<>();
+    private boolean whitelistEnabled;
+
+    public World getWorld() {
+        return Bukkit.getWorld(this.name);
+    }
+
+    @Override
+    public void updateFlag(@NotNull final WorldFlag flag, @NotNull final String value) {
+        switch (flag) {
+            case PVP_ENABLED:
+                this.pvpEnabled = Boolean.parseBoolean(value);
+                break;
+
+            case GAMEMODE:
+                this.gameMode = GameMode.valueOf(value);
+                break;
+
+            case DIFFICULTY:
+                this.difficulty = Difficulty.valueOf(value);
+                if (this.loaded) {
+                    this.getWorld().setDifficulty(this.difficulty);
+                }
+                break;
+
+            case SPAWN_ANIMALS:
+                this.spawnAnimals = Boolean.parseBoolean(value);
+                if (this.loaded) {
+                    this.getWorld().setSpawnFlags(this.spawnMonsters, this.spawnAnimals);
+                }
+                break;
+
+            case SPAWN_MONSTERS:
+                this.spawnMonsters = Boolean.parseBoolean(value);
+                if (this.loaded) {
+                    this.getWorld().setSpawnFlags(this.spawnMonsters, this.spawnAnimals);
+                }
+                break;
+
+            case WORLD_TYPE:
+                this.type = WorldType.valueOf(value);
+                break;
+        }
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldManager.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldManager.java
new file mode 100644
index 0000000..041b29a
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldManager.java
@@ -0,0 +1,10 @@
+package com.dev7ex.multiworld.api.bukkit.world;
+
+import com.dev7ex.multiworld.api.world.WorldManager;
+
+/**
+ * @author Dev7ex
+ * @since 27.06.2023
+ */
+public interface BukkitWorldManager extends WorldManager {
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldProvider.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldProvider.java
new file mode 100644
index 0000000..cff84f3
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldProvider.java
@@ -0,0 +1,12 @@
+package com.dev7ex.multiworld.api.bukkit.world;
+
+import com.dev7ex.multiworld.api.world.WorldProvider;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public interface BukkitWorldProvider extends WorldProvider<BukkitWorldHolder> {
+
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldType.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldType.java
new file mode 100644
index 0000000..a05ac0c
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/BukkitWorldType.java
@@ -0,0 +1,24 @@
+package com.dev7ex.multiworld.api.bukkit.world;
+
+import com.dev7ex.multiworld.api.world.WorldType;
+import org.bukkit.World;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public class BukkitWorldType {
+
+    private BukkitWorldType() {
+    }
+
+    public static WorldType fromEnvironment(@NotNull final World.Environment environment) {
+        return switch (environment) {
+            case THE_END -> WorldType.END;
+            case NETHER -> WorldType.NETHER;
+            default -> WorldType.NORMAL;
+        };
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/location/BukkitWorldLocation.java b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/location/BukkitWorldLocation.java
new file mode 100644
index 0000000..bca0bff
--- /dev/null
+++ b/multiworld-api/multiworld-api-bukkit/src/main/java/com/dev7ex/multiworld/api/bukkit/world/location/BukkitWorldLocation.java
@@ -0,0 +1,92 @@
+package com.dev7ex.multiworld.api.bukkit.world.location;
+
+import com.dev7ex.multiworld.api.world.location.WorldLocation;
+import lombok.*;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.SerializableAs;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author Dev7ex
+ * @since 30.06.2023
+ */
+@Setter(AccessLevel.PUBLIC)
+@Getter(AccessLevel.PUBLIC)
+@Builder(setterPrefix = "set")
+@NoArgsConstructor
+@SerializableAs("BukkitWorldLocation")
+public class BukkitWorldLocation implements WorldLocation, ConfigurationSerializable {
+
+    private String worldName;
+    private double x;
+    private double z;
+    private double y;
+    private double yaw;
+    private double pitch;
+
+    public BukkitWorldLocation(@NotNull final String worldName, final double x, final double y, final double z, final double yaw, final double pitch) {
+        this.worldName = worldName;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.yaw = yaw;
+        this.pitch = pitch;
+    }
+
+    private BukkitWorldLocation(@NotNull final Map<String, Object> serializeData) {
+        this.worldName = (String) serializeData.get("world-name");
+        this.x = (double) serializeData.get("x");
+        this.y = (double) serializeData.get("y");
+        this.z = (double) serializeData.get("z");
+
+        if (serializeData.containsKey("yaw")) {
+            this.yaw = (double) serializeData.get("yaw");
+        }
+
+        if (serializeData.containsKey("pitch")) {
+            this.pitch = (double) serializeData.get("pitch");
+        }
+    }
+
+    public static BukkitWorldLocation deserialize(@NotNull final Map<String, Object> serializeData) {
+        return new BukkitWorldLocation(serializeData);
+    }
+
+    public static BukkitWorldLocation valueOf(@NotNull final Map<String, Object> serializeData) {
+        return new BukkitWorldLocation(serializeData);
+    }
+
+    public static BukkitWorldLocation of(@NotNull final Location location) {
+        final BukkitWorldLocation worldLocation = new BukkitWorldLocation();
+        worldLocation.setWorldName(location.getWorld().getName());
+        worldLocation.setX(location.getX());
+        worldLocation.setY(location.getY());
+        worldLocation.setZ(location.getZ());
+        worldLocation.setYaw(location.getYaw());
+        worldLocation.setPitch(location.getPitch());
+        return worldLocation;
+    }
+
+    public static Location to(@NotNull final WorldLocation location) {
+        return new Location(Bukkit.getWorld(location.getWorldName()), location.getX(), location.getY(), location.getZ(), (float) location.getYaw(), (float) location.getPitch());
+    }
+
+    @Override
+    public Map<String, Object> serialize() {
+        final Map<String, Object> serializeData = new HashMap<>();
+
+        serializeData.put("world-name", this.worldName);
+        serializeData.put("x", this.x);
+        serializeData.put("y", this.y);
+        serializeData.put("z", this.z);
+        serializeData.put("yaw", this.yaw);
+        serializeData.put("pitch", this.pitch);
+        return serializeData;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/MultiWorldApi.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/MultiWorldApi.java
new file mode 100644
index 0000000..6e0247f
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/MultiWorldApi.java
@@ -0,0 +1,33 @@
+package com.dev7ex.multiworld.api;
+
+import com.dev7ex.multiworld.api.user.WorldUserProvider;
+import com.dev7ex.multiworld.api.world.WorldConfiguration;
+import com.dev7ex.multiworld.api.world.WorldGeneratorProvider;
+import com.dev7ex.multiworld.api.world.WorldManager;
+import com.dev7ex.multiworld.api.world.WorldProvider;
+
+import java.io.File;
+
+/**
+ * @author Dev7ex
+ * @since 20.12.2022
+ */
+public interface MultiWorldApi {
+
+    MultiWorldApiConfiguration getConfiguration();
+
+    WorldConfiguration<?> getWorldConfiguration();
+
+    WorldProvider<?> getWorldProvider();
+
+    WorldManager getWorldManager();
+
+    WorldGeneratorProvider getWorldGeneratorProvider();
+
+    WorldUserProvider getUserProvider();
+
+    File getUserFolder();
+
+    File getBackupFolder();
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/MultiWorldApiConfiguration.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/MultiWorldApiConfiguration.java
new file mode 100644
index 0000000..d3a4e74
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/MultiWorldApiConfiguration.java
@@ -0,0 +1,27 @@
+package com.dev7ex.multiworld.api;
+
+import com.dev7ex.common.map.ParsedMap;
+import com.dev7ex.multiworld.api.world.WorldDefaultProperty;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public interface MultiWorldApiConfiguration {
+
+    String getPrefix();
+
+    ParsedMap<WorldDefaultProperty, Object> getDefaultProperties();
+
+    List<String> getAutoLoadableWorlds();
+
+    boolean isAutoGameModeEnabled();
+
+    String getString(@NotNull final String path);
+
+    boolean getBoolean(@NotNull final String path);
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/MultiWorldApiProvider.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/MultiWorldApiProvider.java
new file mode 100644
index 0000000..0d2abd0
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/MultiWorldApiProvider.java
@@ -0,0 +1,25 @@
+package com.dev7ex.multiworld.api;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 20.12.2022
+ */
+public class MultiWorldApiProvider {
+
+    private static MultiWorldApi multiWorldApi;
+
+    public static void registerApi(@NotNull final MultiWorldApi multiWorldApi) {
+        MultiWorldApiProvider.multiWorldApi = multiWorldApi;
+    }
+
+    public static void unregisterApi() {
+        MultiWorldApiProvider.multiWorldApi = null;
+    }
+
+    public static MultiWorldApi getMultiWorldApi() {
+        return MultiWorldApiProvider.multiWorldApi;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/user/WorldUser.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/user/WorldUser.java
new file mode 100644
index 0000000..40b2a33
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/user/WorldUser.java
@@ -0,0 +1,30 @@
+package com.dev7ex.multiworld.api.user;
+
+import com.dev7ex.multiworld.api.world.location.WorldLocation;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public interface WorldUser {
+
+    UUID getUniqueId();
+
+    String getName();
+
+    WorldUserConfiguration getConfiguration();
+
+    void setConfiguration(@NotNull final WorldUserConfiguration configuration);
+
+    @Nullable
+    WorldLocation getLastLocation();
+
+    void setLastLocation(@Nullable final WorldLocation location);
+
+    void sendMessage(@NotNull final String message);
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/user/WorldUserConfiguration.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/user/WorldUserConfiguration.java
new file mode 100644
index 0000000..c1ab788
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/user/WorldUserConfiguration.java
@@ -0,0 +1,20 @@
+package com.dev7ex.multiworld.api.user;
+
+import com.dev7ex.common.map.ParsedMap;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public interface WorldUserConfiguration {
+
+    ParsedMap<WorldUserProperty, Object> read();
+
+    ParsedMap<WorldUserProperty, Object> read(@NotNull final WorldUserProperty... properties);
+
+    void write(@NotNull final ParsedMap<WorldUserProperty, Object> userData);
+
+    void saveFile();
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/user/WorldUserProperty.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/user/WorldUserProperty.java
new file mode 100644
index 0000000..d47671c
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/user/WorldUserProperty.java
@@ -0,0 +1,24 @@
+package com.dev7ex.multiworld.api.user;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+public enum WorldUserProperty {
+
+    UNIQUE_ID("unique-id"),
+    NAME("name"),
+    LAST_LOCATION("last-location");
+
+    private final String storagePath;
+
+    WorldUserProperty(@NotNull final String storagePath) {
+        this.storagePath = storagePath;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/user/WorldUserProvider.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/user/WorldUserProvider.java
new file mode 100644
index 0000000..3e215b2
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/user/WorldUserProvider.java
@@ -0,0 +1,29 @@
+package com.dev7ex.multiworld.api.user;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public interface WorldUserProvider {
+
+    void registerUser(@NotNull final WorldUser user);
+
+    void unregisterUser(@NotNull final UUID uniqueId);
+
+    Optional<WorldUser> getUser(@NotNull final UUID uniqueId);
+
+    Optional<WorldUser> getUser(@NotNull final String name);
+
+    void saveUser(@NotNull final WorldUser user);
+
+    void saveUser(@NotNull final WorldUser user, @NotNull final WorldUserProperty... properties);
+
+    Map<UUID, WorldUser> getUsers();
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldConfiguration.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldConfiguration.java
new file mode 100644
index 0000000..5054bf3
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldConfiguration.java
@@ -0,0 +1,33 @@
+package com.dev7ex.multiworld.api.world;
+
+import com.dev7ex.common.map.ParsedMap;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public interface WorldConfiguration<T extends WorldHolder> {
+
+    void add(@NotNull final T worldHolder);
+
+    void remove(@NotNull final T worldHolder);
+
+    void remove(@NotNull final String name);
+
+    boolean contains(@NotNull final String name);
+
+    void updateFlag(@NotNull final T worldHolder, @NotNull final WorldFlag worldFlag, @NotNull final String value);
+
+    void write(@NotNull final T worldHolder, @NotNull final ParsedMap<WorldProperty, Object> worldData);
+
+    void write(@NotNull final T worldHolder, @NotNull final WorldProperty property, @NotNull final Object data);
+
+    T getWorldHolder(@NotNull final String name);
+
+    Map<String, T> getWorldHolders();
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldDefaultProperty.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldDefaultProperty.java
new file mode 100644
index 0000000..2a6512c
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldDefaultProperty.java
@@ -0,0 +1,40 @@
+package com.dev7ex.multiworld.api.world;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+public enum WorldDefaultProperty {
+
+    DIFFICULTY("difficulty", "settings.defaults.difficulty"),
+    GAME_MODE("game-mode", "settings.defaults.game-mode"),
+    PVP_ENABLED("pvp-enabled", "settings.defaults.pvp-enabled"),
+    SPAWN_ANIMALS("spawn-animals", "settings.defaults.spawn-animals"),
+    SPAWN_MONSTERS("spawn-monsters", "settings.defaults.spawn-monsters"),
+    WORLD("world", "settings.defaults.world"),
+    END_WORLD("end-world", "settings.defaults.end-world"),
+    NETHER_WORLD("nether-world", "settings.defaults.nether-world"),
+    NORMAL_WORLD("world", "settings.defaults.world"),
+    WHITELIST_ENABLED("whitelist-enabled", "settings.defaults.whitelist-enabled");
+
+    private final String name;
+    private final String storagePath;
+
+    WorldDefaultProperty(@NotNull final String name, @NotNull final String storagePath) {
+        this.name = name;
+        this.storagePath = storagePath;
+    }
+
+    public static Optional<WorldDefaultProperty> fromString(final String name) {
+        return Arrays.stream(WorldDefaultProperty.values()).filter(worldType -> worldType.name().equalsIgnoreCase(name)).findFirst();
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldEnvironment.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldEnvironment.java
new file mode 100644
index 0000000..ff9f8fe
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldEnvironment.java
@@ -0,0 +1,25 @@
+package com.dev7ex.multiworld.api.world;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author Dev7ex
+ * @since 26.06.2023
+ */
+public enum WorldEnvironment {
+
+    NORMAL,
+    NETHER,
+    THE_END;
+
+    public static List<String> toStringList() {
+        return Arrays.stream(WorldEnvironment.values()).map(Enum::name).toList();
+    }
+
+    public static Optional<WorldEnvironment> fromString(final String name) {
+        return Arrays.stream(WorldEnvironment.values()).filter(worldType -> worldType.name().equalsIgnoreCase(name)).findFirst();
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldFlag.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldFlag.java
new file mode 100644
index 0000000..08a398b
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldFlag.java
@@ -0,0 +1,41 @@
+package com.dev7ex.multiworld.api.world;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author Dev7ex
+ * @since 23.05.2021
+ */
+@Getter(AccessLevel.PUBLIC)
+public enum WorldFlag {
+
+    DIFFICULTY("difficulty", List.of("EASY", "HARD", "NORMAL", "PEACEFUL")),
+    GAMEMODE("game-mode", List.of("ADVENTURE", "CREATIVE", "SURVIVAL", "SPECTATOR")),
+    SPAWN_MONSTERS("spawn-monsters", List.of("false", "true")),
+    SPAWN_ANIMALS("spawn-animals", List.of("false", "true")),
+    PVP_ENABLED("pvp-enabled", List.of("false", "true")),
+    WORLD_TYPE("world-type", WorldType.toStringList());
+
+    private final String storagePath;
+    private final List<String> values;
+
+    WorldFlag(@NotNull final String storagePath, @NotNull final List<String> values) {
+        this.storagePath = storagePath;
+        this.values = values;
+    }
+
+    public static List<String> toStringList() {
+        return Arrays.stream(WorldFlag.values()).map(Enum::name).toList();
+    }
+
+    public static Optional<WorldFlag> fromString(final String name) {
+        return Arrays.stream(WorldFlag.values()).filter(worldType -> worldType.name().equalsIgnoreCase(name)).findFirst();
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldGeneratorProvider.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldGeneratorProvider.java
new file mode 100644
index 0000000..57f1d1f
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldGeneratorProvider.java
@@ -0,0 +1,15 @@
+package com.dev7ex.multiworld.api.world;
+
+import java.util.Map;
+
+/**
+ * @author Dev7ex
+ * @since 29.06.2023
+ */
+public interface WorldGeneratorProvider {
+
+    Map<?, String> getCustomGenerators();
+
+    boolean exists(final String generator);
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldHolder.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldHolder.java
new file mode 100644
index 0000000..6fa9c33
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldHolder.java
@@ -0,0 +1,51 @@
+package com.dev7ex.multiworld.api.world;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public interface WorldHolder {
+
+    String getName();
+
+    String getCreatorName();
+
+    long getCreationTimeStamp();
+
+    WorldType getType();
+
+    <T> T getGameMode();
+
+    <T> T getDifficulty();
+
+    boolean isPvpEnabled();
+
+    boolean isLoaded();
+
+    boolean isSpawnAnimals();
+
+    boolean isSpawnMonsters();
+
+    List<String> getWhitelist();
+
+    boolean isWhitelistEnabled();
+
+    void setWhitelistEnabled(final boolean enabled);
+
+    @Nullable
+    String getEndWorldName();
+
+    @Nullable
+    String getNetherWorldName();
+
+    @Nullable
+    String getNormalWorldName();
+
+    void updateFlag(@NotNull final WorldFlag flag, @NotNull final String value);
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldManager.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldManager.java
new file mode 100644
index 0000000..8c02a68
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldManager.java
@@ -0,0 +1,33 @@
+package com.dev7ex.multiworld.api.world;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public interface WorldManager {
+
+    void cloneWorld(@NotNull final String creatorName, @NotNull final String name, @NotNull final String clonedName);
+
+    void createBackup(@NotNull final String creatorName, @NotNull final String name);
+
+    void createWorld(@NotNull final String creatorName, @NotNull final String name, @NotNull final WorldType type);
+
+    void createWorld(@NotNull final String creatorName, @NotNull final String name, final long seed);
+
+    void createWorld(@NotNull final String creatorName, @NotNull final String name, @NotNull final String generator);
+
+    void deleteWorld(@NotNull final String creatorName, @NotNull final String name);
+
+    void importWorld(@NotNull final String creatorName, @NotNull final String name, @NotNull final WorldType type);
+
+    void loadWorld(@NotNull final String creatorName, @NotNull final String name);
+
+    void unloadWorld(@NotNull final String creatorName, @NotNull final String name);
+
+    WorldConfiguration<?> getConfiguration();
+
+    WorldProvider<?> getProvider();
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldProperty.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldProperty.java
new file mode 100644
index 0000000..af6faaa
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldProperty.java
@@ -0,0 +1,36 @@
+package com.dev7ex.multiworld.api.world;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+public enum WorldProperty {
+
+    CREATOR_NAME("creator-name", true),
+    CREATION_TIMESTAMP("creation-timestamp", true),
+    TYPE("type", true),
+    GAME_MODE("game-mode", true),
+    DIFFICULTY("difficulty", true),
+    PVP_ENABLED("pvp-enabled", true),
+    SPAWN_ANIMALS("spawn-animals", true),
+    SPAWN_MONSTERS("spawn-monsters", true),
+    END_WORLD("end-world", true),
+    NETHER_WORLD("nether-world", true),
+    NORMAL_WORLD("normal-world", true),
+    WHITELIST("whitelist", true),
+    WHITELIST_ENABLED("whitelist-enabled", true);
+
+    private final String storagePath;
+    private final boolean modifiable;
+
+    WorldProperty(@NotNull final String storagePath, final boolean modifiable) {
+        this.storagePath = storagePath;
+        this.modifiable = modifiable;
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldProvider.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldProvider.java
new file mode 100644
index 0000000..291906e
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldProvider.java
@@ -0,0 +1,27 @@
+package com.dev7ex.multiworld.api.world;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public interface WorldProvider<T extends WorldHolder> {
+
+    void register(@NotNull final T worldHolder);
+
+    void unregister(@NotNull final String name);
+
+    boolean isRegistered(@NotNull final String name);
+
+    Optional<T> getWorldHolder(@NotNull final String name);
+
+    Map<String, T> getWorldHolders();
+
+    WorldConfiguration<T> getConfiguration();
+
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldType.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldType.java
new file mode 100644
index 0000000..7485d0d
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/WorldType.java
@@ -0,0 +1,38 @@
+package com.dev7ex.multiworld.api.world;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author Dev7ex
+ * @since 20.05.2021
+ */
+@Getter(AccessLevel.PUBLIC)
+public enum WorldType {
+
+    CUSTOM(false),
+    END(false),
+    FLAT(true),
+    NETHER(false),
+    NORMAL(true),
+    VOID(true);
+
+    private final boolean overWorld;
+
+    WorldType(final boolean overWorld) {
+        this.overWorld = overWorld;
+    }
+
+    public static List<String> toStringList() {
+        return Arrays.stream(WorldType.values()).map(Enum::name).toList();
+    }
+
+    public static Optional<WorldType> fromString(final String name) {
+        return Arrays.stream(WorldType.values()).filter(worldType -> worldType.name().equalsIgnoreCase(name)).findFirst();
+    }
+
+}
diff --git a/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/location/WorldLocation.java b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/location/WorldLocation.java
new file mode 100644
index 0000000..a774ae0
--- /dev/null
+++ b/multiworld-api/multiworld-api-core/src/main/java/com/dev7ex/multiworld/api/world/location/WorldLocation.java
@@ -0,0 +1,39 @@
+package com.dev7ex.multiworld.api.world.location;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+
+/**
+ * @author Dev7ex
+ * @since 30.06.2023
+ */
+public interface WorldLocation {
+
+    String getWorldName();
+
+    void setWorldName(@NotNull final String worldName);
+
+    double getX();
+
+    void setX(final double x);
+
+    double getY();
+
+    void setY(final double y);
+
+    double getZ();
+
+    void setZ(final double z);
+
+    double getYaw();
+
+    void setYaw(final double yaw);
+
+    double getPitch();
+
+    void setPitch(final double pitch);
+
+    Map<String, Object> serialize();
+
+}
diff --git a/multiworld-bukkit/pom.xml b/multiworld-bukkit/pom.xml
index 6f5a462..82d169a 100644
--- a/multiworld-bukkit/pom.xml
+++ b/multiworld-bukkit/pom.xml
@@ -47,6 +47,14 @@
             <scope>compile</scope>
         </dependency>
 
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>${dependency-commons-io-version}</version>
+            <scope>provided</scope>
+        </dependency>
+
+
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
@@ -108,6 +116,12 @@
                     <target>${project.source.version}</target>
                 </configuration>
             </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+                <version>3.5.0</version>
+            </plugin>
         </plugins>
     </build>
 
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/MultiWorldConfiguration.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/MultiWorldConfiguration.java
new file mode 100644
index 0000000..a1de601
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/MultiWorldConfiguration.java
@@ -0,0 +1,54 @@
+package com.dev7ex.multiworld;
+
+import com.dev7ex.common.bukkit.configuration.ConfigurationProperties;
+import com.dev7ex.common.bukkit.plugin.configuration.DefaultPluginConfiguration;
+import com.dev7ex.common.bukkit.plugin.configuration.LocalizedConfiguration;
+import com.dev7ex.common.map.ParsedMap;
+import com.dev7ex.multiworld.api.MultiWorldApiConfiguration;
+import com.dev7ex.multiworld.api.world.WorldDefaultProperty;
+import com.dev7ex.multiworld.api.world.WorldEnvironment;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.apache.commons.lang.LocaleUtils;
+import org.bukkit.World;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * @author Dev7ex
+ * @since 25.01.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+@ConfigurationProperties(fileName = "config.yml")
+public final class MultiWorldConfiguration extends DefaultPluginConfiguration implements MultiWorldApiConfiguration {
+
+    private final ParsedMap<WorldDefaultProperty, Object> defaultProperties = new ParsedMap<>();
+
+    public MultiWorldConfiguration(@NotNull final Plugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public void load() {
+        super.load();
+
+        super.getFileConfiguration().getConfigurationSection("settings.defaults").getKeys(false)
+                .stream()
+                .forEach(entry -> this.defaultProperties.put(WorldDefaultProperty.valueOf(entry.replaceAll("-", "_").toUpperCase()), super.getFileConfiguration().get("settings.defaults." + entry)));
+
+    }
+
+    @Override
+    public List<String> getAutoLoadableWorlds() {
+        return super.getStringList("settings.auto-load");
+    }
+
+    @Override
+    public boolean isAutoGameModeEnabled() {
+        return super.getBoolean("settings.auto-game-mode-enabled");
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/MultiWorldPlugin.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/MultiWorldPlugin.java
new file mode 100644
index 0000000..c368abf
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/MultiWorldPlugin.java
@@ -0,0 +1,110 @@
+package com.dev7ex.multiworld;
+
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.common.bukkit.plugin.PluginProperties;
+import com.dev7ex.multiworld.api.MultiWorldApiProvider;
+import com.dev7ex.multiworld.api.bukkit.MultiWorldBukkitApi;
+import com.dev7ex.multiworld.api.bukkit.world.location.BukkitWorldLocation;
+import com.dev7ex.multiworld.command.WorldCommand;
+import com.dev7ex.multiworld.listener.PlayerConnectionListener;
+import com.dev7ex.multiworld.listener.PlayerDamagePlayerListener;
+import com.dev7ex.multiworld.listener.PlayerEnterPortalListener;
+import com.dev7ex.multiworld.listener.UserTeleportWorldListener;
+import com.dev7ex.multiworld.user.UserService;
+import com.dev7ex.multiworld.util.UpdateChecker;
+import com.dev7ex.multiworld.world.DefaultWorldConfiguration;
+import com.dev7ex.multiworld.world.DefaultWorldGeneratorProvider;
+import com.dev7ex.multiworld.world.DefaultWorldManager;
+import com.dev7ex.multiworld.world.DefaultWorldProvider;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.File;
+
+/**
+ * @author Dev7ex
+ * @since 19.05.2021
+ */
+@Getter(AccessLevel.PUBLIC)
+@PluginProperties(resourceId = 92559, metricsId = 15446, metrics = true)
+public final class MultiWorldPlugin extends BukkitPlugin implements MultiWorldBukkitApi {
+
+    private MultiWorldConfiguration configuration;
+    private DefaultWorldConfiguration worldConfiguration;
+
+    private DefaultWorldManager worldManager;
+
+    private DefaultWorldProvider worldProvider;
+    private UserService userProvider;
+    private DefaultWorldGeneratorProvider worldGeneratorProvider;
+
+    private final UpdateChecker updateChecker = new UpdateChecker(this);
+
+    @Override
+    public void onLoad() {
+        super.createDataFolder();
+        super.createSubFolder("user");
+        super.createSubFolder("backup");
+
+        this.configuration = new MultiWorldConfiguration(this);
+        this.configuration.load();
+
+        this.worldConfiguration = new DefaultWorldConfiguration(this);
+        this.worldConfiguration.createFile();
+    }
+
+    @Override
+    public void onEnable() {
+        MultiWorldApiProvider.registerApi(this);
+
+        this.worldManager = new DefaultWorldManager(this.worldConfiguration, this.configuration);
+
+        this.updateChecker.getVersion(updateAvailable -> {
+        });
+
+        ConfigurationSerialization.registerClass(BukkitWorldLocation.class);
+    }
+
+    @Override
+    public void onDisable() {
+        MultiWorldApiProvider.unregisterApi();
+    }
+
+    @Override
+    public void registerCommands() {
+        super.registerCommand(new WorldCommand(this));
+    }
+
+    @Override
+    public void registerListeners() {
+        super.registerListener(new PlayerConnectionListener(this));
+        super.registerListener(new PlayerEnterPortalListener(this));
+        super.registerListener(new PlayerDamagePlayerListener(this));
+
+        super.registerListener(new UserTeleportWorldListener(this));
+    }
+
+    @Override
+    public void registerServices() {
+        super.registerService(this.worldProvider = new DefaultWorldProvider(this.worldManager, this.worldConfiguration));
+        super.registerService(this.userProvider = new UserService());
+        super.registerService(this.worldGeneratorProvider = new DefaultWorldGeneratorProvider());
+    }
+
+    @Override
+    public File getBackupFolder() {
+        return super.getSubFolder("backup");
+    }
+
+    @Override
+    public File getUserFolder() {
+        return super.getSubFolder("user");
+    }
+
+    public static MultiWorldPlugin getInstance() {
+        return JavaPlugin.getPlugin(MultiWorldPlugin.class);
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/WorldCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/WorldCommand.java
new file mode 100644
index 0000000..966b498
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/WorldCommand.java
@@ -0,0 +1,76 @@
+package com.dev7ex.multiworld.command;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.command.world.*;
+import com.google.common.collect.Lists;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author Dev7ex
+ * @since 19.05.2021
+ */
+@CommandProperties(name = "world", permission = "multiworld.command.world")
+public final class WorldCommand extends BukkitCommand implements TabCompleter {
+
+    public WorldCommand(final MultiWorldPlugin plugin) {
+        super(plugin);
+
+        super.registerSubCommand(new BackCommand(plugin));
+        super.registerSubCommand(new BackupCommand(plugin));
+        super.registerSubCommand(new CloneCommand(plugin));
+        super.registerSubCommand(new CreateCommand(plugin));
+        super.registerSubCommand(new DeleteCommand(plugin));
+        super.registerSubCommand(new FlagCommand(plugin));
+        super.registerSubCommand(new HelpCommand(plugin));
+        super.registerSubCommand(new ImportCommand(plugin));
+        super.registerSubCommand(new InfoCommand(plugin));
+        super.registerSubCommand(new LinkCommand(plugin));
+        super.registerSubCommand(new ListCommand(plugin));
+        super.registerSubCommand(new LoadCommand(plugin));
+        super.registerSubCommand(new ReloadCommand(plugin));
+        super.registerSubCommand(new TeleportCommand(plugin));
+        super.registerSubCommand(new UnloadCommand(plugin));
+        super.registerSubCommand(new WhitelistCommand(plugin));
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if ((arguments.length == 0) || (arguments.length > 4)) {
+            return super.getSubCommand("help").orElseThrow().execute(commandSender, arguments);
+        }
+        final Optional<BukkitCommand> commandOptional = super.getSubCommand(arguments[0].toLowerCase());
+
+        if (commandOptional.isEmpty()) {
+            return super.getSubCommand("help").orElseThrow().execute(commandSender, arguments);
+        }
+        return commandOptional.get().execute(commandOptional.get(), commandSender, arguments);
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+        if (arguments.length == 1) {
+            return Lists.newArrayList(super.getSubCommands().keySet());
+        }
+        final Optional<BukkitCommand> commandOptional = super.getSubCommand(arguments[0].toLowerCase());
+
+        if ((commandOptional.isEmpty()) || (!(commandOptional.get() instanceof TabCompleter))) {
+            return null;
+        }
+        return ((TabCompleter) commandOptional.get()).onTabComplete(commandSender, command, commandLabel, arguments);
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/BackCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/BackCommand.java
new file mode 100644
index 0000000..a56550d
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/BackCommand.java
@@ -0,0 +1,74 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.user.WorldUser;
+import org.bukkit.Location;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 20.05.2021
+ */
+@CommandProperties(name = "back", permission = "multiworld.command.world.back")
+public class BackCommand extends BukkitCommand {
+
+    public BackCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (!(commandSender instanceof Player)) {
+            commandSender.sendMessage(super.getConfiguration().getString("only-player-command")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+        if (arguments.length != 1) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.back.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+        final Player player = (Player) commandSender;
+        final WorldUser user = MultiWorldPlugin.getInstance().getUserProvider().getUser(player.getUniqueId()).orElseThrow();
+
+        if (user.getLastLocation() == null) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.back.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", player.getWorld().getName()));
+            return true;
+        }
+
+        if (MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(user.getLastLocation().getWorldName()).isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+        final BukkitWorldHolder worldHolder = MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(user.getLastLocation().getWorldName()).orElseThrow();
+
+        if (!worldHolder.isLoaded()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-loaded")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", user.getLastLocation().getWorldName()));
+            return true;
+        }
+
+        if (user.getLastLocation().getWorldName().equalsIgnoreCase(player.getWorld().getName())) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.teleport.sender-already-there")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", player.getWorld().getName()));
+            return true;
+        }
+        final Location teleportLocation = worldHolder.getWorld().getSpawnLocation();
+        player.teleport(teleportLocation);
+        return true;
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/BackupCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/BackupCommand.java
new file mode 100644
index 0000000..d55b160
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/BackupCommand.java
@@ -0,0 +1,54 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author Dev7ex
+ * @since 19.06.2023
+ */
+@CommandProperties(name = "backup", permission = "multiworld.command.world.backup")
+public class BackupCommand extends BukkitCommand implements TabCompleter {
+
+    public BackupCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (arguments.length != 2) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.backup.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+        if (!MultiWorldPlugin.getInstance().getWorldProvider().isRegistered(arguments[1])) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+        MultiWorldPlugin.getInstance().getWorldManager().createBackup(commandSender.getName(), arguments[1]);
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+        if (arguments.length != 2) {
+            return Collections.emptyList();
+        }
+        return new ArrayList<>(MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders().keySet());
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/CloneCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/CloneCommand.java
new file mode 100644
index 0000000..3753c26
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/CloneCommand.java
@@ -0,0 +1,53 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author Dev7ex
+ * @since 26.06.2023
+ */
+@CommandProperties(name = "clone", permission = "multiworld.command.world.clone")
+public class CloneCommand extends BukkitCommand implements TabCompleter {
+
+    public CloneCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (arguments.length != 3) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.clone.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+        if (MultiWorldPlugin.getInstance().getWorldProvider().isRegistered(arguments[2])) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-already-exists")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+        MultiWorldPlugin.getInstance().getWorldManager().cloneWorld(commandSender.getName(), arguments[1], arguments[2]);
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+        if (arguments.length != 2) {
+            return Collections.emptyList();
+        }
+        return new ArrayList<>(MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders().keySet());
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/CreateCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/CreateCommand.java
new file mode 100644
index 0000000..f47de42
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/CreateCommand.java
@@ -0,0 +1,82 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.common.util.Numbers;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.world.WorldType;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author Dev7ex
+ * @since 20.05.2021
+ */
+@CommandProperties(name = "create", permission = "multiworld.command.world.create")
+public class CreateCommand extends BukkitCommand implements TabCompleter {
+
+    public CreateCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (arguments.length != 3) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.create.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+        if (MultiWorldPlugin.getInstance().getWorldProvider().isRegistered(arguments[1])) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-already-exists")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+        if (Numbers.isLong(arguments[2])) {
+            MultiWorldPlugin.getInstance().getWorldManager().createWorld(commandSender.getName(), arguments[1], Long.parseLong(arguments[2]));
+            return true;
+        }
+
+        if (MultiWorldPlugin.getInstance().getWorldGeneratorProvider().exists(arguments[1])) {
+            MultiWorldPlugin.getInstance().getWorldManager().createWorld(commandSender.getName(), arguments[1], arguments[2]);
+            return true;
+        }
+
+        final Optional<WorldType> typeOptional = WorldType.fromString(arguments[2].toUpperCase());
+
+        if (typeOptional.isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-type-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+        MultiWorldPlugin.getInstance().getWorldManager().createWorld(commandSender.getName(), arguments[1], typeOptional.get());
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+        if (arguments.length != 3) {
+            return Collections.emptyList();
+        }
+
+        if (MultiWorldPlugin.getInstance().getWorldGeneratorProvider().getCustomGenerators().isEmpty()) {
+            return WorldType.toStringList();
+        }
+        final List<String> completions = new ArrayList<>();
+        completions.addAll(WorldType.toStringList());
+        completions.addAll(MultiWorldPlugin.getInstance().getWorldGeneratorProvider().getCustomGenerators().values());
+
+        return completions;
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/DeleteCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/DeleteCommand.java
new file mode 100644
index 0000000..e39b726
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/DeleteCommand.java
@@ -0,0 +1,78 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.common.io.Files;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author Dev7ex
+ * @since 20.05.2021
+ */
+@CommandProperties(name = "delete", permission = "multiworld.command.world.delete")
+public class DeleteCommand extends BukkitCommand implements TabCompleter {
+
+    public DeleteCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (arguments.length != 2) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.delete.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+        if (MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(arguments[1]).isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+        final File worldFolder = new File(Bukkit.getWorldContainer(), arguments[1]);
+
+        if(!worldFolder.exists()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+
+        if(!Files.containsFile(worldFolder, "session.lock")) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+
+        if (arguments[1].equalsIgnoreCase(MultiWorldPlugin.getInstance().getConfiguration().getString("settings.defaults.normal-world"))) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.delete.world-cannot-deleted")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+        MultiWorldPlugin.getInstance().getWorldManager().deleteWorld(commandSender.getName(), arguments[1]);
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+        final List<String> worlds = new ArrayList<>(MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders().keySet());
+        worlds.remove(super.getPlugin().getConfiguration().getString("settings.defaults.world"));
+        return worlds;
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/FlagCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/FlagCommand.java
new file mode 100644
index 0000000..a038f3d
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/FlagCommand.java
@@ -0,0 +1,97 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.event.world.WorldFlagChangeEvent;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.world.WorldFlag;
+import com.google.common.collect.Lists;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author Dev7ex
+ * @since 26.06.2023
+ */
+@CommandProperties(name = "flag", permission = "multiworld.command.world.flag")
+public class FlagCommand extends BukkitCommand implements TabCompleter {
+
+    public FlagCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (arguments.length != 4) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.flag.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+        if (MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(arguments[1]).isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+        final Optional<WorldFlag> flagOptional = WorldFlag.fromString(arguments[2].toUpperCase());
+
+        if (flagOptional.isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.flag.not-existing")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+        final BukkitWorldHolder worldHolder = MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(arguments[1]).orElseThrow();
+        final WorldFlag flag = flagOptional.get();
+
+        if (!flag.getValues().contains(arguments[3])) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.flag.value-not-existing")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%flag%", flag.toString()));
+            return true;
+        }
+        final WorldFlagChangeEvent event = new WorldFlagChangeEvent(worldHolder, commandSender, flag, arguments[3]);
+        Bukkit.getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return true;
+        }
+
+        worldHolder.updateFlag(flag, arguments[3]);
+        MultiWorldPlugin.getInstance().getWorldConfiguration().updateFlag(worldHolder, flag, arguments[3]);
+        commandSender.sendMessage(super.getConfiguration().getString("messages.commands.flag.successfully-set")
+                .replaceAll("%prefix%", super.getPrefix())
+                .replaceAll("%flag%", flag.toString())
+                .replaceAll("%value%", arguments[3])
+                .replaceAll("%world_name%", arguments[1]));
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+        if (arguments.length == 2) {
+            return Lists.newArrayList(MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders().keySet());
+        }
+
+        if (arguments.length == 3) {
+            return WorldFlag.toStringList();
+        }
+        final Optional<WorldFlag> flagOptional = WorldFlag.fromString(arguments[2].toUpperCase());
+
+        if (flagOptional.isEmpty()) {
+            return Collections.emptyList();
+        }
+        return Lists.newArrayList(flagOptional.get().getValues());
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/HelpCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/HelpCommand.java
new file mode 100644
index 0000000..3195527
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/HelpCommand.java
@@ -0,0 +1,32 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.BukkitCommon;
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.user.WorldUser;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@CommandProperties(name = "help", permission = "multiworld.command.world")
+public final class HelpCommand extends BukkitCommand {
+
+    public HelpCommand(final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(final CommandSender commandSender, final String[] arguments) {
+        super.getConfiguration().getStringList("messages.commands.help.message").forEach(message -> {
+            commandSender.sendMessage(message.replaceAll("%prefix%", super.getPrefix()));
+        });
+        return true;
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/ImportCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/ImportCommand.java
new file mode 100644
index 0000000..1bf468f
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/ImportCommand.java
@@ -0,0 +1,93 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.common.io.Files;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.world.WorldType;
+import com.google.common.collect.Lists;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * @author Dev7ex
+ * @since 25.05.2021
+ */
+@CommandProperties(name = "import", permission = "multiworld.command.world.import")
+public class ImportCommand extends BukkitCommand implements TabCompleter {
+
+    public ImportCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (arguments.length != 3) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.import.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+        final File worldFolder = new File(Bukkit.getWorldContainer(), arguments[1]);
+
+        if (!Files.containsFile(worldFolder, "level.dat")) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-folder-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%folder%", arguments[1]));
+            return true;
+        }
+
+        if (MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(arguments[1]).isPresent()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.import.world-already-imported")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+        final Optional<WorldType> typeOptional = WorldType.fromString(arguments[2].toUpperCase());
+
+        if (typeOptional.isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-type-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+        MultiWorldPlugin.getInstance().getWorldManager().importWorld(commandSender.getName(), arguments[1], typeOptional.get());
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+        if ((arguments.length < 2) || (arguments.length > 3)) {
+            return Collections.emptyList();
+        }
+
+        if (arguments.length == 3) {
+            return WorldType.toStringList();
+        }
+
+        final List<String> files = Files.toStringList(Bukkit.getWorldContainer());
+        final List<String> completions = Lists.newArrayList(files);
+
+        for (final File folder : Objects.requireNonNull(Bukkit.getWorldContainer().listFiles())) {
+            if (Files.containsFile(folder, "level.dat")) {
+                continue;
+            }
+            completions.remove(folder.getName());
+        }
+
+        for (final String worldName : MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders().keySet()) {
+            completions.remove(worldName);
+        }
+        return completions;
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/InfoCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/InfoCommand.java
new file mode 100644
index 0000000..8d24b15
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/InfoCommand.java
@@ -0,0 +1,69 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @author Dev7ex
+ * @since 24.05.2021
+ */
+@CommandProperties(name = "info", permission = "multiworld.command.world.info")
+public class InfoCommand extends BukkitCommand implements TabCompleter {
+
+    public InfoCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (arguments.length != 2) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.info.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+        if (MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(arguments[1]).isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+        final BukkitWorldHolder worldHolder = MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(arguments[1]).get();
+
+        // TODO: 29.06.2023 NullPointerException if world not loaded [55]
+
+        super.getConfiguration().getStringList("messages.commands.info.message").forEach(message -> {
+            commandSender.sendMessage(message
+                    .replaceAll("%world_name%", worldHolder.getName())
+                    .replaceAll("%world_creator_name%", worldHolder.getCreatorName())
+                    .replaceAll("%creation_timestamp%", new SimpleDateFormat("dd.MM.yyyy HH:mm:ss").format(new Date(worldHolder.getCreationTimeStamp())))
+                    .replaceAll("%loaded%", (worldHolder.isLoaded() ? "true" : "false"))
+                    .replaceAll("%world_type%", worldHolder.getType().toString())
+                    .replaceAll("%environment%", worldHolder.getWorld().getEnvironment().toString())
+                    .replaceAll("%difficulty%", worldHolder.getDifficulty().toString())
+                    .replaceAll("%gamemode%", worldHolder.getGameMode().toString())
+                    .replaceAll("%pvp_enabled%", (worldHolder.isPvpEnabled() ? "true" : "false"))
+                    .replaceAll("%whitelist_enabled%", (worldHolder.isWhitelistEnabled() ? "true" : "false")));
+        });
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+        return new ArrayList<>(MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders().keySet());
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/LinkCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/LinkCommand.java
new file mode 100644
index 0000000..060240a
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/LinkCommand.java
@@ -0,0 +1,160 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldConfiguration;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldProvider;
+import com.dev7ex.multiworld.api.world.WorldEnvironment;
+import com.dev7ex.multiworld.api.world.WorldProperty;
+import com.dev7ex.multiworld.api.world.WorldType;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author Dev7ex
+ * @since 26.06.2023
+ */
+@CommandProperties(name = "link", permission = "multiworld.command.world.link")
+public class LinkCommand extends BukkitCommand implements TabCompleter {
+
+    public LinkCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (arguments.length != 4) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.link.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+        final BukkitWorldProvider worldProvider = MultiWorldPlugin.getInstance().getWorldProvider();
+        final BukkitWorldConfiguration worldConfiguration = MultiWorldPlugin.getInstance().getWorldConfiguration();
+
+        if (worldProvider.getWorldHolder(arguments[1]).isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+
+        final Optional<WorldEnvironment> environmentOptional = WorldEnvironment.fromString(arguments[2].toUpperCase());
+
+        if (environmentOptional.isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.link.environment-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%environment_name%", arguments[2]));
+            return true;
+        }
+        final WorldEnvironment environment = environmentOptional.get();
+
+        if (worldProvider.getWorldHolder(arguments[3]).isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[3]));
+            return true;
+        }
+        final BukkitWorldHolder worldHolder = worldProvider.getWorldHolder(arguments[1]).get();
+
+        switch (environment) {
+            case THE_END:
+                worldHolder.setEndWorldName(arguments[3]);
+                worldConfiguration.write(worldHolder, WorldProperty.END_WORLD, arguments[3]);
+
+                commandSender.sendMessage(super.getConfiguration().getString("messages.commands.link.successfully-set")
+                        .replaceAll("%prefix%", super.getPrefix())
+                        .replaceAll("%world_name%", arguments[1])
+                        .replaceAll("%environment_name%", arguments[2])
+                        .replaceAll("%target_world_name%", arguments[3]));
+                return true;
+
+            case NETHER:
+                worldHolder.setNetherWorldName(arguments[3]);
+                worldConfiguration.write(worldHolder, WorldProperty.NETHER_WORLD, arguments[3]);
+
+                commandSender.sendMessage(super.getConfiguration().getString("messages.commands.link.successfully-set")
+                        .replaceAll("%prefix%", super.getPrefix())
+                        .replaceAll("%world_name%", arguments[1])
+                        .replaceAll("%environment_name%", arguments[2])
+                        .replaceAll("%target_world_name%", arguments[3]));
+                return true;
+
+            case NORMAL:
+                worldHolder.setNormalWorldName(arguments[3]);
+                worldConfiguration.write(worldHolder, WorldProperty.NORMAL_WORLD, arguments[3]);
+
+                commandSender.sendMessage(super.getConfiguration().getString("messages.commands.link.successfully-set")
+                        .replaceAll("%prefix%", super.getPrefix())
+                        .replaceAll("%world_name%", arguments[1])
+                        .replaceAll("%environment_name%", arguments[2])
+                        .replaceAll("%target_world_name%", arguments[3]));
+                return true;
+
+            default:
+                commandSender.sendMessage(super.getConfiguration().getString("messages.commands.link.usage")
+                        .replaceAll("%prefix%", super.getPrefix()));
+                return true;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+
+        if (arguments.length == 2) {
+            return new ArrayList<>(MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders().keySet());
+        }
+
+        if (arguments.length == 3) {
+            return WorldEnvironment.toStringList();
+        }
+
+        if (arguments.length == 4) {
+            final Optional<WorldEnvironment> environmentOptional = WorldEnvironment.fromString(arguments[2]);
+
+            if (environmentOptional.isEmpty()) {
+                return Collections.emptyList();
+            }
+            final WorldEnvironment environment = environmentOptional.get();
+
+            switch (environment) {
+                case NETHER:
+                    return MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders()
+                            .values()
+                            .stream()
+                            .filter(worldHolder -> worldHolder.getType() == WorldType.NETHER)
+                            .map(BukkitWorldHolder::getName)
+                            .toList();
+
+                case NORMAL:
+                    return MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders()
+                            .values()
+                            .stream()
+                            .filter(worldHolder -> worldHolder.getType().isOverWorld())
+                            .map(BukkitWorldHolder::getName)
+                            .toList();
+
+                case THE_END:
+                    return MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders()
+                            .values()
+                            .stream()
+                            .filter(worldHolder -> worldHolder.getType() == WorldType.END)
+                            .map(BukkitWorldHolder::getName)
+                            .toList();
+            }
+
+        }
+        return Collections.emptyList();
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/ListCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/ListCommand.java
new file mode 100644
index 0000000..eb2bf6e
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/ListCommand.java
@@ -0,0 +1,48 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import net.md_5.bungee.api.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Set;
+
+/**
+ * @author Dev7ex
+ * @since 20.05.2021
+ */
+@CommandProperties(name = "list", permission = "multiworld.command.world.list")
+public class ListCommand extends BukkitCommand {
+
+    public ListCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (arguments.length != 1) {
+            return true;
+        }
+
+        final StringBuilder stringBuilder = new StringBuilder();
+        final Set<String> worldEntries = MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders().keySet();
+
+        for (final String worldEntry : worldEntries) {
+            final BukkitWorldHolder worldHolder = MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(worldEntry).orElseThrow();
+
+            if (stringBuilder.length() > 0) {
+                stringBuilder.append(ChatColor.GRAY);
+                stringBuilder.append(", ");
+            }
+            stringBuilder.append(worldHolder.isLoaded() ? ChatColor.GREEN : ChatColor.RED).append(worldEntry);
+        }
+        commandSender.sendMessage(super.getPrefix() + "§7Worlds: " + stringBuilder);
+        return true;
+
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/LoadCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/LoadCommand.java
new file mode 100644
index 0000000..4724d28
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/LoadCommand.java
@@ -0,0 +1,58 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * @author Dev7ex
+ * @since 20.05.2021
+ */
+@CommandProperties(name = "load", permission = "multiworld.command.world.load")
+public class LoadCommand extends BukkitCommand implements TabCompleter {
+
+    public LoadCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (arguments.length != 2) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.load.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+        if (MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(arguments[1]).isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+
+        if (Bukkit.getWorld(arguments[1]) != null) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.load.world-already-loaded")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+        MultiWorldPlugin.getInstance().getWorldManager().loadWorld(commandSender.getName(), arguments[1]);
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+        return MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders().values().stream().filter(bukkitWorldHolder -> !bukkitWorldHolder.isLoaded()).map(BukkitWorldHolder::getName).toList();
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/ReloadCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/ReloadCommand.java
new file mode 100644
index 0000000..283aa02
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/ReloadCommand.java
@@ -0,0 +1,33 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 28.12.2022
+ */
+@CommandProperties(name = "reload", permission = "multiworld.command.world.reload")
+public class ReloadCommand extends BukkitCommand {
+
+    public ReloadCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (arguments.length != 1) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.reload.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+        super.getConfiguration().load();
+        commandSender.sendMessage(super.getConfiguration().getString("messages.commands.reload.message")
+                .replaceAll("%prefix%", super.getPrefix()));
+        return true;
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/TeleportCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/TeleportCommand.java
new file mode 100644
index 0000000..ee3ce1b
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/TeleportCommand.java
@@ -0,0 +1,179 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.event.user.WorldUserTeleportWorldEvent;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.user.WorldUser;
+import com.dev7ex.multiworld.world.DefaultWorldProvider;
+import com.google.common.collect.Lists;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author Dev7ex
+ * @since 20.05.2021
+ */
+@CommandProperties(name = "teleport", permission = "multiworld.command.world.teleport")
+public class TeleportCommand extends BukkitCommand implements TabCompleter {
+
+    public TeleportCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        // /world teleport <World> || /world teleport <Player> <World>
+        if ((arguments.length < 2) || (arguments.length > 3)) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.teleport.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+        final DefaultWorldProvider worldProvider = MultiWorldPlugin.getInstance().getWorldProvider();
+
+        if (arguments.length == 2) {
+            if (!(commandSender instanceof Player)) {
+                commandSender.sendMessage(super.getConfiguration().getString("only-player-command")
+                        .replaceAll("%prefix%", super.getPrefix()));
+                return true;
+            }
+            final Player player = (Player) commandSender;
+            final WorldUser user = MultiWorldPlugin.getInstance().getUserProvider().getUser(player.getUniqueId()).orElseThrow();
+
+            if (MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(arguments[1]).isEmpty()) {
+                commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                        .replaceAll("%prefix%", super.getPrefix())
+                        .replaceAll("%world_name%", arguments[1]));
+                return true;
+            }
+
+            if (Bukkit.getWorld(arguments[1]) == null) {
+                commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-loaded")
+                        .replaceAll("%prefix%", super.getPrefix())
+                        .replaceAll("%world_name%", arguments[1]));
+                return true;
+            }
+            final World world = Bukkit.getWorld(arguments[1]);
+            final BukkitWorldHolder lastWorldHolder = worldProvider.getWorldHolder(player.getLocation().getWorld().getName()).orElseThrow();
+            final BukkitWorldHolder nextWorldHolder = worldProvider.getWorldHolder(arguments[1]).orElseThrow();
+
+            if (player.getLocation().getWorld().getName().equalsIgnoreCase(arguments[1])) {
+                commandSender.sendMessage(super.getConfiguration().getString("messages.commands.teleport.sender-already-there")
+                        .replaceAll("%prefix%", super.getPrefix())
+                        .replaceAll("%world_name%", arguments[1]));
+                return true;
+            }
+
+            if ((world.getEnvironment() == World.Environment.NETHER) && (!super.getConfiguration().getBoolean("settings.access-nether-world-via-command"))) {
+                commandSender.sendMessage(super.getConfiguration().getString("messages.commands.teleport.nether-not-accessible")
+                        .replaceAll("%prefix%", super.getPrefix()));
+                return true;
+            }
+
+            if ((world.getEnvironment() == World.Environment.THE_END) && (!super.getConfiguration().getBoolean("settings.access-end-world-via-command"))) {
+                commandSender.sendMessage(super.getConfiguration().getString("messages.commands.teleport.end-not-accessible")
+                        .replaceAll("%prefix%", super.getPrefix()));
+                return true;
+            }
+
+            final WorldUserTeleportWorldEvent event = new WorldUserTeleportWorldEvent(user, lastWorldHolder, nextWorldHolder);
+            Bukkit.getPluginManager().callEvent(event);
+
+            if (event.isCancelled()) {
+                return true;
+            }
+            player.teleport(nextWorldHolder.getWorld().getSpawnLocation());
+            return true;
+        }
+
+        final Player target = Bukkit.getPlayer(arguments[1]);
+
+        if (target == null) {
+            commandSender.sendMessage(super.getConfiguration().getString("player-not-found")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+        final WorldUser user = MultiWorldPlugin.getInstance().getUserProvider().getUser(target.getUniqueId()).orElseThrow();
+
+        if (MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(arguments[2]).isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+
+        if (Bukkit.getWorld(arguments[2]) == null) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-loaded")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+        final World world = Bukkit.getWorld(arguments[2]);
+
+        if (target.getLocation().getWorld().getName().equalsIgnoreCase(arguments[2])) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.teleport.target-already-there")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%player_name%", arguments[1])
+                    .replaceAll("%world_name%", arguments[2]));
+            return true;
+        }
+
+        if ((world.getEnvironment() == World.Environment.NETHER) && (!super.getConfiguration().getBoolean("settings.access-nether-world-via-command"))) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.teleport.nether-not-accessible")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+        if ((world.getEnvironment() == World.Environment.THE_END) && (!super.getConfiguration().getBoolean("settings.access-end-world-via-command"))) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.teleport.end-not-accessible")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+        final BukkitWorldHolder lastWorldHolder = worldProvider.getWorldHolder(target.getLocation().getWorld().getName()).orElseThrow();
+        final BukkitWorldHolder nextWorldHolder = worldProvider.getWorldHolder(arguments[2]).orElseThrow();
+        final WorldUserTeleportWorldEvent event = new WorldUserTeleportWorldEvent(user, lastWorldHolder, nextWorldHolder);
+        Bukkit.getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return true;
+        }
+        target.teleport(nextWorldHolder.getWorld().getSpawnLocation());
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+        if ((arguments.length < 2) || (arguments.length > 3)) {
+            return Collections.emptyList();
+        }
+        final List<String> completions = Lists.newArrayList(MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders().keySet());
+
+        if (arguments.length == 2) {
+            if (commandSender instanceof Player player) {
+                completions.remove(player.getWorld().getName());
+                return completions;
+
+            } else {
+                return Bukkit.getOnlinePlayers().stream().map(HumanEntity::getName).toList();
+            }
+        }
+
+        if (commandSender instanceof Player) {
+            return Collections.emptyList();
+        }
+        return completions;
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/UnloadCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/UnloadCommand.java
new file mode 100644
index 0000000..d71e20a
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/UnloadCommand.java
@@ -0,0 +1,65 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * @author Dev7ex
+ * @since 20.05.2021
+ */
+@CommandProperties(name = "unload", permission = "multiworld.command.world.unload")
+public class UnloadCommand extends BukkitCommand implements TabCompleter {
+
+    public UnloadCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if (arguments.length != 2) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.load.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+
+        if (MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(arguments[1]).isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+
+        if (arguments[1].equalsIgnoreCase(MultiWorldPlugin.getInstance().getConfiguration().getString("settings.defaults.normal-world"))) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.unload.world-cannot-unloaded")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+
+        if (Bukkit.getWorld(arguments[1]) == null) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-loaded")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+        }
+        MultiWorldPlugin.getInstance().getWorldManager().unloadWorld(commandSender.getName(), arguments[1]);
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+        return MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders().values().stream().filter(BukkitWorldHolder::isLoaded).map(BukkitWorldHolder::getName).toList();
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/WhitelistCommand.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/WhitelistCommand.java
new file mode 100644
index 0000000..43a8d17
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/command/world/WhitelistCommand.java
@@ -0,0 +1,171 @@
+package com.dev7ex.multiworld.command.world;
+
+import com.dev7ex.common.bukkit.command.BukkitCommand;
+import com.dev7ex.common.bukkit.command.CommandProperties;
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.world.WorldProperty;
+import com.dev7ex.multiworld.world.DefaultWorldConfiguration;
+import net.md_5.bungee.api.ChatColor;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.HumanEntity;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author Dev7ex
+ * @since 29.06.2023
+ */
+@CommandProperties(name = "whitelist", permission = "multiworld.command.world.whitelist")
+public class WhitelistCommand extends BukkitCommand implements TabCompleter {
+
+    public WhitelistCommand(@NotNull final BukkitPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender, @NotNull final String[] arguments) {
+        if ((arguments.length < 3) || (arguments.length > 4)) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.usage")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            return true;
+        }
+
+        if (MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(arguments[1]).isEmpty()) {
+            commandSender.sendMessage(super.getConfiguration().getString("messages.general.world-not-exists")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%world_name%", arguments[1]));
+            return true;
+        }
+        final DefaultWorldConfiguration worldConfiguration = MultiWorldPlugin.getInstance().getWorldConfiguration();
+        final BukkitWorldHolder worldHolder = MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolder(arguments[1]).orElseThrow();
+
+        if (arguments.length == 3) {
+            switch (arguments[2]) {
+                case "enable":
+                case "on":
+                    if (worldHolder.isWhitelistEnabled()) {
+                        commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.enable.already-enabled")
+                                .replaceAll("%prefix%", super.getPrefix())
+                                .replaceAll("%world_name%", arguments[1]));
+                        return true;
+                    }
+                    worldHolder.setWhitelistEnabled(true);
+                    worldConfiguration.write(worldHolder, WorldProperty.WHITELIST_ENABLED, true);
+                    commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.enable.successfully-enabled")
+                            .replaceAll("%prefix%", super.getPrefix())
+                            .replaceAll("%world_name%", arguments[1]));
+                    return true;
+
+                case "disable":
+                case "off":
+                    if (!worldHolder.isWhitelistEnabled()) {
+                        commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.disable.already-disabled")
+                                .replaceAll("%prefix%", super.getPrefix())
+                                .replaceAll("%world_name%", arguments[1]));
+                        return true;
+                    }
+                    worldHolder.setWhitelistEnabled(false);
+                    worldConfiguration.write(worldHolder, WorldProperty.WHITELIST_ENABLED, false);
+                    commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.disable.successfully-disabled")
+                            .replaceAll("%prefix%", super.getPrefix())
+                            .replaceAll("%world_name%", arguments[1]));
+                    return true;
+
+                case "list":
+                    if (worldHolder.getWhitelist().isEmpty()) {
+                        commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.list.empty")
+                                .replaceAll("%prefix%", super.getPrefix())
+                                .replaceAll("%world_name%", arguments[1]));
+                        return true;
+                    }
+                    final StringBuilder stringBuilder = new StringBuilder();
+
+                    for (final String name : worldHolder.getWhitelist()) {
+                        if (stringBuilder.length() > 0) {
+                            stringBuilder.append(ChatColor.GRAY);
+                            stringBuilder.append(", ");
+                        }
+                        stringBuilder.append(Bukkit.getPlayer(name) != null ? ChatColor.GREEN : ChatColor.RED).append(name);
+                    }
+                    commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.list.message")
+                            .replaceAll("%prefix%", super.getPrefix())
+                            .replaceAll("%world_name%", arguments[1])
+                            .replaceAll("%player_names%", stringBuilder.toString()));
+                    return true;
+
+                default:
+                    commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.usage")
+                            .replaceAll("%prefix%", super.getPrefix()));
+                    return true;
+            }
+        }
+
+        switch (arguments[2]) {
+            case "add":
+                if (worldHolder.getWhitelist().contains(arguments[3])) {
+                    commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.add.already-added")
+                            .replaceAll("%prefix%", super.getPrefix())
+                            .replaceAll("%world_name%", arguments[1])
+                            .replaceAll("%player_name%", arguments[3]));
+                    return true;
+                }
+                worldHolder.getWhitelist().add(arguments[3]);
+                worldConfiguration.write(worldHolder, WorldProperty.WHITELIST, worldHolder.getWhitelist());
+                commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.add.successfully-added")
+                        .replaceAll("%prefix%", super.getPrefix())
+                        .replaceAll("%world_name%", arguments[1])
+                        .replaceAll("%player_name%", arguments[3]));
+                return true;
+
+            case "remove":
+                if (!worldHolder.getWhitelist().contains(arguments[3])) {
+                    commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.remove.already-removed")
+                            .replaceAll("%prefix%", super.getPrefix())
+                            .replaceAll("%world_name%", arguments[1])
+                            .replaceAll("%player_name%", arguments[3]));
+                    return true;
+                }
+                worldHolder.getWhitelist().remove(arguments[3]);
+                worldConfiguration.write(worldHolder, WorldProperty.WHITELIST, worldHolder.getWhitelist());
+                commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.remove.successfully-removed")
+                        .replaceAll("%prefix%", super.getPrefix())
+                        .replaceAll("%world_name%", arguments[1])
+                        .replaceAll("%player_name%", arguments[3]));
+                return true;
+
+            default:
+                commandSender.sendMessage(super.getConfiguration().getString("messages.commands.whitelist.usage")
+                        .replaceAll("%prefix%", super.getPrefix()));
+                return true;
+        }
+    }
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender, @NotNull final Command command,
+                                      @NotNull final String commandLabel, @NotNull final String[] arguments) {
+
+        if ((arguments.length < 2) || (arguments.length > 4)) {
+            return Collections.emptyList();
+        }
+
+        if (arguments.length == 2) {
+            return new ArrayList<>(MultiWorldPlugin.getInstance().getWorldProvider().getWorldHolders().keySet());
+        }
+
+        if (arguments.length == 3) {
+            return List.of("enable", "disable", "add", "list", "remove");
+        }
+        return Bukkit.getOnlinePlayers().stream().map(HumanEntity::getName).toList();
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/listener/PlayerConnectionListener.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/listener/PlayerConnectionListener.java
new file mode 100644
index 0000000..458247e
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/listener/PlayerConnectionListener.java
@@ -0,0 +1,70 @@
+package com.dev7ex.multiworld.listener;
+
+import com.dev7ex.common.map.ParsedMap;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.MultiWorldBukkitApi;
+import com.dev7ex.multiworld.api.bukkit.event.MultiWorldListener;
+import com.dev7ex.multiworld.api.user.WorldUser;
+import com.dev7ex.multiworld.api.user.WorldUserConfiguration;
+import com.dev7ex.multiworld.api.user.WorldUserProperty;
+import com.dev7ex.multiworld.user.User;
+import com.dev7ex.multiworld.user.UserConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerLoginEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public class PlayerConnectionListener extends MultiWorldListener {
+
+    public PlayerConnectionListener(@NotNull final MultiWorldBukkitApi multiWorldApi) {
+        super(multiWorldApi);
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void handlePlayerLogin(final PlayerLoginEvent event) {
+        final Player player = event.getPlayer();
+        final WorldUser user = new User(player.getUniqueId(), player.getName());
+        final WorldUserConfiguration userConfiguration = new UserConfiguration(user);
+        final ParsedMap<WorldUserProperty, Object> userData = userConfiguration.read(WorldUserProperty.LAST_LOCATION);
+
+        user.setLastLocation(userData.getValue(WorldUserProperty.LAST_LOCATION));
+        user.setConfiguration(userConfiguration);
+
+        super.getUserProvider().registerUser(user);
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void handlePlayerLogin(final PlayerJoinEvent event) {
+        final Player player = event.getPlayer();
+
+        if ((super.getConfiguration().getBoolean("settings.receive-update-message"))
+                && (player.hasPermission("multiworld.update.notify"))
+                && (MultiWorldPlugin.getInstance().getUpdateChecker().isUpdateAvailable())) {
+
+            player.sendMessage(super.getConfiguration().getString("messages.general.update-message-player")
+                    .replaceAll("%prefix%", super.getPrefix()));
+            player.sendMessage(super.getConfiguration().getString("messages.general.update-message-version-player")
+                    .replaceAll("%prefix%", super.getPrefix())
+                    .replaceAll("%current_version%", MultiWorldPlugin.getInstance().getDescription().getVersion())
+                    .replaceAll("%new_version%", MultiWorldPlugin.getInstance().getUpdateChecker().getNewVersion()));
+            return;
+        }
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void handlePlayerQuit(final PlayerQuitEvent event) {
+        final Player player = event.getPlayer();
+        final WorldUser user = super.getUserProvider().getUser(player.getUniqueId()).orElseThrow();
+
+        super.getUserProvider().saveUser(user, WorldUserProperty.LAST_LOCATION);
+        super.getUserProvider().unregisterUser(player.getUniqueId());
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/listener/PlayerDamagePlayerListener.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/listener/PlayerDamagePlayerListener.java
new file mode 100644
index 0000000..92dbfe1
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/listener/PlayerDamagePlayerListener.java
@@ -0,0 +1,58 @@
+package com.dev7ex.multiworld.listener;
+
+import com.dev7ex.multiworld.api.bukkit.MultiWorldBukkitApi;
+import com.dev7ex.multiworld.api.bukkit.event.MultiWorldListener;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 29.06.2023
+ */
+public class PlayerDamagePlayerListener extends MultiWorldListener {
+
+    public PlayerDamagePlayerListener(@NotNull final MultiWorldBukkitApi multiWorldApi) {
+        super(multiWorldApi);
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void handlePlayerDamagePlayer(final EntityDamageByEntityEvent event) {
+        if (event.getEntity().getType() != EntityType.PLAYER) {
+            return;
+        }
+        final Player player = (Player) event.getEntity();
+
+        if (super.getWorldProvider().getWorldHolder(player.getWorld().getName()).isEmpty()) {
+            return;
+        }
+        final BukkitWorldHolder worldHolder = super.getWorldProvider().getWorldHolder(player.getWorld().getName()).orElseThrow();
+
+        if (worldHolder.isPvpEnabled()) {
+            return;
+        }
+
+        if (event.getDamager() instanceof Projectile) {
+            final Projectile projectile = (Projectile) event.getDamager();
+
+            if (projectile.getShooter() == null) {
+                return;
+            }
+
+            if (projectile.getShooter() instanceof Player) {
+                event.setCancelled(true);
+            }
+        }
+
+        if (event.getDamager().getType() == EntityType.PLAYER) {
+            event.setCancelled(true);
+        }
+
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/listener/PlayerEnterPortalListener.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/listener/PlayerEnterPortalListener.java
new file mode 100644
index 0000000..800327a
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/listener/PlayerEnterPortalListener.java
@@ -0,0 +1,113 @@
+package com.dev7ex.multiworld.listener;
+
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.MultiWorldBukkitApi;
+import com.dev7ex.multiworld.api.bukkit.event.MultiWorldListener;
+import com.dev7ex.multiworld.api.bukkit.event.user.WorldUserEnterPortalEvent;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.user.WorldUser;
+import org.bukkit.Bukkit;
+import org.bukkit.PortalType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.player.PlayerPortalEvent;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 26.06.2023
+ */
+public class PlayerEnterPortalListener extends MultiWorldListener {
+
+    public PlayerEnterPortalListener(@NotNull final MultiWorldBukkitApi multiWorldApi) {
+        super(multiWorldApi);
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void handlePlayerPortal(final PlayerPortalEvent event) {
+        final BukkitWorldHolder fromWorldHolder = super.getWorldProvider().getWorldHolder(event.getFrom().getWorld().getName()).orElseThrow();
+        final Player player = event.getPlayer();
+        final WorldUser user = super.getUserProvider().getUser(player.getUniqueId()).orElseThrow();
+
+        if (event.getTo() == null) {
+            return;
+        }
+
+        if (event.getTo().getWorld() == null) {
+            return;
+        }
+
+        switch (event.getTo().getWorld().getEnvironment()) {
+            case NETHER:
+                if (fromWorldHolder.getNetherWorldName() == null) {
+                    MultiWorldPlugin.getInstance().getLogger().warning("Player: " + player.getName() + " try to enter the nether-world of " + fromWorldHolder.getName() + " but is null!");
+                    event.setCancelled(true);
+                    return;
+                }
+
+                if (super.getWorldProvider().getWorldHolder(fromWorldHolder.getNetherWorldName()).isEmpty()) {
+                    MultiWorldPlugin.getInstance().getLogger().warning("Player: " + player.getName() + " try to enter the nether-world of " + fromWorldHolder.getName() + " but the world not exists!");
+                    event.setCancelled(true);
+                    return;
+                }
+                final BukkitWorldHolder netherWorldHolder = super.getWorldProvider().getWorldHolder(fromWorldHolder.getNetherWorldName()).get();
+
+                if (!netherWorldHolder.isLoaded()) {
+                    MultiWorldPlugin.getInstance().getLogger().warning("Player: " + player.getName() + " try to enter the nether-world of " + fromWorldHolder.getName() + " but the world is not loaded!");
+                    event.setCancelled(true);
+                    return;
+                }
+                Bukkit.getPluginManager().callEvent(new WorldUserEnterPortalEvent(user, fromWorldHolder, netherWorldHolder, PortalType.NETHER));
+                event.setTo(netherWorldHolder.getWorld().getSpawnLocation());
+                break;
+
+            case NORMAL:
+                if (fromWorldHolder.getNormalWorldName() == null) {
+                    MultiWorldPlugin.getInstance().getLogger().warning("Player: " + player.getName() + " try to enter the normal-world of " + fromWorldHolder.getName() + " but is null!");
+                    event.setCancelled(true);
+                    event.setCancelled(true);
+                }
+
+                if (super.getWorldProvider().getWorldHolder(fromWorldHolder.getNormalWorldName()).isEmpty()) {
+                    MultiWorldPlugin.getInstance().getLogger().warning("Player: " + player.getName() + " try to enter the normal-world of " + fromWorldHolder.getName() + " but the world not exists!");
+                    event.setCancelled(true);
+                    return;
+                }
+                final BukkitWorldHolder normalWorldHolder = super.getWorldProvider().getWorldHolder(fromWorldHolder.getNormalWorldName()).get();
+
+                if (!normalWorldHolder.isLoaded()) {
+                    MultiWorldPlugin.getInstance().getLogger().warning("Player: " + player.getName() + " try to enter the normal-world of " + fromWorldHolder.getName() + " but the world is not loaded!");
+                    event.setCancelled(true);
+                    return;
+                }
+                Bukkit.getPluginManager().callEvent(new WorldUserEnterPortalEvent(user, fromWorldHolder, normalWorldHolder, PortalType.CUSTOM));
+                event.setTo(normalWorldHolder.getWorld().getSpawnLocation());
+                break;
+
+            case THE_END:
+                if (fromWorldHolder.getEndWorldName() == null) {
+                    MultiWorldPlugin.getInstance().getLogger().warning("Player: " + player.getName() + " try to enter the end-world of " + fromWorldHolder.getName() + " but is null!");
+                    event.setCancelled(true);
+                }
+
+                if (super.getWorldProvider().getWorldHolder(fromWorldHolder.getEndWorldName()).isEmpty()) {
+                    MultiWorldPlugin.getInstance().getLogger().warning("Player: " + player.getName() + " try to enter the end-world of " + fromWorldHolder.getName() + " but the world not exists!");
+                    event.setCancelled(true);
+                    return;
+                }
+                final BukkitWorldHolder endWorldHolder = super.getWorldProvider().getWorldHolder(fromWorldHolder.getEndWorldName()).get();
+
+                if (!endWorldHolder.isLoaded()) {
+                    MultiWorldPlugin.getInstance().getLogger().warning("Player: " + player.getName() + " try to enter the end-world of " + fromWorldHolder.getName() + " but the world is not loaded!");
+                    event.setCancelled(true);
+                    return;
+                }
+                Bukkit.getPluginManager().callEvent(new WorldUserEnterPortalEvent(user, fromWorldHolder, endWorldHolder, PortalType.ENDER));
+                event.setTo(endWorldHolder.getWorld().getSpawnLocation());
+                break;
+        }
+
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/listener/UserTeleportWorldListener.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/listener/UserTeleportWorldListener.java
new file mode 100644
index 0000000..b04eebc
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/listener/UserTeleportWorldListener.java
@@ -0,0 +1,61 @@
+package com.dev7ex.multiworld.listener;
+
+import com.dev7ex.multiworld.api.bukkit.MultiWorldBukkitApi;
+import com.dev7ex.multiworld.api.bukkit.event.MultiWorldListener;
+import com.dev7ex.multiworld.api.bukkit.event.user.WorldUserTeleportWorldEvent;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.bukkit.world.location.BukkitWorldLocation;
+import com.dev7ex.multiworld.api.user.WorldUser;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Dev7ex
+ * @since 29.06.2023
+ */
+public class UserTeleportWorldListener extends MultiWorldListener {
+
+    public UserTeleportWorldListener(@NotNull final MultiWorldBukkitApi multiWorldApi) {
+        super(multiWorldApi);
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void handleUserGameModeChange(final WorldUserTeleportWorldEvent event) {
+        if (!super.getConfiguration().isAutoGameModeEnabled()) {
+            return;
+        }
+
+        final Player player = Bukkit.getPlayer(event.getUser().getUniqueId());
+        player.setGameMode(event.getNextWorldHolder().getGameMode());
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void handleUserEnterWorld(final WorldUserTeleportWorldEvent event) {
+        final WorldUser user = event.getUser();
+        final Player player = Bukkit.getPlayer(user.getUniqueId());
+        final BukkitWorldHolder nextWorldHolder = event.getNextWorldHolder();
+
+        user.setLastLocation(BukkitWorldLocation.of(player.getLocation()));
+
+        if (!nextWorldHolder.isWhitelistEnabled()) {
+            return;
+        }
+
+        if (nextWorldHolder.getWhitelist().contains(user.getName())) {
+            return;
+        }
+
+        if (player.hasPermission("multiworld.whitelist.ignore")) {
+            return;
+        }
+        user.setLastLocation(null);
+        player.sendMessage(super.getConfiguration().getString("messages.general.world-whitelist-block-trespassing")
+                .replaceAll("%prefix%", super.getPrefix())
+                .replaceAll("%world_name%", nextWorldHolder.getName()));
+        event.setCancelled(true);
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/user/User.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/user/User.java
new file mode 100644
index 0000000..41c49b9
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/user/User.java
@@ -0,0 +1,45 @@
+package com.dev7ex.multiworld.user;
+
+import com.dev7ex.common.bukkit.entity.EntityResolver;
+import com.dev7ex.multiworld.api.user.WorldUser;
+import com.dev7ex.multiworld.api.user.WorldUserConfiguration;
+import com.dev7ex.multiworld.api.world.location.WorldLocation;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.UUID;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+@Setter(AccessLevel.PUBLIC)
+public class User implements WorldUser, EntityResolver<Player> {
+
+    private final UUID uniqueId;
+    private final String name;
+    private WorldUserConfiguration configuration;
+    private WorldLocation lastLocation;
+
+    public User(@NotNull final UUID uniqueId, @NotNull final String name) {
+        this.uniqueId = uniqueId;
+        this.name = name;
+    }
+
+    @Override
+    public void sendMessage(@NotNull final String message) {
+        this.getEntity().sendMessage(message);
+    }
+
+    @Override
+    public Player getEntity() {
+        return Bukkit.getPlayer(this.uniqueId);
+    }
+
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/user/UserConfiguration.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/user/UserConfiguration.java
new file mode 100644
index 0000000..5158956
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/user/UserConfiguration.java
@@ -0,0 +1,119 @@
+package com.dev7ex.multiworld.user;
+
+import com.dev7ex.common.map.ParsedMap;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.world.location.BukkitWorldLocation;
+import com.dev7ex.multiworld.api.user.WorldUser;
+import com.dev7ex.multiworld.api.user.WorldUserConfiguration;
+import com.dev7ex.multiworld.api.user.WorldUserProperty;
+import lombok.SneakyThrows;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.UUID;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+public class UserConfiguration implements WorldUserConfiguration {
+
+    private final File configurationFile;
+    private final YamlConfiguration fileConfiguration;
+
+    @SneakyThrows
+    public UserConfiguration(@NotNull final WorldUser user) {
+        this.configurationFile = new File(MultiWorldPlugin.getInstance().getSubFolder("user")
+                + File.separator + user.getUniqueId().toString() + ".yml");
+
+        if (!this.configurationFile.exists()) {
+            this.configurationFile.createNewFile();
+        }
+        this.fileConfiguration = YamlConfiguration.loadConfiguration(this.configurationFile);
+        this.fileConfiguration.addDefault(WorldUserProperty.UNIQUE_ID.getStoragePath(), user.getUniqueId().toString());
+        this.fileConfiguration.addDefault(WorldUserProperty.NAME.getStoragePath(), user.getName());
+        this.fileConfiguration.addDefault(WorldUserProperty.LAST_LOCATION.getStoragePath(), null);
+        this.fileConfiguration.options().copyDefaults(true);
+        this.saveFile();
+    }
+
+    @Override
+    public ParsedMap<WorldUserProperty, Object> read() {
+        final ParsedMap<WorldUserProperty, Object> userData = new ParsedMap<>();
+
+        Arrays.stream(WorldUserProperty.values()).forEach(property -> {
+            switch (property) {
+                case UNIQUE_ID:
+                    userData.put(property, UUID.fromString(Objects.requireNonNull(this.fileConfiguration.getString(property.getStoragePath()))));
+                    break;
+
+                case NAME:
+                    userData.put(property, this.fileConfiguration.getString(property.getStoragePath()));
+                    break;
+
+                case LAST_LOCATION:
+                    userData.put(property, this.fileConfiguration.getSerializable(property.getStoragePath(), BukkitWorldLocation.class));
+                    break;
+            }
+        });
+        return userData;
+    }
+
+    @Override
+    public ParsedMap<WorldUserProperty, Object> read(final WorldUserProperty... properties) {
+        if (properties == null) {
+            return this.read();
+        }
+        final ParsedMap<WorldUserProperty, Object> userData = new ParsedMap<>();
+
+        for (final WorldUserProperty property : properties) {
+            switch (property) {
+                case UNIQUE_ID:
+                    userData.put(property, UUID.fromString(Objects.requireNonNull(this.fileConfiguration.getString(property.getStoragePath()))));
+                    break;
+
+                case NAME:
+                    userData.put(property, this.fileConfiguration.getString(property.getStoragePath()));
+                    break;
+
+                case LAST_LOCATION:
+                    userData.put(property, this.fileConfiguration.getSerializable(property.getStoragePath(), BukkitWorldLocation.class));
+                    break;
+
+                default:
+                    break;
+            }
+        }
+        return userData;
+    }
+
+    @Override
+    public void write(final ParsedMap<WorldUserProperty, Object> userData) {
+        for (final WorldUserProperty property : userData.keySet()) {
+            switch (property) {
+                case UNIQUE_ID:
+                    this.fileConfiguration.set(property.getStoragePath(), userData.getUUID(property).toString());
+                    break;
+
+                case NAME:
+                    this.fileConfiguration.set(property.getStoragePath(), userData.getString(property));
+                    break;
+
+                case LAST_LOCATION:
+                    this.fileConfiguration.set(property.getStoragePath(), userData.get(property));
+                    break;
+            }
+        }
+        this.saveFile();
+    }
+
+    @Override
+    @SneakyThrows
+    public void saveFile() {
+        this.fileConfiguration.save(this.configurationFile);
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/user/UserService.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/user/UserService.java
new file mode 100644
index 0000000..4d6e823
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/user/UserService.java
@@ -0,0 +1,104 @@
+package com.dev7ex.multiworld.user;
+
+import com.dev7ex.common.bukkit.plugin.service.PluginService;
+import com.dev7ex.common.map.ParsedMap;
+import com.dev7ex.multiworld.api.user.WorldUser;
+import com.dev7ex.multiworld.api.user.WorldUserConfiguration;
+import com.dev7ex.multiworld.api.user.WorldUserProperty;
+import com.dev7ex.multiworld.api.user.WorldUserProvider;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+public class UserService implements PluginService, WorldUserProvider {
+
+    private final Map<UUID, WorldUser> users = new HashMap<>();
+
+    @Override
+    public void onEnable() {
+        for (final Player player : Bukkit.getOnlinePlayers()) {
+            final WorldUser user = new User(player.getUniqueId(), player.getName());
+            final WorldUserConfiguration userConfiguration = new UserConfiguration(user);
+            final ParsedMap<WorldUserProperty, Object> userData = userConfiguration.read(WorldUserProperty.LAST_LOCATION);
+
+            user.setLastLocation(userData.getValue(WorldUserProperty.LAST_LOCATION));
+            user.setConfiguration(userConfiguration);
+
+            this.registerUser(user);
+        }
+    }
+
+    @Override
+    public void onDisable() {
+        for (final WorldUser user : this.users.values()) {
+            this.saveUser(user, WorldUserProperty.LAST_LOCATION);
+        }
+        this.users.clear();
+    }
+
+    @Override
+    public void registerUser(@NotNull final WorldUser user) {
+        this.users.put(user.getUniqueId(), user);
+    }
+
+    @Override
+    public void unregisterUser(@NotNull final UUID uniqueId) {
+        this.users.remove(uniqueId);
+    }
+
+    @Override
+    public Optional<WorldUser> getUser(@NotNull final UUID uniqueId) {
+        return Optional.ofNullable(this.users.get(uniqueId));
+    }
+
+    @Override
+    public Optional<WorldUser> getUser(@NotNull final String name) {
+        return this.users.values().stream().filter(user -> user.getName().equalsIgnoreCase(name)).findFirst();
+    }
+
+    @Override
+    public void saveUser(@NotNull final WorldUser user) {
+        this.saveUser(user, WorldUserProperty.UNIQUE_ID,
+                WorldUserProperty.NAME,
+                WorldUserProperty.LAST_LOCATION);
+    }
+
+    @Override
+    public void saveUser(@NotNull final WorldUser user, @NotNull final WorldUserProperty... properties) {
+        final ParsedMap<WorldUserProperty, Object> data = new ParsedMap<>();
+
+        for (final WorldUserProperty property : properties) {
+            switch (property) {
+                case UNIQUE_ID:
+                    data.put(property, user.getUniqueId());
+                    break;
+
+                case NAME:
+                    data.put(property, user.getName());
+                    break;
+
+                case LAST_LOCATION:
+                    data.put(property, user.getLastLocation());
+                    break;
+
+                default:
+                    this.saveUser(user);
+                    break;
+            }
+        }
+        user.getConfiguration().write(data);
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/util/UpdateChecker.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/util/UpdateChecker.java
new file mode 100644
index 0000000..29ea00a
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/util/UpdateChecker.java
@@ -0,0 +1,59 @@
+package com.dev7ex.multiworld.util;
+
+import com.dev7ex.common.bukkit.plugin.BukkitPlugin;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Scanner;
+import java.util.function.Consumer;
+
+/**
+ * @author Dev7ex
+ * @since 01.07.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+@Deprecated
+public class UpdateChecker {
+
+    private final BukkitPlugin plugin;
+    private boolean updateAvailable = false;
+    private String newVersion;
+
+    public UpdateChecker(@NotNull final BukkitPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void getVersion(@NotNull final Consumer<Boolean> consumer) {
+        this.plugin.getServer().getScheduler().runTaskAsynchronously(this.plugin, () -> {
+            try (final InputStream inputStream = new URL("https://api.spigotmc.org/legacy/update.php?resource=" + this.plugin.getResourceId()).openStream()) {
+                try (final Scanner scanner = new Scanner(inputStream)) {
+                    final String currentVersion = this.plugin.getDescription().getVersion();
+                    this.newVersion = scanner.next();
+
+                    if (!currentVersion.equalsIgnoreCase(this.newVersion)) {
+                        this.updateAvailable = true;
+                        this.plugin.getServer().getScheduler().runTask(this.plugin, () -> {
+                            this.plugin.getLogger().info("There is a new update available.");
+                            this.plugin.getLogger().info("Current Version: " + currentVersion);
+                            this.plugin.getLogger().info("New Version: " + this.newVersion);
+                        });
+                        return;
+                    }
+                    consumer.accept(this.updateAvailable);
+                }
+
+            } catch (final IOException exception) {
+                this.updateAvailable = false;
+                consumer.accept(false);
+                this.plugin.getServer().getScheduler().runTask(this.plugin, () -> {
+                    this.plugin.getLogger().info("Unable to check for updates: " + exception.getMessage());
+                });
+            }
+        });
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/world/DefaultWorldConfiguration.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/world/DefaultWorldConfiguration.java
new file mode 100644
index 0000000..cf7ed10
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/world/DefaultWorldConfiguration.java
@@ -0,0 +1,159 @@
+package com.dev7ex.multiworld.world;
+
+import com.dev7ex.common.bukkit.configuration.ConfigurationBase;
+import com.dev7ex.common.bukkit.configuration.ConfigurationProperties;
+import com.dev7ex.common.map.ParsedMap;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldConfiguration;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.world.WorldDefaultProperty;
+import com.dev7ex.multiworld.api.world.WorldFlag;
+import com.dev7ex.multiworld.api.world.WorldProperty;
+import com.dev7ex.multiworld.api.world.WorldType;
+import org.bukkit.Difficulty;
+import org.bukkit.GameMode;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@ConfigurationProperties(fileName = "world.yml")
+public class DefaultWorldConfiguration extends ConfigurationBase implements BukkitWorldConfiguration {
+
+    public DefaultWorldConfiguration(@NotNull final Plugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public void add(@NotNull final BukkitWorldHolder worldHolder) {
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.CREATOR_NAME.getStoragePath(), worldHolder.getCreatorName());
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.CREATION_TIMESTAMP.getStoragePath(), worldHolder.getCreationTimeStamp());
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.TYPE.getStoragePath(), worldHolder.getType().toString());
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.GAME_MODE.getStoragePath(), worldHolder.getGameMode().toString());
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.DIFFICULTY.getStoragePath(), worldHolder.getDifficulty().toString());
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.PVP_ENABLED.getStoragePath(), worldHolder.isPvpEnabled());
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.SPAWN_ANIMALS.getStoragePath(), worldHolder.isSpawnAnimals());
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.SPAWN_MONSTERS.getStoragePath(), worldHolder.isSpawnMonsters());
+
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.END_WORLD.getStoragePath(), MultiWorldPlugin.getInstance()
+                .getConfiguration()
+                .getDefaultProperties()
+                .getString(WorldDefaultProperty.END_WORLD));
+
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.NETHER_WORLD.getStoragePath(), MultiWorldPlugin.getInstance()
+                .getConfiguration()
+                .getDefaultProperties()
+                .getString(WorldDefaultProperty.NETHER_WORLD));
+
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.NORMAL_WORLD.getStoragePath(), MultiWorldPlugin.getInstance()
+                .getConfiguration()
+                .getDefaultProperties()
+                .getString(WorldDefaultProperty.NORMAL_WORLD));
+
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.WHITELIST.getStoragePath(), Collections.emptyList());
+        super.getFileConfiguration().set(worldHolder.getName() + "." + WorldProperty.WHITELIST_ENABLED.getStoragePath(), MultiWorldPlugin.getInstance()
+                .getConfiguration()
+                .getDefaultProperties()
+                .getBoolean(WorldDefaultProperty.WHITELIST_ENABLED));
+
+        super.saveFile();
+    }
+
+    @Override
+    public void remove(@NotNull final BukkitWorldHolder worldHolder) {
+        this.remove(worldHolder.getName());
+    }
+
+    @Override
+    public void remove(@NotNull final String name) {
+        super.getFileConfiguration().set(name, null);
+        super.saveFile();
+    }
+
+    @Override
+    public boolean contains(@NotNull final String name) {
+        return super.getFileConfiguration().contains(name);
+    }
+
+    @Override
+    public void updateFlag(@NotNull final BukkitWorldHolder worldHolder, @NotNull final WorldFlag worldFlag, @NotNull final String value) {
+        super.getFileConfiguration().set(worldHolder.getName() + "." + worldFlag.getStoragePath(), value);
+        super.saveFile();
+    }
+
+    @Override
+    public void write(@NotNull final BukkitWorldHolder worldHolder, @NotNull final ParsedMap<WorldProperty, Object> worldData) {
+        for (final WorldProperty property : worldData.keySet()) {
+            switch (property) {
+                case CREATOR_NAME:
+                case TYPE:
+                case GAME_MODE:
+                case DIFFICULTY:
+                case END_WORLD:
+                case NETHER_WORLD:
+                case NORMAL_WORLD:
+                    super.getFileConfiguration().set(worldHolder.getName() + "." + property.getStoragePath(), worldData.getString(property));
+                    break;
+
+                case CREATION_TIMESTAMP:
+                    super.getFileConfiguration().set(worldHolder.getName() + "." + property.getStoragePath(), worldData.getLong(property));
+                    break;
+
+                case PVP_ENABLED:
+                case SPAWN_ANIMALS:
+                case SPAWN_MONSTERS:
+                case WHITELIST_ENABLED:
+                    super.getFileConfiguration().set(worldHolder.getName() + "." + property.getStoragePath(), worldData.getBoolean(property));
+                    break;
+
+                case WHITELIST:
+                    super.getFileConfiguration().set(worldHolder.getName() + "." + property.getStoragePath(), worldData.getStringList(property));
+                    break;
+            }
+        }
+        super.saveFile();
+    }
+
+    @Override
+    public void write(@NotNull final BukkitWorldHolder worldHolder, @NotNull final WorldProperty property, @NotNull final Object data) {
+        super.getFileConfiguration().set(worldHolder.getName() + "." + property.getStoragePath(), data);
+        super.saveFile();
+    }
+
+    @Override
+    public BukkitWorldHolder getWorldHolder(@NotNull final String name) {
+        return BukkitWorldHolder.builder()
+                .setName(name)
+                .setCreatorName(super.getFileConfiguration().getString(name + "." + WorldProperty.CREATOR_NAME.getStoragePath()))
+                .setCreationTimeStamp(super.getFileConfiguration().getLong(name + "." + WorldProperty.CREATION_TIMESTAMP.getStoragePath()))
+                .setType(WorldType.fromString(super.getFileConfiguration().getString(name + "." + WorldProperty.TYPE.getStoragePath())).orElseThrow())
+                .setGameMode(GameMode.valueOf(super.getFileConfiguration().getString(name + "." + WorldProperty.GAME_MODE.getStoragePath())))
+                .setDifficulty(Difficulty.valueOf(super.getFileConfiguration().getString(name + "." + WorldProperty.DIFFICULTY.getStoragePath())))
+                .setPvpEnabled(super.getFileConfiguration().getBoolean(name + "." + WorldProperty.PVP_ENABLED.getStoragePath()))
+                .setSpawnAnimals(super.getFileConfiguration().getBoolean(name + "." + WorldProperty.SPAWN_ANIMALS.getStoragePath()))
+                .setSpawnMonsters(super.getFileConfiguration().getBoolean(name + "." + WorldProperty.SPAWN_MONSTERS.getStoragePath()))
+                .setEndWorldName(super.getFileConfiguration().getString(name + "." + WorldProperty.END_WORLD.getStoragePath()))
+                .setNetherWorldName(super.getFileConfiguration().getString(name + "." + WorldProperty.NETHER_WORLD.getStoragePath()))
+                .setNormalWorldName(super.getFileConfiguration().getString(name + "." + WorldProperty.NORMAL_WORLD.getStoragePath()))
+                .setWhitelist(super.getFileConfiguration().getStringList(name + "." + WorldProperty.WHITELIST.getStoragePath()))
+                .setWhitelistEnabled(super.getFileConfiguration().getBoolean(name + "." + WorldProperty.WHITELIST_ENABLED.getStoragePath()))
+                .build();
+    }
+
+    @Override
+    public Map<String, BukkitWorldHolder> getWorldHolders() {
+        final Map<String, BukkitWorldHolder> worlds = new HashMap<>();
+
+        for (final String entry : super.getFileConfiguration().getKeys(false)) {
+            worlds.put(entry, this.getWorldHolder(entry));
+        }
+        return worlds;
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/world/DefaultWorldGeneratorProvider.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/world/DefaultWorldGeneratorProvider.java
new file mode 100644
index 0000000..87d9a59
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/world/DefaultWorldGeneratorProvider.java
@@ -0,0 +1,53 @@
+package com.dev7ex.multiworld.world;
+
+import com.dev7ex.common.bukkit.plugin.service.PluginService;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldGeneratorProvider;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author Dev7ex
+ * @since 29.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+public class DefaultWorldGeneratorProvider implements PluginService, BukkitWorldGeneratorProvider {
+
+    private final Map<Plugin, String> customGenerators = new HashMap<>();
+
+    @Override
+    public void onEnable() {
+        for (final Plugin plugin : Bukkit.getServer().getPluginManager().getPlugins()) {
+            if (!plugin.isEnabled()) {
+                continue;
+            }
+            try {
+                if (plugin.getDefaultWorldGenerator("world", "") == null) {
+                    continue;
+                }
+            } catch (final Exception exception) {
+                MultiWorldPlugin.getInstance().getLogger().severe(plugin.getName() + " could not be loaded");
+                continue;
+            }
+            this.customGenerators.put(plugin, plugin.getDescription().getName());
+        }
+        MultiWorldPlugin.getInstance().getLogger().info("Found: [" + this.customGenerators.values().size() + "] World Generator");
+    }
+
+    @Override
+    public void onDisable() {
+        this.customGenerators.clear();
+    }
+
+    @Override
+    public boolean exists(@NotNull final String generator) {
+        return this.customGenerators.containsValue(generator);
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/world/DefaultWorldManager.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/world/DefaultWorldManager.java
new file mode 100644
index 0000000..90a5f61
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/world/DefaultWorldManager.java
@@ -0,0 +1,450 @@
+package com.dev7ex.multiworld.world;
+
+import com.dev7ex.common.bukkit.BukkitCommon;
+import com.dev7ex.common.io.Files;
+import com.dev7ex.common.map.ParsedMap;
+import com.dev7ex.multiworld.MultiWorldConfiguration;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.event.world.WorldCloneEvent;
+import com.dev7ex.multiworld.api.bukkit.event.world.WorldCreateEvent;
+import com.dev7ex.multiworld.api.bukkit.event.world.WorldDeleteEvent;
+import com.dev7ex.multiworld.api.bukkit.generator.FlatChunkGenerator;
+import com.dev7ex.multiworld.api.bukkit.generator.VoidChunkGenerator;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldManager;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldProvider;
+import com.dev7ex.multiworld.api.world.WorldDefaultProperty;
+import com.dev7ex.multiworld.api.world.WorldType;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.apache.commons.io.FileUtils;
+import org.bukkit.*;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Objects;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+public class DefaultWorldManager implements BukkitWorldManager {
+
+    private final DefaultWorldConfiguration configuration;
+    private final MultiWorldConfiguration pluginConfiguration;
+
+    public DefaultWorldManager(@NotNull final DefaultWorldConfiguration configuration,
+                               @NotNull final MultiWorldConfiguration pluginConfiguration) {
+        this.configuration = configuration;
+        this.pluginConfiguration = pluginConfiguration;
+    }
+
+    @Override
+    public void cloneWorld(@NotNull final String creatorName, @NotNull final String name, @NotNull final String clonedName) {
+        final File sourceFolder = new File(Bukkit.getWorldContainer(), name);
+        final File destinationFolder = new File(Bukkit.getWorldContainer(), clonedName);
+        final CommandSender commandSender = BukkitCommon.getCommandSender(creatorName);
+        final BukkitWorldHolder worldHolder = this.getProvider().getWorldHolder(name).orElseThrow();
+
+        final WorldCloneEvent event = new WorldCloneEvent(worldHolder, commandSender, clonedName, sourceFolder, destinationFolder);
+        Bukkit.getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return;
+        }
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.clone.starting")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+
+        try {
+            final File sessionFile = new File(sourceFolder, "session.lock");
+
+            if (sessionFile.exists()) {
+                final boolean deleted = sessionFile.delete();
+            }
+            FileUtils.copyDirectory(sourceFolder, destinationFolder);
+
+            for (final File file : Files.getFiles(destinationFolder)) {
+                if (!file.isFile()) {
+                    continue;
+                }
+                if (!file.getName().equalsIgnoreCase("uid.dat")) {
+                    continue;
+                }
+                file.delete();
+            }
+            commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.clone.finished")
+                    .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                    .replaceAll("%world_name%", name));
+
+        } catch (final IOException exception) {
+            commandSender.sendMessage("§cAn error has occurred. View the logs");
+            exception.printStackTrace();
+        }
+    }
+
+    @Override
+    public void createBackup(@NotNull final String creatorName, @NotNull final String name) {
+        final CommandSender commandSender = BukkitCommon.getCommandSender(creatorName);
+        final File sourceFolder = new File(Bukkit.getWorldContainer(), name);
+        final File destinationFolder = new File(MultiWorldPlugin.getInstance().getSubFolder("backup"),
+                name + "-" + new SimpleDateFormat("MM-dd-yyyy-HH-mm-ss").format(Calendar.getInstance().getTime()));
+
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.backup.starting")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+
+        try {
+            final File sessionFile = new File(sourceFolder, "session.lock");
+
+            if (sessionFile.exists()) {
+                sessionFile.delete();
+            }
+            FileUtils.copyDirectory(sourceFolder, destinationFolder);
+
+            for (final File file : Files.getFiles(destinationFolder)) {
+                if (!file.isFile()) {
+                    continue;
+                }
+                if (!file.getName().equalsIgnoreCase("uid.dat")) {
+                    continue;
+                }
+                file.delete();
+            }
+            commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.backup.finished")
+                    .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                    .replaceAll("%world_name%", name));
+
+        } catch (final IOException exception) {
+            commandSender.sendMessage("§cAn error has occurred. View the logs");
+            exception.printStackTrace();
+        }
+    }
+
+    @Override
+    public void createWorld(@NotNull final String creatorName, @NotNull final String name, @NotNull final WorldType type) {
+        final WorldCreator worldCreator = new WorldCreator(name);
+        final CommandSender commandSender = BukkitCommon.getCommandSender(creatorName);
+
+        switch (type) {
+            case FLAT:
+                worldCreator.generator(new FlatChunkGenerator());
+                break;
+
+            case NETHER:
+                worldCreator.environment(World.Environment.NETHER);
+                break;
+
+            case END:
+                worldCreator.environment(World.Environment.THE_END);
+                break;
+
+            case VOID:
+                worldCreator.generator(new VoidChunkGenerator());
+                break;
+
+            default:
+                worldCreator.type(org.bukkit.WorldType.NORMAL);
+                break;
+        }
+        final ParsedMap<WorldDefaultProperty, Object> defaultProperties = this.pluginConfiguration.getDefaultProperties();
+
+        final BukkitWorldHolder worldHolder = BukkitWorldHolder.builder()
+                .setName(name)
+                .setCreatorName(commandSender.getName())
+                .setCreationTimeStamp(System.currentTimeMillis())
+                .setType(type)
+                .setGameMode(GameMode.valueOf(defaultProperties.getString(WorldDefaultProperty.GAME_MODE)))
+                .setDifficulty(Difficulty.valueOf(defaultProperties.getString(WorldDefaultProperty.DIFFICULTY)))
+                .setPvpEnabled(defaultProperties.getBoolean(WorldDefaultProperty.PVP_ENABLED))
+                .setLoaded(false)
+                .setSpawnAnimals(defaultProperties.getBoolean(WorldDefaultProperty.SPAWN_ANIMALS))
+                .setSpawnMonsters(defaultProperties.getBoolean(WorldDefaultProperty.SPAWN_MONSTERS))
+                .setEndWorldName(defaultProperties.getString(WorldDefaultProperty.END_WORLD))
+                .setNetherWorldName(defaultProperties.getString(WorldDefaultProperty.NETHER_WORLD))
+                .setNormalWorldName(defaultProperties.getString(WorldDefaultProperty.NORMAL_WORLD))
+                .setWhitelist(Collections.emptyList())
+                .setWhitelistEnabled(defaultProperties.getBoolean(WorldDefaultProperty.WHITELIST_ENABLED))
+                .build();
+
+        final WorldCreateEvent event = new WorldCreateEvent(worldHolder, commandSender);
+        Bukkit.getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return;
+        }
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.create.starting")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+
+        final World world = worldCreator.createWorld();
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.create.finished")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+
+        world.setDifficulty(worldHolder.getDifficulty());
+        world.setSpawnFlags(worldHolder.isSpawnMonsters(), worldHolder.isSpawnAnimals());
+
+        worldHolder.setLoaded(true);
+        this.configuration.add(worldHolder);
+        this.getProvider().register(worldHolder);
+    }
+
+    @Override
+    public void createWorld(@NotNull final String creatorName, @NotNull final String name, final long seed) {
+        final WorldCreator worldCreator = new WorldCreator(name);
+        final CommandSender commandSender = BukkitCommon.getCommandSender(creatorName);
+
+        worldCreator.seed(seed);
+
+        final ParsedMap<WorldDefaultProperty, Object> defaultProperties = this.pluginConfiguration.getDefaultProperties();
+
+        final BukkitWorldHolder worldHolder = BukkitWorldHolder.builder()
+                .setName(name)
+                .setCreatorName(commandSender.getName())
+                .setCreationTimeStamp(System.currentTimeMillis())
+                .setType(WorldType.NORMAL)
+                .setGameMode(GameMode.valueOf(defaultProperties.getString(WorldDefaultProperty.GAME_MODE)))
+                .setDifficulty(Difficulty.valueOf(defaultProperties.getString(WorldDefaultProperty.DIFFICULTY)))
+                .setPvpEnabled(defaultProperties.getBoolean(WorldDefaultProperty.PVP_ENABLED))
+                .setLoaded(false)
+                .setSpawnAnimals(defaultProperties.getBoolean(WorldDefaultProperty.SPAWN_ANIMALS))
+                .setSpawnMonsters(defaultProperties.getBoolean(WorldDefaultProperty.SPAWN_MONSTERS))
+                .setEndWorldName(defaultProperties.getString(WorldDefaultProperty.END_WORLD))
+                .setNetherWorldName(defaultProperties.getString(WorldDefaultProperty.NETHER_WORLD))
+                .setNormalWorldName(defaultProperties.getString(WorldDefaultProperty.NORMAL_WORLD))
+                .setWhitelist(Collections.emptyList())
+                .setWhitelistEnabled(defaultProperties.getBoolean(WorldDefaultProperty.WHITELIST_ENABLED))
+                .build();
+
+        final WorldCreateEvent event = new WorldCreateEvent(worldHolder, commandSender);
+        Bukkit.getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return;
+        }
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.create.starting")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+        final World world = worldCreator.createWorld();
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.create.finished")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+
+        world.setDifficulty(worldHolder.getDifficulty());
+        world.setSpawnFlags(worldHolder.isSpawnMonsters(), worldHolder.isSpawnAnimals());
+
+        worldHolder.setLoaded(true);
+        this.configuration.add(worldHolder);
+        this.getProvider().register(worldHolder);
+    }
+
+    @Override
+    public void createWorld(@NotNull final String creatorName, @NotNull final String name, @NotNull final String generator) {
+        final WorldCreator worldCreator = new WorldCreator(name);
+        final CommandSender commandSender = BukkitCommon.getCommandSender(creatorName);
+
+        worldCreator.generator(generator);
+
+        final ParsedMap<WorldDefaultProperty, Object> defaultProperties = this.pluginConfiguration.getDefaultProperties();
+
+        final BukkitWorldHolder worldHolder = BukkitWorldHolder.builder()
+                .setName(name)
+                .setCreatorName(commandSender.getName())
+                .setCreationTimeStamp(System.currentTimeMillis())
+                .setType(WorldType.NORMAL)
+                .setGameMode(GameMode.valueOf(defaultProperties.getString(WorldDefaultProperty.GAME_MODE)))
+                .setDifficulty(Difficulty.valueOf(defaultProperties.getString(WorldDefaultProperty.DIFFICULTY)))
+                .setPvpEnabled(defaultProperties.getBoolean(WorldDefaultProperty.PVP_ENABLED))
+                .setLoaded(false)
+                .setSpawnAnimals(defaultProperties.getBoolean(WorldDefaultProperty.SPAWN_ANIMALS))
+                .setSpawnMonsters(defaultProperties.getBoolean(WorldDefaultProperty.SPAWN_MONSTERS))
+                .setEndWorldName(defaultProperties.getString(WorldDefaultProperty.END_WORLD))
+                .setNetherWorldName(defaultProperties.getString(WorldDefaultProperty.NETHER_WORLD))
+                .setNormalWorldName(defaultProperties.getString(WorldDefaultProperty.NORMAL_WORLD))
+                .setWhitelist(Collections.emptyList())
+                .setWhitelistEnabled(defaultProperties.getBoolean(WorldDefaultProperty.WHITELIST_ENABLED))
+                .build();
+
+        final WorldCreateEvent event = new WorldCreateEvent(worldHolder, commandSender);
+        Bukkit.getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return;
+        }
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.create.starting")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+        final World world = worldCreator.createWorld();
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.create.finished")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+
+        world.setDifficulty(worldHolder.getDifficulty());
+        world.setSpawnFlags(worldHolder.isSpawnMonsters(), worldHolder.isSpawnAnimals());
+
+        worldHolder.setLoaded(true);
+        this.configuration.add(worldHolder);
+        this.getProvider().register(worldHolder);
+    }
+
+    @Override
+    public void deleteWorld(@NotNull final String creatorName, @NotNull final String name) {
+        final CommandSender commandSender = BukkitCommon.getCommandSender(creatorName);
+        final BukkitWorldHolder worldHolder = this.getProvider().getWorldHolder(name).orElseThrow();
+
+        final WorldDeleteEvent event = new WorldDeleteEvent(worldHolder, commandSender);
+        Bukkit.getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
+            return;
+        }
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.delete.starting")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+        this.unloadWorld(creatorName, name);
+
+        try {
+            FileUtils.deleteDirectory(new File(Bukkit.getWorldContainer() + File.separator + name));
+
+        } catch (final IOException exception) {
+            commandSender.sendMessage("§cAn error has occurred. View the logs");
+            exception.printStackTrace();
+            return;
+        }
+        this.configuration.remove(name);
+        this.getProvider().unregister(name);
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.delete.finished")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+    }
+
+    @Override
+    public void importWorld(@NotNull final String creatorName, @NotNull final String name, @NotNull final WorldType type) {
+        final CommandSender commandSender = BukkitCommon.getCommandSender(creatorName);
+
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.import.starting")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+
+        final ParsedMap<WorldDefaultProperty, Object> defaultProperties = this.pluginConfiguration.getDefaultProperties();
+
+        final BukkitWorldHolder worldHolder = BukkitWorldHolder.builder()
+                .setName(name)
+                .setCreatorName(commandSender.getName())
+                .setCreationTimeStamp(System.currentTimeMillis())
+                .setType(type)
+                .setGameMode(GameMode.valueOf(defaultProperties.getString(WorldDefaultProperty.GAME_MODE)))
+                .setDifficulty(Difficulty.valueOf(defaultProperties.getString(WorldDefaultProperty.DIFFICULTY)))
+                .setPvpEnabled(defaultProperties.getBoolean(WorldDefaultProperty.PVP_ENABLED))
+                .setLoaded(false)
+                .setSpawnAnimals(defaultProperties.getBoolean(WorldDefaultProperty.SPAWN_ANIMALS))
+                .setSpawnMonsters(defaultProperties.getBoolean(WorldDefaultProperty.SPAWN_MONSTERS))
+                .setEndWorldName(defaultProperties.getString(WorldDefaultProperty.END_WORLD))
+                .setNetherWorldName(defaultProperties.getString(WorldDefaultProperty.NETHER_WORLD))
+                .setNormalWorldName(defaultProperties.getString(WorldDefaultProperty.NORMAL_WORLD))
+                .setWhitelist(Collections.emptyList())
+                .setWhitelistEnabled(defaultProperties.getBoolean(WorldDefaultProperty.WHITELIST_ENABLED))
+                .build();
+
+        this.configuration.add(worldHolder);
+        this.getProvider().register(worldHolder);
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.import.finished")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+    }
+
+    @Override
+    public void loadWorld(@NotNull final String creatorName, @NotNull final String name) {
+        final CommandSender commandSender = BukkitCommon.getCommandSender(creatorName);
+        final BukkitWorldHolder worldHolder = this.getProvider().getWorldHolder(name).orElseThrow();
+        final WorldCreator worldCreator = new WorldCreator(name);
+
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.load.starting")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+
+        switch (worldHolder.getType()) {
+            case VOID:
+                worldCreator.generator(new VoidChunkGenerator());
+                worldCreator.generateStructures(false);
+                break;
+
+            case FLAT:
+                worldCreator.generator(new FlatChunkGenerator());
+                worldCreator.generateStructures(false);
+                break;
+
+            case NETHER:
+                worldCreator.environment(World.Environment.NETHER);
+                break;
+
+            case END:
+                worldCreator.environment(World.Environment.THE_END);
+                break;
+        }
+
+        final World world = Bukkit.createWorld(worldCreator);
+
+        world.setDifficulty(worldHolder.getDifficulty());
+        world.setSpawnFlags(worldHolder.isSpawnMonsters(), worldHolder.isSpawnAnimals());
+
+        worldHolder.setLoaded(true);
+        this.getProvider().register(worldHolder);
+
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.load.finished")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+    }
+
+    @Override
+    public void unloadWorld(@NotNull final String creatorName, @NotNull final String name) {
+        final CommandSender commandSender = BukkitCommon.getCommandSender(creatorName);
+        final World world = Objects.requireNonNull(Bukkit.getWorld(name));
+
+        for (final Player player : Bukkit.getOnlinePlayers()) {
+            if (!player.getWorld().getName().equalsIgnoreCase(name)) {
+                continue;
+            }
+            player.sendMessage(this.pluginConfiguration.getString("messages.commands.unload.chunk-teleport")
+                    .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                    .replaceAll("%world_name%", name));
+            player.teleport(Bukkit.getWorld(MultiWorldPlugin.getInstance().getConfiguration().getString("settings.defaults.normal-world")).getSpawnLocation());
+        }
+
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.unload.chunk-starting")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+
+        Arrays.stream(world.getLoadedChunks()).forEach(Chunk::unload);
+
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.unload.chunk-finished")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.unload.starting")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+
+        Bukkit.unloadWorld(world.getName(), true);
+        this.getProvider().getWorldHolder(name).orElseThrow().setLoaded(false);
+
+        commandSender.sendMessage(this.pluginConfiguration.getString("messages.commands.unload.finished")
+                .replaceAll("%prefix%", this.pluginConfiguration.getPrefix())
+                .replaceAll("%world_name%", name));
+    }
+
+    @Override
+    public BukkitWorldProvider getProvider() {
+        return MultiWorldPlugin.getInstance().getWorldProvider();
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/world/DefaultWorldProvider.java b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/world/DefaultWorldProvider.java
new file mode 100644
index 0000000..719784f
--- /dev/null
+++ b/multiworld-bukkit/src/main/java/com/dev7ex/multiworld/world/DefaultWorldProvider.java
@@ -0,0 +1,96 @@
+package com.dev7ex.multiworld.world;
+
+import com.dev7ex.common.bukkit.plugin.service.PluginService;
+import com.dev7ex.multiworld.MultiWorldPlugin;
+import com.dev7ex.multiworld.api.bukkit.event.plugin.MultiWorldStartupCompleteEvent;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldHolder;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldProvider;
+import com.dev7ex.multiworld.api.bukkit.world.BukkitWorldType;
+import lombok.AccessLevel;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * @author Dev7ex
+ * @since 18.06.2023
+ */
+@Getter(AccessLevel.PUBLIC)
+public class DefaultWorldProvider implements PluginService, BukkitWorldProvider {
+
+    private final Map<String, BukkitWorldHolder> worldHolders = new HashMap<>();
+    private final DefaultWorldManager worldManager;
+    private final DefaultWorldConfiguration configuration;
+
+    public DefaultWorldProvider(@NotNull final DefaultWorldManager worldManager, @NotNull final DefaultWorldConfiguration configuration) {
+        this.worldManager = worldManager;
+        this.configuration = configuration;
+    }
+
+    @Override
+    public void onEnable() {
+        final long startTime = System.currentTimeMillis();
+
+        // Use this to import the standard worlds
+        for (final World worlds : Bukkit.getWorlds()) {
+            if (this.configuration.contains(worlds.getName())) {
+                continue;
+            }
+            this.worldManager.importWorld(Bukkit.getConsoleSender().getName(), worlds.getName(), BukkitWorldType.fromEnvironment(worlds.getEnvironment()));
+        }
+
+        for (final String worldEntry : this.configuration.getWorldHolders().keySet()) {
+            final BukkitWorldHolder worldHolder = this.configuration.getWorldHolder(worldEntry);
+
+            if (Bukkit.getWorld(worldEntry) != null) {
+                final World world = worldHolder.getWorld();
+                world.setDifficulty(worldHolder.getDifficulty());
+                world.setSpawnFlags(worldHolder.isSpawnMonsters(), worldHolder.isSpawnMonsters());
+                worldHolder.setLoaded(true);
+            }
+            this.register(worldHolder);
+        }
+
+        for (final String worldName : MultiWorldPlugin.getInstance().getConfiguration().getAutoLoadableWorlds()) {
+            if (!this.configuration.contains(worldName)) {
+                Bukkit.getConsoleSender().sendMessage("%prefix% §7Couldnt load the world §a%world%§7. Use /world import");
+                continue;
+            }
+            this.worldManager.loadWorld(Bukkit.getConsoleSender().getName(), worldName);
+        }
+
+        MultiWorldPlugin.getInstance().getLogger().info("Found: [" + this.worldHolders.size() + "] Worlds");
+        Bukkit.getPluginManager().callEvent(new MultiWorldStartupCompleteEvent(MultiWorldPlugin.getInstance(), (System.currentTimeMillis() - startTime)));
+    }
+
+    @Override
+    public void onDisable() {
+        this.worldHolders.clear();
+    }
+
+    @Override
+    public void register(@NotNull final BukkitWorldHolder worldHolder) {
+        this.worldHolders.put(worldHolder.getName(), worldHolder);
+    }
+
+    @Override
+    public void unregister(@NotNull final String name) {
+        this.worldHolders.remove(name);
+    }
+
+    @Override
+    public boolean isRegistered(@NotNull final String name) {
+        return this.worldHolders.containsKey(name);
+    }
+
+    @Override
+    public Optional<BukkitWorldHolder> getWorldHolder(@NotNull final String name) {
+        return Optional.ofNullable(this.worldHolders.get(name));
+    }
+
+}
diff --git a/multiworld-bukkit/src/main/resources/config.yml b/multiworld-bukkit/src/main/resources/config.yml
new file mode 100644
index 0000000..facdf80
--- /dev/null
+++ b/multiworld-bukkit/src/main/resources/config.yml
@@ -0,0 +1,173 @@
+#
+#      __  ___      ____  _ _       __           __    __
+#    /  |/  /_  __/ / /_(_) |     / /___  _____/ /___/ /
+#   / /|_/ / / / / / __/ /| | /| / / __ \/ ___/ / __  /
+#  / /  / / /_/ / / /_/ / | |/ |/ / /_/ / /  / / /_/ /
+# /_/  /_/\__,_/_/\__/_/  |__/|__/\____/_/  /_/\__,_/
+#
+# Copyright (c) 2023 by Dev7ex
+# Version: ${project.version}
+config-version: ${project.version}
+# General
+prefix: '§8[§bMultiWorld§8]§r'
+no-permission: '§cIm sorry, but you do not have permission to perform this command. Please contact the server administrators if you believe that is in error.'
+player-not-found: '%prefix% §cThis player could not be found'
+only-player-command: '%prefix% §cThis command can only performed by a player'
+
+settings:
+  # Worlds that should be loaded when the server starts
+  # WARNING: When the world is not registered by MultiWorld the world will not bee loaded
+  # The world has to be imported manually! (Attention choose the correct WorldType)
+  # Example: auto-load: [world1, world2, world3]
+  auto-load: [ ]
+  # Should all players with the permission (multiworld.notify.update)
+  # get a message when entering server
+  receive-update-message: true
+  # Should the auto-gamemode per world work?
+  auto-game-mode-enabled: true
+  # Should you be able to enter Nether/End worlds with the command /world telport <Player> <World>
+  access-nether-world-via-command: true
+  access-end-world-via-command: true
+  # Standard values for new worlds
+  defaults:
+    normal-world: world
+    end-world: world_the_end
+    nether_world: world_nether
+    difficulty: PEACEFUL
+    game-mode: SURVIVAL
+    pvp-enabled: true
+    spawn-animals: false
+    spawn-monsters: false
+    whitelist-enabled: false
+
+messages:
+  general:
+    update-message-player: '%prefix% §7There is a new update available. §8[§bhttps://www.spigotmc.org/resources/multiworld.92559§8]'
+    update-message-version-player: '%prefix% §7Current Version: §b%current_version% §7New Version §b%new_version%'
+    world-not-exists: '%prefix% §cThe specified world does not exist!'
+    world-not-loaded: '%prefix% §cThe specified world is not loaded!'
+    world-already-exists: '%prefix% §cThe specified world already exists!'
+    world-type-not-exists: '%prefix% §cThe specified WorldType does not exist'
+    world-folder-not-exists: '%prefix% §cNo world folder could be found!'
+    world-whitelist-block-trespassing: '%prefix% §7You are not on the whitelist of this world!'
+  commands:
+    back:
+      usage: '%prefix% §cUsage: /world back'
+      world-not-exists: '%prefix% §cThere is no world you can go!'
+      sender-already-there: '%prefix% §cYou are already in the world §b%world_name%'
+    backup:
+      usage: '%prefix% §cUsage: /world backup <World>'
+      starting: '%prefix% §7A backup of the world §b%world_name% is created...'
+      finished: '%prefix% §7The backup of the world §b%world_name% §7has been successfully created!'
+    clone:
+      usage: '%prefix% §cUsage: /world clone <World> <Name>'
+      starting: '%prefix% §7The world §b%world_name% §7will be copied...'
+      finished: '%prefix% §7The world §b%world_name% §7has been successfully copied!'
+    create:
+      usage: '%prefix% §cUsage: /world create <Name> <Generator | Seed | WorldType>'
+      starting: '%prefix% §7The world §b%world_name% §7will be created...'
+      finished: '%prefix% §7The world §b%world_name% §7was created successfully!'
+    delete:
+      usage: '%prefix% §cUsage: /world delete <World>'
+      world-cannot-deleted: '%prefix% §cThe specified world may not be deleted!'
+      starting: '%prefix% §7The world §b%world_name% §7will be deleted...'
+      finished: '%prefix% §7The world §b%world_name% §7has been successfully deleted!'
+    flag:
+      usage: '%prefix% §cUsage: /world flag <World> <Flag> <Value>'
+      not-existing: '%prefix% §cThis flag does not exist'
+      value-not-existing: '%prefix% §cThis value does not exist for the flag §b%flag%'
+      successfully-set: '%prefix% §7The flag §b%flag% §7was set to §b%value% §7!'
+    help:
+      message:
+        - ''
+        - '§f§m                    §r§r %prefix% §f§m                    '
+        - ''
+        - '§7» §7/world §bback'
+        - '§7» §7/world §bbackup §7<World>'
+        - '§7» §7/world §bclone §7<World> <Name>'
+        - '§7» §7/world §bcreate §7<Name> <WorldType | Seed | Generator>'
+        - '§7» §7/world §bdelete §7<World>'
+        - '§7» §7/world §bflag §7<World> <Property> <Value>'
+        - '§7» §7/world §bhelp'
+        - '§7» §7/world §bimport §7<World> <WorldType>'
+        - '§7» §7/world §binfo §7<World>'
+        - '§7» §7/world §blist'
+        - '§7» §7/world §blink §7<World> <Nether | End> <Welt>'
+        - '§7» §7/world §bload §7<World>'
+        - '§7» §7/world §breload'
+        - '§7» §7/world §bteleport §7<Player> <Welt>'
+        - '§7» §7/world §bunload §7<World>'
+        - '§7» §7/world §bwhitelist §7<World> <Enable | Disable | Add | Remove | List> <Name>'
+        - ''
+        - '§f§m                    §r§r %prefix% §f§m                    '
+        - ''
+    import:
+      usage: '%prefix% §cUsage: /world import <Name> <WorldType | Generator>'
+      world-already-imported: '%prefix% §7The world §b%world_name% §7is already imported!'
+      starting: '%prefix% §7The world §b%world_name% §7will import...'
+      finished: '%prefix% §7The world §b%world_name% §7was successfully imported!'
+    info:
+      usage: '%prefix% §cUsage: /world info <World>'
+      message:
+        - ''
+        - '§f§m               §r§r §b%world_name% §f§m               '
+        - ''
+        - '§7» Creator: §b%world_creator_name%'
+        - '§7» Created at: §b%creation_timestamp%'
+        - '§7» Loaded: §b%loaded%'
+        - '§7» WorldType: §b%world_type%'
+        - '§7» Environment: §b%environment%'
+        - '§7» Difficulty: §b%difficulty%'
+        - '§7» GameMode: §b%gamemode%'
+        - '§7» Pvp: §b%pvp_enabled%'
+        - '§7» Whitelist: §b%whitelist_enabled%'
+        - ''
+        - '§f§m               §r§r §b%world_name% §f§m               '
+        - ''
+    list:
+      usage: '%prefix% §cUsage: /world list'
+      message: '%prefix% §aWorlds: %worlds%'
+    link:
+      usage: '%prefix% §cUsage: /world link <World> <End | Nether> <World>'
+      environment-not-exists: '%prefix% §cThe specified environment does not exist!'
+      successfully-set: '%prefix% §7You have connected the portal of the environment §b%environment_name% §7in the world §b%world_name% §7with the world §b%target_world_name% §7'
+    load:
+      usage: '%prefix% §cUsage: /world load <Name>'
+      world-already-loaded: '%prefix% §7The world §bworld_name% §7is already loaded!'
+      starting: '%prefix% §7The world §b%world_name% §7will loaded...'
+      finished: '%prefix% §7The world §b%world_name% §7was successfully loaded!'
+    reload:
+      usage: '%prefix% §cUsage: /world reload'
+      message: '%prefix% §7The configurations has been reloaded!'
+    teleport:
+      usage: '%prefix% §cUsage: /world teleport <Player> <World>'
+      message: '%prefix% §a%player_name% §7is teleported to the world §b%world_name% §7!'
+      sender-already-there: '%prefix% §7You are already in the world §b%world_name%'
+      target-already-there: '%prefix% §7The player §a%player_name% §7is already in the world §b%world_name%'
+      nether-not-accessible: '%prefix% §cYou cant enter the Nether via the command!'
+      end-not-accessible: '%prefix% §cYou cant enter the end via the command!'
+    unload:
+      usage: '%prefix% §cUsage: /world unload <World>'
+      world-cannot-unloaded: '%prefix% §cThe specified world must not be unloaded!'
+      starting: '%prefix% §7The world §b%world_name% §7will be unloaded...'
+      finished: '%prefix% §7The world §b%world_name% §7was successfully unloaded!'
+      chunk-starting: '%prefix% §7The chunks in §b%world_name% §7are unloaded...'
+      chunk-finished: '%prefix% §7The chunks in §b%world_name% §7were successfully unloaded!'
+      chunk-teleport: '%prefix% §The world you were in will be unloaded. You will be teleported!'
+    whitelist:
+      usage: '%prefix% §cUsage: /world whitelist <World> <On | Off | Add | List | Remove> <Player>'
+      add:
+        already-added: '%prefix% §The player %player_name% §7is already §7on the whitelist!'
+        successfully-added: '%prefix% §7You have added %player_name% §7to the whitelist of world §b%world_name% §7'
+      list:
+        empty: '%prefix% §7The whitelist for world §b%world_name% §7is empty'
+        message: '%prefix% §7Whitelist: %player_names%'
+      disable:
+        already-disabled: '%prefix% §7World whitelist §b%world_name% §7is already disabled!'
+        successfully-disabled: '%prefix% §7You have disabled the whitelist in the world §b%world_name% §7deactivated!'
+      enable:
+        already-enabled: '%prefix% §7The world whitelist §b%world_name% §7is already activated!'
+        successfully-enabled: '%prefix% §7You have activated the whitelist in the world §b%world_name% §7!'
+      remove:
+        already-removed: '%prefix% §7The player %player_name% §7is §not §7on the whitelist!'
+        successfully-removed: '%prefix% §7You have %player_name% §7removed from the §b%world_name% §7whitelist'
\ No newline at end of file
diff --git a/multiworld-bukkit/src/main/resources/language/de_DE.yml b/multiworld-bukkit/src/main/resources/language/de_DE.yml
new file mode 100644
index 0000000..2b9b97c
--- /dev/null
+++ b/multiworld-bukkit/src/main/resources/language/de_DE.yml
@@ -0,0 +1,130 @@
+messages:
+  general:
+    update-message-player: '%prefix% §7Es ist ein neues Update verfügbar. §8[§bhttps://www.spigotmc.org/resources/multiworld.92559§8]'
+    world-not-exists: '%prefix% §cDie angegebene Welt existiert nicht!'
+    world-not-loaded: '%prefix% §cDie angegebene Welt ist nicht geladen!'
+    world-already-exists: '%prefix% §cDie angegebene Welt existiert bereits!'
+    world-type-not-exists: '%prefix% §cDer angegebene Welten-Typ existiert nicht'
+    world-folder-not-exists: '%prefix% §cEs konnte kein Welten Ordner gefunden werden!'
+    world-whitelist-block-trespassing: '%prefix% §7Du bist nicht auf der Whitelist dieser Welt!'
+  commands:
+    back:
+      usage: '%prefix% §cSyntax: /world back'
+      world-not-exists: '%prefix% §cEs gibt keine Welt in die du gehen kannst!'
+      sender-already-there: '%prefix% Du bist bereits in der Welt §b%world_name%'
+    backup:
+      usage: '%prefix% §cSyntax: /world backup <Welt>'
+      starting: '%prefix% §7Es wird ein Backup von der Welt §b%world_name% §7erstellt...'
+      finished: '%prefix% §7Das Backup der Welt §b%world_name% §7wurde erfolgreich erstellt!'
+    clone:
+      usage: '%prefix% §cSyntax: /world clone <Welt> <Name>'
+      starting: '%prefix% §7Die Welt §b%world_name% §7wird kopiert...'
+      finished: '%prefix% §7Die Welt §b%world_name% §7wurde erfolgreich kopiert!'
+    create:
+      usage: '%prefix% §cSyntax: /world create <Name> <Generator | Seed | WorldType>'
+      starting: '%prefix% §7Die Welt §b%world_name% §7wird erstellt...'
+      finished: '%prefix% §7Die Welt §b%world_name% §7wurde erfolgreich erstellt!'
+    delete:
+      usage: '%prefix% §cSyntax: /world delete <Welt>'
+      world-cannot-deleted: '%prefix% §cDie angegebene Welt darf nicht gelöscht werden!'
+      starting: '%prefix% §7Die Welt §b%world_name% §7wird gelöscht...'
+      finished: '%prefix% §7Die Welt §b%world_name% §7wurde erfolgreich gelöscht!'
+    flag:
+      usage: '%prefix% §cSyntax: /world flag <Welt> <Flag> <Wert>'
+      not-existing: '%prefix% §cDiese Flag existiert nicht'
+      value-not-existing: '%prefix% §cDieser Wert existiert nicht für die Flag §b%flag%'
+      successfully-set: '%prefix% §7Die Flag §b%flag% §7wurde auf §b%value% §7gesetzt!'
+    help:
+      message:
+        - ''
+        - '§f§m                    §r§r %prefix% §f§m                    '
+        - ''
+        - '§7» §7/world §bback'
+        - '§7» §7/world §bbackup §7<Welt>'
+        - '§7» §7/world §bclone §7<Welt> <Name>'
+        - '§7» §7/world §bcreate §7<Name> <WorldType | Seed | Generator>'
+        - '§7» §7/world §bdelete §7<Welt>'
+        - '§7» §7/world §bflag §7<Welt> <Eigenschaft> <Eintrag>'
+        - '§7» §7/world §bhelp'
+        - '§7» §7/world §bimport §7<Welt> <WorldType>'
+        - '§7» §7/world §binfo §7<Welt>'
+        - '§7» §7/world §blist'
+        - '§7» §7/world §blink §7<Welt> <Nether | End> <Welt>'
+        - '§7» §7/world §bload §7<Welt>'
+        - '§7» §7/world §breload'
+        - '§7» §7/world §bteleport §7<Spieler> <Welt>'
+        - '§7» §7/world §bunload §7<Welt>'
+        - '§7» §7/world §bwhitelist §7<Welt> <Enable | Disable | Add | Remove | List> <Name>'
+        - ''
+        - '§f§m                    §r§r %prefix% §f§m                    '
+        - ''
+    import:
+      usage: '%prefix% §cSyntax: /world import <Name> <WorldType | Generator>'
+      world-already-imported: '%prefix% §7Die Welt §b%world_name% §7ist bereits importiert!'
+      starting: '%prefix% §7Die Welt §b%world_name% §7wird importiert...'
+      finished: '%prefix% §7Die Welt §b%world_name% §7wurde erfolgreich importiert!'
+    info:
+      usage: '%prefix% §cSyntax: /world info <Welt>'
+      message:
+        - ''
+        - '§f§m               §r§r §b%world_name% §f§m               '
+        - ''
+        - '§7» Ersteller: §b%world_creator_name%'
+        - '§7» Erstellt am: §b%creation_timestamp%'
+        - '§7» Geladen: §b%loaded%'
+        - '§7» Welten-Typ: §b%world_type%'
+        - '§7» Umgebung: §b%environment%'
+        - '§7» Schwierigkeit: §b%difficulty%'
+        - '§7» Spielmodus: §b%gamemode%'
+        - '§7» Pvp: §b%pvp_enabled%'
+        - '§7» Whitelist: §b%whitelist_enabled%'
+        - ''
+        - '§f§m               §r§r §b%world_name% §f§m               '
+        - ''
+    list:
+      usage: '%prefix% §cSyntax: /world list'
+      message: '%prefix% §aWelten: %worlds%'
+    link:
+      usage: '%prefix% §cSyntax: /world link <Welt> <End | Nether> <Welt>'
+      environment-not-exists: '%prefix% §cDie angegebene Umgebung existiert nicht!'
+      successfully-set: '%prefix% §7Du hast das Portal der Umgebung §b%environment_name% §7in der Welt §b%world_name% §7mit der Welt §b%target_world_name% §7verbunden'
+    load:
+      usage: '%prefix% §cSyntax: /world load <Name>'
+      world-already-loaded: '%prefix% §7Die Welt §bworld_name% §7ist bereits geladen!'
+      starting: '%prefix% §7Die Welt §b%world_name% §7wird geladen...'
+      finished: '%prefix% §7Die Welt §b%world_name% §7wurde erfolgreich geladen!'
+    reload:
+      usage: '%prefix% §cSyntax: /world reload'
+      message: '%prefix% §7Die Konfigurationen wurde neu geladen!'
+    teleport:
+      usage: '%prefix% §cSyntax: /world teleport <Spieler> <Welt>'
+      message: '%prefix% §a%player_name% §7wird in die Welt §b%world_name% §7teleportiert!'
+      sender-already-there: '%prefix% §7Du bist bereits in der Welt §b%world_name%'
+      target-already-there: '%prefix% §7Der Spieler §a%player_name% §7ist bereits in der Welt §b%world_name%'
+      nether-not-accessible: '%prefix% §cDu kannst den Nether nicht über den Befehl betreten!'
+      end-not-accessible: '%prefix% §cDu kannst das End nicht über den Befehl betreten!'
+    unload:
+      usage: '%prefix% §cSyntax: /world unload <Welt>'
+      world-cannot-unloaded: '%prefix% §cDie angegebene Welt darf nicht entladen werden!'
+      starting: '%prefix% §7Die Welt §b%world_name% §7wird entladen...'
+      finished: '%prefix% §7Die Welt §b%world_name% §7wurde erfolgreich entladen!'
+      chunk-starting: '%prefix% §7Die Chunks in §b%world_name% §7werden entladen...'
+      chunk-finished: '%prefix% §7Die Chunks in §b%world_name% §7wurde erfolgreich entladen!'
+      chunk-teleport: '%prefix% §7Die Welt in der du warst wird entladen. Du wirst teleportiert!'
+    whitelist:
+      usage: '%prefix% §cSyntax: /world whitelist <Welt> <On | Off | Add | List | Remove> <Spieler>'
+      add:
+        already-added: '%prefix% §7Der Spieler %player_name% §7befindet sich §abereits §7auf der Whitelist!'
+        successfully-added: '%prefix% §7Du hast %player_name% §7zur Whitelist der Welt §b%world_name% §7hinzugefügt'
+      list:
+        empty: '%prefix% §7Die Whitelist für die Welt §b%world_name% §7ist leer'
+        message: '%prefix% §7Whitelist: %player_names%'
+      disable:
+        already-disabled: '%prefix% §7Die Whitelist der Welt §b%world_name% §7ist bereits deaktiviert!'
+        successfully-disabled: '%prefix% §7Du hast die Whitelist in der Welt §b%world_name% §7deaktiviert!'
+      enable:
+        already-enabled: '%prefix% §7Die Whitelist der Welt §b%world_name% §7ist bereits aktiviert!'
+        successfully-enabled: '%prefix% §7Du hast die Whitelist in der Welt §b%world_name% §7aktiviert!'
+      remove:
+        already-removed: '%prefix% §7Der Spieler %player_name% §7befindet sich §anicht §7auf der Whitelist!'
+        successfully-removed: '%prefix% §7Du hast %player_name% §7von der Whitelist der Welt §b%world_name% §7entfernt'
\ No newline at end of file
diff --git a/multiworld-bukkit/src/main/resources/language/en_US.yml b/multiworld-bukkit/src/main/resources/language/en_US.yml
new file mode 100644
index 0000000..076ca04
--- /dev/null
+++ b/multiworld-bukkit/src/main/resources/language/en_US.yml
@@ -0,0 +1,130 @@
+messages:
+  general:
+    update-message-player: '%prefix% §7There is a new update available. §8[§bhttps://www.spigotmc.org/resources/multiworld.92559§8]'
+    world-not-exists: '%prefix% §cThe specified world does not exist!'
+    world-not-loaded: '%prefix% §cThe specified world is not loaded!'
+    world-already-exists: '%prefix% §cThe specified world already exists!'
+    world-type-not-exists: '%prefix% §cThe specified WorldType does not exist'
+    world-folder-not-exists: '%prefix% §cNo world folder could be found!'
+    world-whitelist-block-trespassing: '%prefix% §7You are not on the whitelist of this world!'
+  commands:
+    back:
+      usage: '%prefix% §cUsage: /world back'
+      world-not-exists: '%prefix% §cThere is no world you can go!'
+      sender-already-there: '%prefix% §cYou are already in the world §b%world_name%'
+    backup:
+      usage: '%prefix% §cUsage: /world backup <World>'
+      starting: '%prefix% §7A backup of the world §b%world_name% is created...'
+      finished: '%prefix% §7The backup of the world §b%world_name% §7has been successfully created!'
+    clone:
+      usage: '%prefix% §cUsage: /world clone <World> <Name>'
+      starting: '%prefix% §7The world §b%world_name% §7will be copied...'
+      finished: '%prefix% §7The world §b%world_name% §7has been successfully copied!'
+    create:
+      usage: '%prefix% §cUsage: /world create <Name> <Generator | Seed | WorldType>'
+      starting: '%prefix% §7The world §b%world_name% §7will be created...'
+      finished: '%prefix% §7The world §b%world_name% §7was created successfully!'
+    delete:
+      usage: '%prefix% §cUsage: /world delete <World>'
+      world-cannot-deleted: '%prefix% §cThe specified world may not be deleted!'
+      starting: '%prefix% §7The world §b%world_name% §7will be deleted...'
+      finished: '%prefix% §7The world §b%world_name% §7has been successfully deleted!'
+    flag:
+      usage: '%prefix% §cUsage: /world flag <World> <Flag> <Value>'
+      not-existing: '%prefix% §cThis flag does not exist'
+      value-not-existing: '%prefix% §cThis value does not exist for the flag §b%flag%'
+      successfully-set: '%prefix% §7The flag §b%flag% §7was set to §b%value% §7!'
+    help:
+      message:
+        - ''
+        - '§f§m                    §r§r %prefix% §f§m                    '
+        - ''
+        - '§7» §7/world §bback'
+        - '§7» §7/world §bbackup §7<World>'
+        - '§7» §7/world §bclone §7<World> <Name>'
+        - '§7» §7/world §bcreate §7<Name> <WorldType | Seed | Generator>'
+        - '§7» §7/world §bdelete §7<World>'
+        - '§7» §7/world §bflag §7<World> <Property> <Value>'
+        - '§7» §7/world §bhelp'
+        - '§7» §7/world §bimport §7<World> <WorldType>'
+        - '§7» §7/world §binfo §7<World>'
+        - '§7» §7/world §blist'
+        - '§7» §7/world §blink §7<World> <Nether | End> <Welt>'
+        - '§7» §7/world §bload §7<World>'
+        - '§7» §7/world §breload'
+        - '§7» §7/world §bteleport §7<Player> <World>'
+        - '§7» §7/world §bunload §7<World>'
+        - '§7» §7/world §bwhitelist §7<World> <Enable | Disable | Add | Remove | List> <Name>'
+        - ''
+        - '§f§m                    §r§r %prefix% §f§m                    '
+        - ''
+    import:
+      usage: '%prefix% §cUsage: /world import <Name> <WorldType | Generator>'
+      world-already-imported: '%prefix% §7The world §b%world_name% §7is already imported!'
+      starting: '%prefix% §7The world §b%world_name% §7will import...'
+      finished: '%prefix% §7The world §b%world_name% §7was successfully imported!'
+    info:
+      usage: '%prefix% §cUsage: /world info <World>'
+      message:
+        - ''
+        - '§f§m               §r§r §b%world_name% §f§m               '
+        - ''
+        - '§7» Creator: §b%world_creator_name%'
+        - '§7» Created at: §b%creation_timestamp%'
+        - '§7» Loaded: §b%loaded%'
+        - '§7» WorldType: §b%world_type%'
+        - '§7» Environment: §b%environment%'
+        - '§7» Difficulty: §b%difficulty%'
+        - '§7» GameMode: §b%gamemode%'
+        - '§7» Pvp: §b%pvp_enabled%'
+        - '§7» Whitelist: §b%whitelist_enabled%'
+        - ''
+        - '§f§m               §r§r §b%world_name% §f§m               '
+        - ''
+    list:
+      usage: '%prefix% §cUsage: /world list'
+      message: '%prefix% §aWorlds: %worlds%'
+    link:
+      usage: '%prefix% §cUsage: /world link <World> <End | Nether> <World>'
+      environment-not-exists: '%prefix% §cThe specified environment does not exist!'
+      successfully-set: '%prefix% §7You have connected the portal of the environment §b%environment_name% §7in the world §b%world_name% §7with the world §b%target_world_name% §7'
+    load:
+      usage: '%prefix% §cUsage: /world load <Name>'
+      world-already-loaded: '%prefix% §7The world §bworld_name% §7is already loaded!'
+      starting: '%prefix% §7The world §b%world_name% §7will loaded...'
+      finished: '%prefix% §7The world §b%world_name% §7was successfully loaded!'
+    reload:
+      usage: '%prefix% §cUsage: /world reload'
+      message: '%prefix% §7The configurations has been reloaded!'
+    teleport:
+      usage: '%prefix% §cUsage: /world teleport <Player> <World>'
+      message: '%prefix% §a%player_name% §7is teleported to the world §b%world_name% §7!'
+      sender-already-there: '%prefix% §7You are already in the world §b%world_name%'
+      target-already-there: '%prefix% §7The player §a%player_name% §7is already in the world §b%world_name%'
+      nether-not-accessible: '%prefix% §cYou cant enter the Nether via the command!'
+      end-not-accessible: '%prefix% §cYou cant enter the end via the command!'
+    unload:
+      usage: '%prefix% §cUsage: /world unload <World>'
+      world-cannot-unloaded: '%prefix% §cThe specified world must not be unloaded!'
+      starting: '%prefix% §7The world §b%world_name% §7will be unloaded...'
+      finished: '%prefix% §7The world §b%world_name% §7was successfully unloaded!'
+      chunk-starting: '%prefix% §7The chunks in §b%world_name% §7are unloaded...'
+      chunk-finished: '%prefix% §7The chunks in §b%world_name% §7were successfully unloaded!'
+      chunk-teleport: '%prefix% §The world you were in will be unloaded. You will be teleported!'
+    whitelist:
+      usage: '%prefix% §cUsage: /world whitelist <World> <On | Off | Add | List | Remove> <Player>'
+      add:
+        already-added: '%prefix% §The player %player_name% §7is already §7on the whitelist!'
+        successfully-added: '%prefix% §7You have added %player_name% §7to the whitelist of world §b%world_name% §7'
+      list:
+        empty: '%prefix% §7The whitelist for world §b%world_name% §7is empty'
+        message: '%prefix% §7Whitelist: %player_names%'
+      disable:
+        already-disabled: '%prefix% §7World whitelist §b%world_name% §7is already disabled!'
+        successfully-disabled: '%prefix% §7You have disabled the whitelist in the world §b%world_name% §7deactivated!'
+      enable:
+        already-enabled: '%prefix% §7The world whitelist §b%world_name% §7is already activated!'
+        successfully-enabled: '%prefix% §7You have activated the whitelist in the world §b%world_name% §7!'
+      remove:
+        already-removed: '%prefix% §7The player %player_name% §7is §not §7on the whitelist!'
+        successfully-removed: '%prefix% §7You have %player_name% §7removed from the §b%world_name% §7whitelist'
\ No newline at end of file
diff --git a/multiworld-bukkit/src/main/resources/plugin.yml b/multiworld-bukkit/src/main/resources/plugin.yml
new file mode 100644
index 0000000..06995bc
--- /dev/null
+++ b/multiworld-bukkit/src/main/resources/plugin.yml
@@ -0,0 +1,17 @@
+api-version: 1.16
+author: Dev7ex
+database: false
+depend: [ FacilisCommon ]
+description: ${project.description}
+load: POSTWORLD
+loadbefore: [ ]
+main: com.dev7ex.multiworld.MultiWorldPlugin
+name: MultiWorld
+prefix: MultiWorld
+softdepend: [ ]
+version: ${project.version}
+website: ${project.url}
+commands:
+  world:
+    aliases: [ multiworld, mw, w ]
+    permissions: multiworld.command.world
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 8ddb82a..fe56c3d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -9,6 +9,8 @@
     <packaging>pom</packaging>
     <version>1.4.0-SNAPSHOT</version>
     <name>MultiWorld</name>
+    <description>World Management for Minecraft</description>
+    <url>https://www.spigotmc.org/resources/multiworld.92559/</url>
 
     <modules>
         <module>multiworld-bukkit</module>
@@ -24,6 +26,7 @@
 
         <dependency.annotations-version>24.0.1</dependency.annotations-version>
         <dependency.facilis-common-version>1.0.1-SNAPSHOT</dependency.facilis-common-version>
+        <dependency-commons-io-version>2.11.0</dependency-commons-io-version>
         <dependency.lombok-version>1.18.26</dependency.lombok-version>
         <dependency-spigot-api-version>1.16.5-R0.1-SNAPSHOT</dependency-spigot-api-version>
         <dependency-maven-artifact-version>3.9.0</dependency-maven-artifact-version>