diff --git a/src/main/java/ch/njol/skript/classes/data/BukkitClasses.java b/src/main/java/ch/njol/skript/classes/data/BukkitClasses.java
index 9794bfc2e22..78b10cd554b 100644
--- a/src/main/java/ch/njol/skript/classes/data/BukkitClasses.java
+++ b/src/main/java/ch/njol/skript/classes/data/BukkitClasses.java
@@ -4,7 +4,11 @@
 import ch.njol.skript.bukkitutil.BukkitUtils;
 import ch.njol.skript.bukkitutil.EntityUtils;
 import ch.njol.skript.bukkitutil.SkriptTeleportFlag;
-import ch.njol.skript.classes.*;
+import ch.njol.skript.classes.ClassInfo;
+import ch.njol.skript.classes.EnumClassInfo;
+import ch.njol.skript.classes.Parser;
+import ch.njol.skript.classes.PatternedParser;
+import ch.njol.skript.classes.Serializer;
 import ch.njol.skript.classes.registry.RegistryClassInfo;
 import ch.njol.skript.expressions.ExprDamageCause;
 import ch.njol.skript.expressions.base.EventValueExpression;
@@ -26,7 +30,12 @@
 import org.bukkit.command.CommandSender;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.enchantments.EnchantmentOffer;
-import org.bukkit.entity.*;
+import org.bukkit.entity.EntitySnapshot;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.Vehicle;
+import org.bukkit.entity.Villager;
 import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
 import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
 import org.bukkit.event.entity.EntityPotionEffectEvent;
@@ -52,15 +61,20 @@
 import org.bukkit.util.CachedServerIcon;
 import org.bukkit.util.Vector;
 import org.jetbrains.annotations.Nullable;
-import org.skriptlang.skript.bukkit.base.types.*;
+import org.skriptlang.skript.bukkit.base.types.BlockClassInfo;
+import org.skriptlang.skript.bukkit.base.types.EntityClassInfo;
 import org.skriptlang.skript.bukkit.base.types.EntityClassInfo.EntityChanger;
+import org.skriptlang.skript.bukkit.base.types.InventoryClassInfo;
+import org.skriptlang.skript.bukkit.base.types.ItemStackClassInfo;
+import org.skriptlang.skript.bukkit.base.types.NameableClassInfo;
+import org.skriptlang.skript.bukkit.base.types.OfflinePlayerClassInfo;
+import org.skriptlang.skript.bukkit.base.types.PlayerClassInfo;
+import org.skriptlang.skript.bukkit.base.types.WorldClassInfo;
 import org.skriptlang.skript.lang.properties.Property;
 import org.skriptlang.skript.lang.properties.PropertyHandler.ExpressionPropertyHandler;
 
 import java.io.StreamCorruptedException;
 import java.util.Arrays;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 public class BukkitClasses {
 
@@ -331,87 +345,7 @@ protected boolean canBeInstantiated() {
 				})
 				.cloner(Vector::clone));
 
-		Classes.registerClass(new ClassInfo<>(World.class, "world")
-				.user("worlds?")
-				.name("World")
-				.description("One of the server's worlds. Worlds can be put into scripts by surrounding their name with double quotes, e.g. \"world_nether\", " +
-						"but this might not work reliably as <a href='#string'>text</a> uses the same syntax.")
-				.usage("<code>\"world_name\"</code>, e.g. \"world\"")
-				.examples("broadcast \"Hello!\" to the world \"world_nether\"")
-				.since("1.0, 2.2 (alternate syntax)")
-				.after("string")
-				.defaultExpression(new EventValueExpression<>(World.class))
-				.parser(new Parser<World>() {
-					@SuppressWarnings("null")
-					private final Pattern parsePattern = Pattern.compile("(?:(?:the )?world )?\"(.+)\"", Pattern.CASE_INSENSITIVE);
-
-					@Override
-					@Nullable
-					public World parse(final String s, final ParseContext context) {
-						// REMIND allow shortcuts '[over]world', 'nether' and '[the_]end' (server.properties: 'level-name=world') // inconsistent with 'world is "..."'
-						if (context == ParseContext.COMMAND || context == ParseContext.PARSE || context == ParseContext.CONFIG)
-							return Bukkit.getWorld(s);
-						final Matcher m = parsePattern.matcher(s);
-						if (m.matches())
-							return Bukkit.getWorld(m.group(1));
-						return null;
-					}
-
-					@Override
-					public String toString(final World w, final int flags) {
-						return "" + w.getName();
-					}
-
-					@Override
-					public String toVariableNameString(final World w) {
-						return "" + w.getName();
-					}
-				}).serializer(new Serializer<World>() {
-					@Override
-					public Fields serialize(final World w) {
-						final Fields f = new Fields();
-						f.putObject("name", w.getName());
-						return f;
-					}
-
-					@Override
-					public void deserialize(final World o, final Fields f) {
-						assert false;
-					}
-
-					@Override
-					public boolean canBeInstantiated() {
-						return false;
-					}
-
-					@Override
-					protected World deserialize(final Fields fields) throws StreamCorruptedException {
-						final String name = fields.getObject("name", String.class);
-						assert name != null;
-						final World w = Bukkit.getWorld(name);
-						if (w == null)
-							throw new StreamCorruptedException("Missing world " + name);
-						return w;
-					}
-
-					// return w.getName();
-					@Override
-					@Nullable
-					public World deserialize(final String s) {
-						return Bukkit.getWorld(s);
-					}
-
-					@Override
-					public boolean mustSyncDeserialization() {
-						return true;
-					}
-				})
-				.property(Property.NAME,
-					"A world's name, as text. Cannot be changed.",
-					Skript.instance(),
-					ExpressionPropertyHandler.of(World::getName, String.class))
-		);
-
+		Classes.registerClass(new WorldClassInfo());
 		Classes.registerClass(new InventoryClassInfo());
 
 		Classes.registerClass(new EnumClassInfo<>(InventoryAction.class, "inventoryaction", "inventory actions")
diff --git a/src/main/java/ch/njol/skript/effects/EffScriptFile.java b/src/main/java/ch/njol/skript/effects/EffScriptFile.java
deleted file mode 100644
index 5a90098798b..00000000000
--- a/src/main/java/ch/njol/skript/effects/EffScriptFile.java
+++ /dev/null
@@ -1,216 +0,0 @@
-package ch.njol.skript.effects;
-
-import ch.njol.skript.ScriptLoader;
-import ch.njol.skript.Skript;
-import ch.njol.skript.SkriptCommand;
-import ch.njol.skript.command.ScriptCommand;
-import ch.njol.skript.doc.Description;
-import ch.njol.skript.doc.Examples;
-import ch.njol.skript.doc.Name;
-import ch.njol.skript.doc.Since;
-import ch.njol.skript.lang.Effect;
-import ch.njol.skript.lang.Expression;
-import ch.njol.skript.localization.Language;
-import ch.njol.skript.localization.PluralizingArgsMessage;
-import ch.njol.skript.log.LogEntry;
-import ch.njol.skript.log.LogHandler;
-import ch.njol.skript.log.RedirectingLogHandler;
-import ch.njol.skript.log.RetainingLogHandler;
-import ch.njol.skript.log.TimingLogHandler;
-import ch.njol.skript.registrations.Feature;
-import ch.njol.skript.util.Utils;
-import ch.njol.util.StringUtils;
-import org.bukkit.Bukkit;
-import org.bukkit.command.CommandSender;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.annotations.UnknownNullability;
-import org.skriptlang.skript.lang.script.Script;
-import ch.njol.skript.lang.SkriptParser;
-import ch.njol.skript.util.FileUtils;
-import ch.njol.util.Kleenean;
-import ch.njol.util.OpenCloseable;
-import org.bukkit.event.Event;
-
-import java.io.File;
-import java.io.FileFilter;
-import java.io.IOException;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.logging.Level;
-import java.util.stream.Collectors;
-
-@Name("Enable/Disable/Unload/Reload Script")
-@Description("""
-	Enables, disables, unloads, or reloads a script.
-	
-	Disabling a script unloads it and prepends - to its name so it will not be loaded the next time the server restarts.
-	If the script reflection experiment is enabled: unloading a script terminates it and removes it from memory, but does not alter the file.""")
-@Examples({
-	"reload script \"test\"",
-	"enable script file \"testing\"",
-	"unload script file \"script.sk\"",
-	"set {_script} to the script \"MyScript.sk\"",
-	"reload {_script}"
-})
-@Since("2.4, 2.10 (unloading)")
-public class EffScriptFile extends Effect {
-
-	static {
-		Skript.registerEffect(EffScriptFile.class,
-			"(1:(enable|load)|2:reload|3:disable|4:unload) script [file|named] %string% [print:with errors]",
-			"(1:(enable|load)|2:reload|3:disable|4:unload) skript file %string% [print:with errors]",
-			"(1:(enable|load)|2:reload|3:disable|4:unload) %scripts% [print:with errors]"
-		);
-		/*
-			The string-pattern must come first (since otherwise `script X` would match the expression)
-			and we cannot get a script object for a non-loaded script.
-		 */
-	}
-
-	private static final int ENABLE = 1, RELOAD = 2, DISABLE = 3, UNLOAD = 4;
-
-	private int mark;
-
-	private @UnknownNullability Expression<String> scriptNameExpression;
-	private @UnknownNullability Expression<Script> scriptExpression;
-	private boolean scripts, hasReflection, printErrors;
-
-	@Override
-	@SuppressWarnings("unchecked")
-	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
-		this.mark = parseResult.mark;
-		printErrors = parseResult.hasTag("print");
-		switch (matchedPattern) {
-			case 0, 1:
-				this.scriptNameExpression = (Expression<String>) exprs[0];
-				break;
-			case 2:
-				this.scriptExpression = (Expression<Script>) exprs[0];
-				this.scripts = true;
-		}
-		this.hasReflection = this.getParser().hasExperiment(Feature.SCRIPT_REFLECTION);
-		return true;
-	}
-
-	@Override
-	protected void execute(Event event) {
-		Set<CommandSender> recipients = new HashSet<>();
-		if (printErrors) {
-			recipients.addAll(Bukkit.getOnlinePlayers().stream()
-				.filter(player -> player.hasPermission("skript.reloadnotify"))
-				.collect(Collectors.toSet()));
-		}
-		RedirectingLogHandler logHandler = new RedirectingLogHandler(recipients, "").start();
-
-		if (scripts) {
-			for (Script script : scriptExpression.getArray(event)) {
-				@Nullable File file = script.getConfig().getFile();
-				this.handle(file, script.getConfig().getFileName(), logHandler);
-			}
-		} else {
-			String name = scriptNameExpression.getSingle(event);
-			if (name != null)
-				this.handle(ScriptLoader.getScriptFromName(name), name, logHandler);
-		}
-		logHandler.close();
-	}
-
-	private void handle(@Nullable File scriptFile, @Nullable String name, OpenCloseable openCloseable) {
-		if (scriptFile == null || !scriptFile.exists())
-			return;
-		if (name == null)
-			name = scriptFile.getName();
-		FileFilter filter = ScriptLoader.getDisabledScriptsFilter();
-		switch (mark) {
-			case ENABLE:
-				if (ScriptLoader.getLoadedScripts().contains(ScriptLoader.getScript(scriptFile)))
-					return;
-				if (filter.accept(scriptFile)) {
-					try {
-						// TODO Central methods to be used between here and SkriptCommand should be created for
-						//  enabling/disabling (renaming) files
-						scriptFile = FileUtils.move(
-							scriptFile,
-							new File(scriptFile.getParentFile(), scriptFile.getName()
-								.substring(ScriptLoader.DISABLED_SCRIPT_PREFIX_LENGTH)),
-							false
-						);
-					} catch (IOException ex) {
-						//noinspection ThrowableNotThrown
-						Skript.exception(ex, "Error while enabling script file: " + name);
-						return;
-					}
-				}
-
-				ScriptLoader.loadScripts(scriptFile, openCloseable);
-				break;
-			case RELOAD:
-				if (filter.accept(scriptFile))
-					return;
-
-				this.unloadScripts(scriptFile);
-
-				ScriptLoader.loadScripts(scriptFile, openCloseable);
-				break;
-			case UNLOAD:
-				if (hasReflection) { // if we don't use the new features this falls through into DISABLE
-					if (!ScriptLoader.getLoadedScriptsFilter().accept(scriptFile))
-						return;
-
-					this.unloadScripts(scriptFile);
-					break;
-				}
-			case DISABLE:
-				if (filter.accept(scriptFile))
-					return;
-
-				this.unloadScripts(scriptFile);
-
-				try {
-					FileUtils.move(
-						scriptFile,
-						new File(scriptFile.getParentFile(), ScriptLoader.DISABLED_SCRIPT_PREFIX + scriptFile.getName()),
-						false
-					);
-				} catch (IOException ex) {
-					//noinspection ThrowableNotThrown
-					Skript.exception(ex, "Error while disabling script file: " + name);
-					return;
-				}
-				break;
-			default:
-				assert false;
-		}
-	}
-
-	private void unloadScripts(File file) {
-		Set<Script> loaded = ScriptLoader.getLoadedScripts();
-		if (file.isDirectory()) {
-			Set<Script> scripts = ScriptLoader.getScripts(file);
-			if (scripts.isEmpty())
-				return;
-			scripts.retainAll(loaded); // skip any that are not loaded (avoid throwing error)
-			ScriptLoader.unloadScripts(scripts);
-		} else {
-			Script script = ScriptLoader.getScript(file);
-			if (!loaded.contains(script))
-				return; // don't need to unload if not loaded (avoid throwing error)
-			if (script != null)
-				ScriptLoader.unloadScript(script);
-		}
-	}
-
-	@Override
-	public String toString(@Nullable Event event, boolean debug) {
-		String start = switch (mark) {
-			case ENABLE -> "enable";
-			case DISABLE -> "disable";
-			case RELOAD -> "reload";
-			default -> "unload";
-		} + " ";
-		if (scripts)
-			return start + scriptExpression.toString(event, debug);
-		return start + "script file " + scriptNameExpression.toString(event, debug);
-	}
-
-}
diff --git a/src/main/java/ch/njol/skript/effects/EffWorldLoad.java b/src/main/java/ch/njol/skript/effects/EffWorldLoad.java
index 820017c87ea..0f80d9e9462 100644
--- a/src/main/java/ch/njol/skript/effects/EffWorldLoad.java
+++ b/src/main/java/ch/njol/skript/effects/EffWorldLoad.java
@@ -2,7 +2,7 @@
 
 import ch.njol.skript.Skript;
 import ch.njol.skript.doc.Description;
-import ch.njol.skript.doc.Examples;
+import ch.njol.skript.doc.Example;
 import ch.njol.skript.doc.Name;
 import ch.njol.skript.doc.Since;
 import ch.njol.skript.lang.Effect;
@@ -17,58 +17,60 @@
 import org.jetbrains.annotations.Nullable;
 
 @Name("Load World")
-@Description({
-		"Load your worlds or unload your worlds",
-		"The load effect will create a new world if world doesn't already exist.",
-		"When attempting to load a normal vanilla world you must define it's environment i.e \"world_nether\" must be loaded with nether environment"
-})
-@Examples({
-		"load world \"world_nether\" with environment nether",
-		"load the world \"myCustomWorld\"",
-		"unload \"world_nether\"",
-		"unload \"world_the_end\" without saving",
-		"unload all worlds"
-})
+@Description("""
+	Load or unload a world.
+	Loading a world that does not already exist will create a new one.
+	When attempting to load a normal vanilla world, you must define it's environment. Such as "world_nether" would need \
+	to be loaded with the 'nether' environment.
+	
+	See also: the generic 'unload' effect, which will save and unload a world.
+	""")
+@Example("load world \"world_nether\" with environment nether")
+@Example("load the world \"myCustomWorld\"")
+@Example("unload \"world_the_end\" without saving")
 @Since("2.8.0")
 public class EffWorldLoad extends Effect {
 
 	static {
 		Skript.registerEffect(EffWorldLoad.class,
 				"load [the] world[s] %strings% [with environment %-environment%]",
-				"unload [[the] world[s]] %worlds% [:without saving]"
+				"unload [[the] world[s]] %worlds% without saving"
 		);
 	}
 
-	private boolean save, load;
-	private Expression<?> worlds;
-	@Nullable
-	private Expression<Environment> environment;
+	private boolean load;
+	private Expression<String> strings;
+	private Expression<World> worlds;
+	private @Nullable Expression<Environment> environment;
 
 	@Override
-	@SuppressWarnings("unchecked")
 	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
-		worlds = exprs[0];
 		load = matchedPattern == 0;
 		if (load) {
+			//noinspection unchecked
+			strings = (Expression<String>) exprs[0];
+			//noinspection unchecked
 			environment = (Expression<Environment>) exprs[1];
 		} else {
-			save = !parseResult.hasTag("without saving");
+			//noinspection unchecked
+			worlds = (Expression<World>) exprs[0];
 		}
 		return true;
 	}
 
 	@Override
 	protected void execute(Event event) {
-		Environment environment = this.environment != null ? this.environment.getSingle(event) : null;
-		for (Object world : worlds.getArray(event)) {
-			if (load && world instanceof String) {
-				WorldCreator worldCreator = new WorldCreator((String) world);
+		if (load) {
+			Environment environment = this.environment != null ? this.environment.getSingle(event) : null;
+			for (String string : strings.getArray(event)) {
+				WorldCreator worldCreator = new WorldCreator(string);
 				if (environment != null)
 					worldCreator.environment(environment);
 				worldCreator.createWorld();
-			} else if (!load && world instanceof World) {
-				Bukkit.unloadWorld((World) world, save);
 			}
+		} else {
+			for (World world : worlds.getArray(event))
+				Bukkit.unloadWorld(world, false);
 		}
 	}
 
@@ -76,7 +78,7 @@ protected void execute(Event event) {
 	public String toString(@Nullable Event event, boolean debug) {
 		if (load)
 			return "load the world(s) " + worlds.toString(event, debug) + (environment == null ? "" : " with environment " + environment.toString(event, debug));
-		return "unload the world(s) " + worlds.toString(event, debug) + " " + (save ? "with saving" : "without saving");
+		return "unload the world(s) " + worlds.toString(event, debug) + " without saving";
 	}
 
 }
diff --git a/src/main/java/ch/njol/skript/expressions/ExprScripts.java b/src/main/java/ch/njol/skript/expressions/ExprScripts.java
index 2a3f3e79b43..881d1b21abd 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprScripts.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprScripts.java
@@ -14,6 +14,7 @@
 import org.bukkit.event.Event;
 import org.jetbrains.annotations.Nullable;
 import ch.njol.skript.registrations.experiments.ReflectionExperimentSyntax;
+import org.skriptlang.skript.common.expressions.ExprScript;
 import org.skriptlang.skript.lang.script.Script;
 
 import java.util.ArrayList;
diff --git a/src/main/java/org/skriptlang/skript/bukkit/base/types/WorldClassInfo.java b/src/main/java/org/skriptlang/skript/bukkit/base/types/WorldClassInfo.java
new file mode 100644
index 00000000000..81e0fe9cb95
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/bukkit/base/types/WorldClassInfo.java
@@ -0,0 +1,118 @@
+package org.skriptlang.skript.bukkit.base.types;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.classes.ClassInfo;
+import ch.njol.skript.classes.Parser;
+import ch.njol.skript.classes.Serializer;
+import ch.njol.skript.expressions.base.EventValueExpression;
+import ch.njol.skript.lang.ParseContext;
+import ch.njol.yggdrasil.Fields;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.lang.properties.Property;
+import org.skriptlang.skript.lang.properties.PropertyHandler.EffectHandler;
+import org.skriptlang.skript.lang.properties.PropertyHandler.ExpressionPropertyHandler;
+
+import java.io.StreamCorruptedException;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class WorldClassInfo extends ClassInfo<World> {
+
+	public WorldClassInfo() {
+		super(World.class, "world");
+		this.user("worlds?")
+			.name("World")
+			.description("One of the server's worlds. Worlds can be put into scripts by surrounding their name with double quotes, e.g. \"world_nether\", " +
+				"but this might not work reliably as <a href='#string'>text</a> uses the same syntax.")
+			.usage("<code>\"world_name\"</code>, e.g. \"world\"")
+			.examples("broadcast \"Hello!\" to the world \"world_nether\"")
+			.since("1.0, 2.2 (alternate syntax)")
+			.after("string")
+			.defaultExpression(new EventValueExpression<>(World.class))
+			.parser(new WorldParser())
+			.serializer(new WorldSerializer())
+			.property(Property.NAME,
+				"A world's name, as text. Cannot be changed.",
+				Skript.instance(),
+				ExpressionPropertyHandler.of(World::getName, String.class))
+			.property(Property.UNLOAD,
+				"Unloads and saves a world.",
+				Skript.instance(),
+				new WorldUnloadHandler());
+	}
+
+	private static class WorldParser extends Parser<World> {
+		//<editor-fold desc="world parser" defaultstate="collapsed">
+		private static final Pattern PARSE_PATTERN = Pattern.compile("(?:(?:the )?world )?\"(.+)\"", Pattern.CASE_INSENSITIVE);
+
+		@Override
+		public @Nullable World parse(String s, ParseContext context) {
+			// REMIND allow shortcuts '[over]world', 'nether' and '[the_]end' (server.properties: 'level-name=world') // inconsistent with 'world is "..."'
+			if (context == ParseContext.COMMAND || context == ParseContext.PARSE || context == ParseContext.CONFIG)
+				return Bukkit.getWorld(s);
+			Matcher matcher = PARSE_PATTERN.matcher(s);
+			if (matcher.matches())
+				return Bukkit.getWorld(matcher.group(1));
+			return null;
+		}
+
+		@Override
+		public String toString(World world, int flags) {
+			return world.getName();
+		}
+
+		@Override
+		public String toVariableNameString(World world) {
+			return world.getName();
+		}
+		//</editor-fold>
+	}
+
+	private static class WorldSerializer extends Serializer<World> {
+		//<editor-fold desc="world serializer" defaultstate="collapsed">
+		@Override
+		public Fields serialize(World world) {
+			Fields fields = new Fields();
+			fields.putObject("name", world.getName());
+			return fields;
+		}
+
+		@Override
+		public void deserialize(World world, Fields fields) {
+			assert false;
+		}
+
+		@Override
+		public boolean canBeInstantiated() {
+			return false;
+		}
+
+		@Override
+		protected World deserialize(Fields fields) throws StreamCorruptedException {
+			String name = fields.getObject("name", String.class);
+			assert name != null;
+			org.bukkit.World world = Bukkit.getWorld(name);
+			if (world == null)
+				throw new StreamCorruptedException("Missing world " + name);
+			return world;
+		}
+
+		@Override
+		public boolean mustSyncDeserialization() {
+			return true;
+		}
+		//</editor-fold>
+	}
+
+	private static class WorldUnloadHandler implements EffectHandler<World> {
+		//<editor-fold desc="unload property handler" defaultstate="collapsed">
+		@Override
+		public void execute(World world) {
+			Bukkit.unloadWorld(world, true);
+		}
+		//</editor-fold>
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/common/CommonModule.java b/src/main/java/org/skriptlang/skript/common/CommonModule.java
index 22de43efd99..76183060450 100644
--- a/src/main/java/org/skriptlang/skript/common/CommonModule.java
+++ b/src/main/java/org/skriptlang/skript/common/CommonModule.java
@@ -3,6 +3,8 @@
 import ch.njol.skript.Skript;
 import org.skriptlang.skript.addon.AddonModule;
 import org.skriptlang.skript.addon.SkriptAddon;
+import org.skriptlang.skript.common.effects.EffScriptFile;
+import org.skriptlang.skript.common.expressions.ExprScript;
 import org.skriptlang.skript.common.properties.PropertiesModule;
 
 import java.io.IOException;
@@ -16,6 +18,9 @@ public void load(SkriptAddon addon) {
 			throw new RuntimeException(e);
 		}
 
+		EffScriptFile.register(addon.syntaxRegistry());
+		ExprScript.register(addon.syntaxRegistry());
+
 		addon.loadModules(new PropertiesModule());
 	}
 }
diff --git a/src/main/java/org/skriptlang/skript/common/effects/EffScriptFile.java b/src/main/java/org/skriptlang/skript/common/effects/EffScriptFile.java
new file mode 100644
index 00000000000..4a76589af60
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/common/effects/EffScriptFile.java
@@ -0,0 +1,79 @@
+package org.skriptlang.skript.common.effects;
+
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Example;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.Since;
+import ch.njol.skript.lang.Effect;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser;
+import ch.njol.skript.log.RedirectingLogHandler;
+import ch.njol.util.Kleenean;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.lang.script.Script;
+import org.skriptlang.skript.registration.SyntaxInfo;
+import org.skriptlang.skript.registration.SyntaxRegistry;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@Name("Enable/Reload Script With Errors")
+@Description("""
+	Enables or reloads a script.
+	Any errors occurred will be printed to console and to all players with the permission 'skript.reloadnotify'.
+	
+	See also: the generic 'load/enable' and 'reload' effects for loading or reloading a script without any errors being printed.
+	""")
+@Example("reload script \"test\"")
+@Example("enable script file \"testing\"")
+@Since("2.4, 2.10 (unloading)")
+public class EffScriptFile extends Effect {
+
+	public static void register(SyntaxRegistry registry) {
+		registry.register(
+			SyntaxRegistry.EFFECT,
+			SyntaxInfo.builder(EffScriptFile.class)
+				.addPatterns("(enable:(enable|load)|reload) [the] [script[s]] %scripts% with errors")
+				.supplier(EffScriptFile::new)
+				.build());
+	}
+
+	private Expression<Script> scriptExpression;
+	private boolean isEnable;
+
+	@Override
+	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
+		//noinspection unchecked
+		scriptExpression = (Expression<Script>) exprs[0];
+		isEnable = parseResult.hasTag("enable");
+		return true;
+	}
+
+	@Override
+	protected void execute(Event event) {
+		Set<CommandSender> recipients = Bukkit.getOnlinePlayers().stream()
+			.filter(player -> player.hasPermission("skript.reloadnotify"))
+			.collect(Collectors.toSet());
+		RedirectingLogHandler logHandler = new RedirectingLogHandler(recipients, "").start();
+
+		if (isEnable) {
+			for (Script script : scriptExpression.getArray(event)) {
+				script.load(logHandler);
+			}
+		} else {
+			for (Script script : scriptExpression.getArray(event)) {
+				script.reload(logHandler);
+			}
+		}
+		logHandler.close();
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return (isEnable ? "enable " : "reload ") + scriptExpression.toString(event, debug) + " with errors";
+	}
+
+}
diff --git a/src/main/java/ch/njol/skript/expressions/ExprScript.java b/src/main/java/org/skriptlang/skript/common/expressions/ExprScript.java
similarity index 68%
rename from src/main/java/ch/njol/skript/expressions/ExprScript.java
rename to src/main/java/org/skriptlang/skript/common/expressions/ExprScript.java
index c217a5e5847..d8725eed23f 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprScript.java
+++ b/src/main/java/org/skriptlang/skript/common/expressions/ExprScript.java
@@ -1,20 +1,22 @@
-package ch.njol.skript.expressions;
+package org.skriptlang.skript.common.expressions;
 
 import ch.njol.skript.ScriptLoader;
 import ch.njol.skript.Skript;
 import ch.njol.skript.doc.Description;
-import ch.njol.skript.doc.Examples;
+import ch.njol.skript.doc.Example;
 import ch.njol.skript.doc.Name;
 import ch.njol.skript.doc.Since;
 import ch.njol.skript.lang.Expression;
-import ch.njol.skript.lang.ExpressionType;
-import ch.njol.skript.lang.parser.ParserInstance;
-import org.jetbrains.annotations.Nullable;
-import org.skriptlang.skript.lang.script.Script;
 import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.parser.ParserInstance;
 import ch.njol.skript.lang.util.SimpleExpression;
 import ch.njol.util.Kleenean;
 import org.bukkit.event.Event;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.lang.script.Script;
+import org.skriptlang.skript.lang.script.ScriptWarning;
+import org.skriptlang.skript.registration.SyntaxInfo;
+import org.skriptlang.skript.registration.SyntaxRegistry;
 
 import java.io.File;
 import java.io.FileFilter;
@@ -23,28 +25,41 @@
 import java.util.Objects;
 
 @Name("Script")
-@Description({"The current script, or a script from its (file) name.",
-	"If the script is enabled or disabled (or reloaded) this reference will become invalid.",
-	"Therefore, it is recommended to obtain a script reference <em>when needed</em>."})
-@Examples({
-	"on script load:",
-	"\tbroadcast \"Loaded %the current script%\"",
-	"on script load:",
-	"\tset {running::%script%} to true",
-	"on script unload:",
-	"\tset {running::%script%} to false",
-	"set {script} to the script named \"weather.sk\"",
-	"loop the scripts in directory \"quests/\":",
-	"\tenable loop-value"
-})
+@Description("""
+	The current script, or a script from its (file) name.
+	If the script is enabled or disabled (or reloaded) this reference will become invalid.
+	Therefore, it is recommended to obtain a script reference <em>when needed</em>.
+	""")
+@Example("""
+	on script load:
+		broadcast "Loaded %the current script%"
+	""")
+@Example("""
+	on script load:
+		set {running::%script%} to true
+	on script unload:
+		set {running::%script%} to false
+	""")
+@Example("set {script} to the script named \"weather.sk\"")
+@Example("""
+	loop the scripts in directory "quests/":
+		enable loop-value
+	""")
 @Since("2.0")
 public class ExprScript extends SimpleExpression<Script> {
 
-	static {
-		Skript.registerExpression(ExprScript.class, Script.class, ExpressionType.SIMPLE,
-			"[the] [current] script",
-			"[the] script[s] [named] %strings%",
-			"[the] scripts in [directory|folder] %string%"
+	public static void register(SyntaxRegistry registry) {
+		registry.register(
+			SyntaxRegistry.EXPRESSION,
+			SyntaxInfo.Expression.builder(ExprScript.class, Script.class)
+				.addPatterns(
+					"[the] [current] script [file]",
+					"[the] script[s] [file[s]] [named] %strings%",
+					"[the] skript file[s] %strings%",
+					"[the] scripts in [directory|folder] %string%"
+				)
+				.supplier(ExprScript::new)
+				.build()
 		);
 	}
 
@@ -54,7 +69,7 @@ public class ExprScript extends SimpleExpression<Script> {
 
 	@Override
 	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
-		this.isDirectory = matchedPattern == 2;
+		this.isDirectory = matchedPattern == 3;
 		if (matchedPattern == 0) {
 			ParserInstance parser = this.getParser();
 			if (!parser.isActive()) {
@@ -66,6 +81,9 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 			//noinspection unchecked
 			this.name = (Expression<String>) exprs[0];
 		}
+		if (matchedPattern == 2) {
+			ScriptWarning.printDeprecationWarning("This pattern 'skript file' is deprecated and will be removed in the future.");
+		}
 		return true;
 	}
 
@@ -132,7 +150,7 @@ public String toString(@Nullable Event event, boolean debug) {
 		return "the scripts named " + name.toString(event, debug);
 	}
 
-	static @Nullable Script getHandle(@Nullable File file) {
+	public static @Nullable Script getHandle(@Nullable File file) {
 		if (file == null || file.isDirectory())
 			return null;
 		Script script = ScriptLoader.getScript(file);
diff --git a/src/main/java/org/skriptlang/skript/common/properties/PropertiesModule.java b/src/main/java/org/skriptlang/skript/common/properties/PropertiesModule.java
index 81db9eae319..a08b55002a0 100644
--- a/src/main/java/org/skriptlang/skript/common/properties/PropertiesModule.java
+++ b/src/main/java/org/skriptlang/skript/common/properties/PropertiesModule.java
@@ -1,7 +1,6 @@
 package org.skriptlang.skript.common.properties;
 
 import ch.njol.skript.Skript;
-import ch.njol.skript.SkriptConfig;
 import org.skriptlang.skript.addon.AddonModule;
 import org.skriptlang.skript.addon.SkriptAddon;
 
@@ -9,17 +8,15 @@
 
 public class PropertiesModule implements AddonModule {
 
-	@Override
-	public boolean canLoad(SkriptAddon addon) {
-		return SkriptConfig.useTypeProperties.value();
-	}
-
 	@Override
 	public void load(SkriptAddon addon) {
 		try {
-			Skript.getAddonInstance().loadClasses("org.skriptlang.skript.common.properties", "expressions", "conditions");
+			Skript.getAddonInstance().loadClasses(
+				"org.skriptlang.skript.common.properties",
+				"expressions", "conditions", "effects");
 		} catch (IOException e) {
 			throw new RuntimeException(e);
 		}
 	}
+
 }
diff --git a/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffDisable.java b/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffDisable.java
new file mode 100644
index 00000000000..e383c4c2a5a
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffDisable.java
@@ -0,0 +1,36 @@
+package org.skriptlang.skript.common.properties.effects;
+
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.RelatedProperty;
+import ch.njol.skript.doc.Since;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.lang.properties.Property;
+import org.skriptlang.skript.lang.properties.PropertyBaseEffect;
+import org.skriptlang.skript.lang.properties.PropertyHandler.EffectHandler;
+
+@Name("Disable")
+@Description("""
+	Disables something.
+	""")
+@Since("INSERT VERSION")
+@RelatedProperty("disable")
+public class PropEffDisable extends PropertyBaseEffect<EffectHandler<?>> {
+
+	static {
+		register(PropEffDisable.class, "disable %objects%");
+	}
+
+	@Override
+	public @NotNull Property<EffectHandler<?>> getProperty() {
+		return Property.DISABLE;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "disable " + expr.toString(event, debug);
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffEnable.java b/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffEnable.java
new file mode 100644
index 00000000000..d917ed6a173
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffEnable.java
@@ -0,0 +1,36 @@
+package org.skriptlang.skript.common.properties.effects;
+
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.RelatedProperty;
+import ch.njol.skript.doc.Since;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.lang.properties.Property;
+import org.skriptlang.skript.lang.properties.PropertyBaseEffect;
+import org.skriptlang.skript.lang.properties.PropertyHandler.EffectHandler;
+
+@Name("Enable")
+@Description("""
+	Enables something.
+	""")
+@Since("INSERT VERSION")
+@RelatedProperty("enable")
+public class PropEffEnable extends PropertyBaseEffect<EffectHandler<?>> {
+
+	static {
+		register(PropEffEnable.class, "enable %objects%");
+	}
+
+	@Override
+	public @NotNull Property<EffectHandler<?>> getProperty() {
+		return Property.ENABLE;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "enable " + expr.toString(event, debug);
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffLoad.java b/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffLoad.java
new file mode 100644
index 00000000000..fe88f8387c0
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffLoad.java
@@ -0,0 +1,36 @@
+package org.skriptlang.skript.common.properties.effects;
+
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.RelatedProperty;
+import ch.njol.skript.doc.Since;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.lang.properties.Property;
+import org.skriptlang.skript.lang.properties.PropertyBaseEffect;
+import org.skriptlang.skript.lang.properties.PropertyHandler.EffectHandler;
+
+@Name("Load")
+@Description("""
+	Loads something.
+	""")
+@Since("INSERT VERSION")
+@RelatedProperty("load")
+public class PropEffLoad extends PropertyBaseEffect<EffectHandler<?>> {
+
+	static {
+		register(PropEffLoad.class, "load %objects%");
+	}
+
+	@Override
+	public @NotNull Property<EffectHandler<?>> getProperty() {
+		return Property.LOAD;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "load " + expr.toString(event, debug);
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffReload.java b/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffReload.java
new file mode 100644
index 00000000000..2425d2ba8c2
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffReload.java
@@ -0,0 +1,36 @@
+package org.skriptlang.skript.common.properties.effects;
+
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.RelatedProperty;
+import ch.njol.skript.doc.Since;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.lang.properties.Property;
+import org.skriptlang.skript.lang.properties.PropertyBaseEffect;
+import org.skriptlang.skript.lang.properties.PropertyHandler.EffectHandler;
+
+@Name("Reload")
+@Description("""
+	Reloads something.
+	""")
+@Since("INSERT VERSION")
+@RelatedProperty("reload")
+public class PropEffReload extends PropertyBaseEffect<EffectHandler<?>> {
+
+	static {
+		register(PropEffReload.class, "reload %objects%");
+	}
+
+	@Override
+	public @NotNull Property<EffectHandler<?>> getProperty() {
+		return Property.RELOAD;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "reload " + expr.toString(event, debug);
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffUnload.java b/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffUnload.java
new file mode 100644
index 00000000000..3d67a269122
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/common/properties/effects/PropEffUnload.java
@@ -0,0 +1,36 @@
+package org.skriptlang.skript.common.properties.effects;
+
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.RelatedProperty;
+import ch.njol.skript.doc.Since;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.lang.properties.Property;
+import org.skriptlang.skript.lang.properties.PropertyBaseEffect;
+import org.skriptlang.skript.lang.properties.PropertyHandler.EffectHandler;
+
+@Name("Unload")
+@Description("""
+	Unloads something.
+	""")
+@Since("INSERT VERSION")
+@RelatedProperty("unload")
+public class PropEffUnload extends PropertyBaseEffect<EffectHandler<?>> {
+
+	static {
+		register(PropEffUnload.class, "unload %objects%");
+	}
+
+	@Override
+	public @NotNull Property<EffectHandler<?>> getProperty() {
+		return Property.UNLOAD;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "unload " + expr.toString(event, debug);
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/common/types/ScriptClassInfo.java b/src/main/java/org/skriptlang/skript/common/types/ScriptClassInfo.java
index 8a45d41439c..8ecce5d6ab9 100644
--- a/src/main/java/org/skriptlang/skript/common/types/ScriptClassInfo.java
+++ b/src/main/java/org/skriptlang/skript/common/types/ScriptClassInfo.java
@@ -13,6 +13,7 @@
 import org.jetbrains.annotations.Nullable;
 import org.skriptlang.skript.lang.properties.Property;
 import org.skriptlang.skript.lang.properties.PropertyHandler;
+import org.skriptlang.skript.lang.properties.PropertyHandler.EffectHandler;
 import org.skriptlang.skript.lang.properties.PropertyHandler.ExpressionPropertyHandler;
 import org.skriptlang.skript.lang.script.Script;
 
@@ -37,7 +38,31 @@ public ScriptClassInfo() {
 					+ "this will return the resolved name of the script, otherwise it returns the file "
 					+ "name with path relative to the scripts folder. Cannot be changed.",
 				Skript.instance(),
-				new ScriptNameHandler());
+				new ScriptNameHandler())
+			.property(Property.LOAD,
+				"Loads a script if not already loaded.",
+				Skript.instance(),
+				EffectHandler.of(Script::load))
+			.property(Property.ENABLE,
+				"Enables a script if not already enabled.",
+				Skript.instance(),
+				EffectHandler.of(Script::load))
+			.property(Property.RELOAD,
+				"Reloads a script.",
+				Skript.instance(),
+				EffectHandler.of(Script::reload))
+			.property(Property.UNLOAD,
+				"Unloads a script and removes it from memory.",
+				Skript.instance(),
+				EffectHandler.of(Script::unload))
+			.property(Property.DISABLE,
+				"""
+				Disables a script if not already disabled.
+				Disabling a script unloads it and prepends "-" to the file name so it will not be loaded the next time \
+				the server restarts.
+				""",
+				Skript.instance(),
+				EffectHandler.of(Script::disable));
 	}
 
 	private static class ScriptParser extends Parser<Script> {
diff --git a/src/main/java/org/skriptlang/skript/lang/properties/Property.java b/src/main/java/org/skriptlang/skript/lang/properties/Property.java
index 01171aafbb8..884d477778d 100644
--- a/src/main/java/org/skriptlang/skript/lang/properties/Property.java
+++ b/src/main/java/org/skriptlang/skript/lang/properties/Property.java
@@ -18,6 +18,7 @@
 import org.skriptlang.skript.common.types.ScriptClassInfo;
 import org.skriptlang.skript.lang.properties.PropertyHandler.ConditionPropertyHandler;
 import org.skriptlang.skript.lang.properties.PropertyHandler.ContainsHandler;
+import org.skriptlang.skript.lang.properties.PropertyHandler.EffectHandler;
 import org.skriptlang.skript.lang.properties.PropertyHandler.ExpressionPropertyHandler;
 import org.skriptlang.skript.lang.properties.PropertyHandler.TypedValuePropertyHandler;
 
@@ -244,6 +245,61 @@ public record PropertyInfo<Handler extends PropertyHandler<?>>(Property<Handler>
 			Skript.instance(),
 			TypedValuePropertyHandler.class);
 
+	/**
+	 * A property for something that can be loaded.
+	 */
+	public static final Property<EffectHandler<?>> LOAD = Property.of(
+		"load",
+		"Something that can be loaded.",
+		"INSERT VERSION",
+		Skript.instance(),
+		EffectHandler.class
+	);
+
+	/**
+	 * A property for something that can be unloaded.
+	 */
+	public static final Property<EffectHandler<?>> UNLOAD = Property.of(
+		"unload",
+		"Something that can be unloaded.",
+		"INSERT VERSION",
+		Skript.instance(),
+		EffectHandler.class
+	);
+
+	/**
+	 * A property for something that can be reloaded.
+	 */
+	public static final Property<EffectHandler<?>> RELOAD = Property.of(
+		"reload",
+		"Something that can be reloaded.",
+		"INSERT VERSION",
+		Skript.instance(),
+		EffectHandler.class
+	);
+
+	/**
+	 * A property for something that can be enabled.
+	 */
+	public static final Property<EffectHandler<?>> ENABLE = Property.of(
+		"enable",
+		"Something that can be enabled.",
+		"INSERT VERSION",
+		Skript.instance(),
+		EffectHandler.class
+	);
+
+	/**
+	 * A property for something that can be disabled.
+	 */
+	public static final Property<EffectHandler<?>> DISABLE = Property.of(
+		"disable",
+		"Something that can be disabled.",
+		"INSERT VERSION",
+		Skript.instance(),
+		EffectHandler.class
+	);
+
 	/**
 	 * Register all Skript's default properties. Should be done prior to loading classinfos.
 	 */
@@ -256,6 +312,11 @@ public static void registerDefaultProperties() {
 		NUMBER.register();
 		IS_EMPTY.register();
 		TYPED_VALUE.register();
+		LOAD.register();
+		UNLOAD.register();
+		RELOAD.register();
+		ENABLE.register();
+		DISABLE.register();
 	}
 
 }
diff --git a/src/main/java/org/skriptlang/skript/lang/properties/PropertyBaseEffect.java b/src/main/java/org/skriptlang/skript/lang/properties/PropertyBaseEffect.java
new file mode 100644
index 00000000000..c87d9009cfd
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/lang/properties/PropertyBaseEffect.java
@@ -0,0 +1,70 @@
+package org.skriptlang.skript.lang.properties;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Effect;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.util.LiteralUtils;
+import ch.njol.util.Kleenean;
+import org.bukkit.event.Event;
+import org.skriptlang.skript.lang.properties.PropertyHandler.EffectHandler;
+
+/**
+ * A helper class for implementing property-driven effects.
+ * @param <Handler> The handler type expected for this property.
+ */
+public abstract class PropertyBaseEffect<Handler extends EffectHandler<?>> extends Effect implements PropertyBaseSyntax<Handler> {
+
+	protected static void register(Class<? extends PropertyBaseEffect<?>> effectClass, String ... patterns) {
+		Skript.registerEffect(effectClass, patterns);
+	}
+
+	protected Expression<?> expr;
+	protected PropertyMap<Handler> properties;
+	protected final Property<Handler> property = getProperty();
+
+	@Override
+	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+		expr = PropertyBaseSyntax.asProperty(property, exprs[0]);
+		if (expr == null) {
+			Skript.error(getBadTypesErrorMessage(exprs[0]));
+			return false;
+		}
+
+		properties = PropertyBaseSyntax.getPossiblePropertyInfos(property, expr);
+		if (properties.isEmpty()) {
+			Skript.error(getBadTypesErrorMessage(expr));
+			return false;
+		}
+
+		return LiteralUtils.canInitSafely(expr);
+	}
+
+	@Override
+	protected void execute(Event event) {
+		expr.stream(event)
+			.forEach(source -> {
+				Handler handler = properties.getHandler(source.getClass());
+				if (handler == null)
+					return;
+				execute(event, handler, source);
+			});
+	}
+
+	/**
+	 * Calls {@link EffectHandler#execute(Object)} using {@code source}.
+	 * Users that override this method may have to cast the handler to have the appropriate generics.
+	 * It is guaranteed that the handler can handle the source object, but the Java generics system cannot
+	 * reflect that. See the default implementation for an example of this sort of casting.
+	 *
+	 * @param event The current {@link Event}.
+	 * @param handler The {@link EffectHandler} used for {@code source}.
+	 * @param source The source object.
+	 * @param <T> The type of the source object and the type the handler will accept.
+	 */
+	@SuppressWarnings("unchecked")
+	protected <T> void execute(Event event, Handler handler, T source) {
+		((EffectHandler<T>) handler).execute(source);
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/lang/properties/PropertyHandler.java b/src/main/java/org/skriptlang/skript/lang/properties/PropertyHandler.java
index 6343cea0ef7..95ff5a14939 100644
--- a/src/main/java/org/skriptlang/skript/lang/properties/PropertyHandler.java
+++ b/src/main/java/org/skriptlang/skript/lang/properties/PropertyHandler.java
@@ -9,6 +9,7 @@
 import ch.njol.skript.registrations.Classes;
 import ch.njol.skript.util.StringMode;
 import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.ApiStatus.Experimental;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -16,6 +17,7 @@
 import org.skriptlang.skript.common.types.ScriptClassInfo;
 import org.skriptlang.skript.lang.converter.Converters;
 
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 
@@ -279,4 +281,33 @@ default boolean canContain(Class<?> type) {
 		}
 	}
 
+	/**
+	 * A handler for executing an effect on an object.
+	 * @param <Type> The type of object.
+	 *
+	 * @see PropertyBaseEffect
+	 */
+	@Experimental
+	interface EffectHandler<Type> extends PropertyHandler<Type> {
+
+		/**
+		 * To execute an effect on the value.
+		 * @param type The value.
+		 */
+		void execute(Type type);
+
+		/**
+		 * Creates a simple property handler from the given consumer.
+		 *
+		 * @param consumer The consumer to trigger execution.
+		 * @param <Type> The type of object this property can be applied to.
+		 * @return A new property handler that uses the given consumer.
+		 */
+		@Contract(value = "_ -> new", pure = true)
+		static <Type> @NotNull EffectHandler<Type> of(Consumer<Type> consumer) {
+			return consumer::accept;
+		}
+
+	}
+
 }
diff --git a/src/main/java/org/skriptlang/skript/lang/script/Script.java b/src/main/java/org/skriptlang/skript/lang/script/Script.java
index 21d060dac65..206e4bba8a6 100644
--- a/src/main/java/org/skriptlang/skript/lang/script/Script.java
+++ b/src/main/java/org/skriptlang/skript/lang/script/Script.java
@@ -1,7 +1,11 @@
 package org.skriptlang.skript.lang.script;
 
+import ch.njol.skript.ScriptLoader;
+import ch.njol.skript.Skript;
 import ch.njol.skript.config.Config;
 import ch.njol.skript.lang.util.common.AnyNamed;
+import ch.njol.skript.util.FileUtils;
+import ch.njol.util.OpenCloseable;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.Unmodifiable;
@@ -10,7 +14,12 @@
 import org.skriptlang.skript.util.event.EventRegistry;
 
 import java.io.File;
-import java.util.*;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Supplier;
 
@@ -212,4 +221,111 @@ public boolean valid() {
 		return false;
 	}
 
+	/**
+	 * Enables and Loads this {@link Script} if it is not already loaded.
+	 */
+	public void load() {
+		load(OpenCloseable.EMPTY);
+	}
+
+	/**
+	 * Enables and Loads this {@link Script} if it is not already loaded.
+	 * @param closeable A handler for catching any errors while loading.
+	 */
+	public void load(OpenCloseable closeable) {
+		File file = getConfig().getFile();
+		if (file == null || !file.exists())
+			return;
+		if (ScriptLoader.getLoadedScripts().contains(ScriptLoader.getScript(file)))
+			return;
+		if (ScriptLoader.getDisabledScriptsFilter().accept(file)) {
+			try {
+				file = FileUtils.move(
+					file,
+					new File(file.getParentFile(), file.getName().substring(ScriptLoader.DISABLED_SCRIPT_PREFIX_LENGTH)),
+					false
+				);
+			} catch (IOException e) {
+				Skript.exception("Error while enabling script file: " + name());
+				return;
+			}
+		}
+		ScriptLoader.loadScripts(file, closeable);
+	}
+
+	/**
+	 * Unloads this {@link Script} if it is loaded.
+	 */
+	public void unload() {
+		File file = getConfig().getFile();
+		if (file == null || !file.exists())
+			return;
+		if (!ScriptLoader.getLoadedScriptsFilter().accept(file))
+			return;
+		unloadScripts(file);
+	}
+
+	/**
+	 * Reloads this {@link Script}.
+	 */
+	public void reload() {
+		reload(OpenCloseable.EMPTY);
+	}
+
+	/**
+	 * Reloads this {@link Script}.
+	 * @param closeable A handler for catching any errors while reloading.
+	 */
+	public void reload(OpenCloseable closeable) {
+		File file = getConfig().getFile();
+		if (file == null || !file.exists())
+			return;
+		if (ScriptLoader.getDisabledScriptsFilter().accept(file))
+			return;
+		unloadScripts(file);
+		ScriptLoader.loadScripts(file, closeable);
+	}
+
+	/**
+	 * Disables this {@link Script} by unloading and disabling the file.
+	 */
+	public void disable() {
+		File file = getConfig().getFile();
+		if (file == null || !file.exists())
+			return;
+		if (ScriptLoader.getDisabledScriptsFilter().accept(file))
+			return;
+		unloadScripts(file);
+
+		try {
+			FileUtils.move(
+				file,
+				new File(file.getParentFile(), ScriptLoader.DISABLED_SCRIPT_PREFIX + file.getName()),
+				false
+			);
+		} catch (IOException e) {
+			Skript.exception(e, "Error while disabling script file: " + name());
+		}
+	}
+
+	/**
+	 * Helper method for unloading a script.
+	 */
+	private static void unloadScripts(File file) {
+		Set<Script> loaded = ScriptLoader.getLoadedScripts();
+		if (file.isDirectory()) {
+			Set<Script> scripts = ScriptLoader.getScripts(file);
+			if (scripts.isEmpty())
+				return;
+			scripts.retainAll(loaded); // skip any that are not loaded (avoid throwing error)
+			ScriptLoader.unloadScripts(scripts);
+		} else {
+			Script script = ScriptLoader.getScript(file);
+			if (!loaded.contains(script))
+				return; // don't need to unload if not loaded (avoid throwing error)
+			if (script != null)
+				ScriptLoader.unloadScript(script);
+		}
+	}
+
 }
diff --git a/src/test/java/ch/njol/skript/patterns/PatternConflictsTest.java b/src/test/java/ch/njol/skript/patterns/PatternConflictsTest.java
index 640ea2649a5..a2ce47fe70a 100644
--- a/src/test/java/ch/njol/skript/patterns/PatternConflictsTest.java
+++ b/src/test/java/ch/njol/skript/patterns/PatternConflictsTest.java
@@ -6,8 +6,6 @@
 import ch.njol.skript.conditions.CondDate;
 import ch.njol.skript.conditions.CondIsLoaded;
 import ch.njol.skript.conditions.CondScriptLoaded;
-import ch.njol.skript.effects.EffScriptFile;
-import ch.njol.skript.effects.EffWorldLoad;
 import ch.njol.skript.expressions.*;
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.Section;
@@ -424,7 +422,6 @@ private boolean exclude(List<Combination> combinations) {
 		// Exclusions by amount of conflicts
 		// 1 conflict
 		EXCLUSIONS.add(new Exclusion("formatted %*%", ExprFormatDate.class, ExprColoured.class));
-		EXCLUSIONS.add(new Exclusion("unload %*%", EffScriptFile.class, EffWorldLoad.class));
 		EXCLUSIONS.add(new Exclusion("the %*% of %*%", ExprArmorSlot.class, ExprEntities.class));
 		EXCLUSIONS.add(new Exclusion("%*% of %*%", ExprArmorSlot.class, ExprEntities.class, ExprXOf.class));