diff --git a/src/main/java/io/github/syst3ms/skriptparser/Skript.java b/src/main/java/io/github/syst3ms/skriptparser/Skript.java
index f0ed8a2f..9e759160 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/Skript.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/Skript.java
@@ -3,6 +3,7 @@
 import io.github.syst3ms.skriptparser.lang.Trigger;
 import io.github.syst3ms.skriptparser.lang.TriggerMap;
 import io.github.syst3ms.skriptparser.lang.event.StartOnLoadEvent;
+import io.github.syst3ms.skriptparser.parsing.Script;
 import io.github.syst3ms.skriptparser.registration.SkriptAddon;
 import io.github.syst3ms.skriptparser.registration.SkriptRegistration;
 import io.github.syst3ms.skriptparser.structures.functions.StructFunction;
@@ -24,12 +25,12 @@ public Skript(String[] mainArgs) {
     }
 
     @Override
-    public void finishedLoading(@Nullable String scriptName) {
+    public void finishedLoading(@Nullable Script script) {
         List<Trigger> triggers;
-        if (scriptName == null) {
+        if (script == null) {
             triggers = TriggerMap.getAllTriggers();
         } else {
-            triggers = TriggerMap.getTriggersByScript(scriptName).values().stream().flatMap(List::stream).toList();
+            triggers = TriggerMap.getTriggersByScript(script).values().stream().flatMap(List::stream).toList();
         }
         triggers.stream().sorted(Comparator.comparing(trigger -> trigger.getEvent().getLoadingPriority())).forEach(trigger -> {
             if (trigger.getEvent() instanceof StartOnLoadEvent event) {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/config/Config.java b/src/main/java/io/github/syst3ms/skriptparser/config/Config.java
index 18468426..ea5a77ae 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/config/Config.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/config/Config.java
@@ -52,7 +52,7 @@ public Config(Path path, String resourceToCopy, SkriptLogger logger) {
             throw new RuntimeException(e);
         }
 
-        this.fileElements = FileParser.parseFileLines(path.toString(), strings, 0, 1, logger);
+        this.fileElements = FileParser.parseFileLines(path, strings, 0, 1, logger);
         logger.debug("Loaded config file at " + path + " with " + fileElements.size() + " lines");
     }
 
diff --git a/src/main/java/io/github/syst3ms/skriptparser/expressions/LitScriptName.java b/src/main/java/io/github/syst3ms/skriptparser/expressions/LitScriptName.java
index 3ae31a9c..bcd5584d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/expressions/LitScriptName.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/expressions/LitScriptName.java
@@ -6,7 +6,6 @@
 import io.github.syst3ms.skriptparser.lang.TriggerContext;
 import io.github.syst3ms.skriptparser.log.SkriptLogger;
 import io.github.syst3ms.skriptparser.parsing.ParseContext;
-import io.github.syst3ms.skriptparser.util.FileUtils;
 
 /**
  * The name of the current executed script, without the extension.
@@ -38,7 +37,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
 
     @Override
     public String[] getValues() {
-        return new String[]{FileUtils.removeExtension(logger.getFileName())};
+        return new String[]{logger.getScript().scriptName()};
     }
 
     @Override
diff --git a/src/main/java/io/github/syst3ms/skriptparser/file/FileElement.java b/src/main/java/io/github/syst3ms/skriptparser/file/FileElement.java
index b5fee322..e10d6e84 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/file/FileElement.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/file/FileElement.java
@@ -1,5 +1,7 @@
 package io.github.syst3ms.skriptparser.file;
 
+import java.nio.file.Path;
+
 /**
  * Represents any non-blank and not comment-only line in a file. It is important to note that information about comments
  * is absent from this class, as they are discarded before being passed to the constructor.<br>
@@ -9,13 +11,21 @@
  * additional properties.</strong>
  */
 public class FileElement {
-    private final String fileName;
+    private final Path filePath;
     private final int line;
     private final String content;
     private final int indentation;
 
+    /**
+     * @deprecated Use {@link #FileElement(Path, int, String, int)} instead.
+     */
+    @Deprecated(forRemoval = true)
     public FileElement(String fileName, int line, String content, int indentation) {
-        this.fileName = fileName;
+        this(Path.of(fileName), line, content, indentation);
+    }
+
+    public FileElement(Path filePath, int line, String content, int indentation) {
+        this.filePath = filePath;
         this.line = line;
         this.content = content;
         this.indentation = indentation;
@@ -24,6 +34,7 @@ public FileElement(String fileName, int line, String content, int indentation) {
     /**
      * The returned {@link String} does not include the indentation of the line. To have the line content along with
      * indentation, use {@link #toString()}
+     *
      * @return the text content of this line, excluding any indentation.
      */
     public String getLineContent() {
@@ -34,14 +45,13 @@ public String getLineContent() {
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
-        if (!(obj instanceof FileElement)) {
+        if (!(obj instanceof FileElement other)) {
             return false;
         } else {
-            var other = (FileElement) obj;
             return indentation == other.indentation &&
-                   line == other.line &&
-                   content.equalsIgnoreCase(other.content) &&
-                   fileName.equals(other.fileName);
+                line == other.line &&
+                content.equalsIgnoreCase(other.content) &&
+                filePath.toAbsolutePath().normalize().equals(other.filePath.toAbsolutePath().normalize());
         }
     }
 
@@ -58,14 +68,23 @@ public String toString() {
     }
 
     /**
-     * @return the name of the file this line is contained in
+     * @deprecated Use {@link #getFilePath()} instead.
      */
+    @Deprecated(forRemoval = true)
     public String getFileName() {
-        return fileName;
+        return filePath.toString();
+    }
+
+    /**
+     * @return the path of the file this line is contained in
+     */
+    public Path getFilePath() {
+        return filePath;
     }
 
     /**
      * Line numbering starts at 1, and blank and comment-only lines are accounted for.
+     *
      * @return the line in the file where this line is located at.
      */
     public int getLine() {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/file/FileParser.java b/src/main/java/io/github/syst3ms/skriptparser/file/FileParser.java
index 6b6dbfc1..0ce28478 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/file/FileParser.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/file/FileParser.java
@@ -4,6 +4,7 @@
 import io.github.syst3ms.skriptparser.log.SkriptLogger;
 import io.github.syst3ms.skriptparser.util.FileUtils;
 
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Pattern;
@@ -15,12 +16,20 @@ public class FileParser {
 
     public static final Pattern COMMENT_PATTERN = Pattern.compile("#(?=(?:(?:[^\"]*\"){2})*[^\"]*$)");
 
+    /**
+     * @deprecated Use {@link #parseFileLines(Path, List, int, int, SkriptLogger)} instead.
+     */
+    @Deprecated(forRemoval = true)
+    public static List<FileElement> parseFileLines(String fileName, List<String> lines, int expectedIndentation, int lastLine, SkriptLogger logger) {
+        return parseFileLines(Path.of(fileName), lines, expectedIndentation, lastLine, logger);
+    }
+
     /**
      * Parses a {@linkplain List} of strings into a list of {@link FileElement}s. This creates {@link FileElement} and
      * {@link FileSection} objects from the lines, effectively structuring the lines into a tree.
      * This removes comments from each line, and discards any blank lines afterwards.
      *
-     * @param fileName            the name of the file the lines belong to
+     * @param filePath            the path of the file the lines belong to
      * @param lines               the list of lines to parse
      * @param expectedIndentation the indentation level the first line is expected to be at
      * @param lastLine            a parameter that keeps track of the line count throughout recursive calls of this method when
@@ -28,7 +37,7 @@ public class FileParser {
      * @param logger              the logger
      * @return a list of {@link FileElement}s
      */
-    public static List<FileElement> parseFileLines(String fileName, List<String> lines, int expectedIndentation, int lastLine, SkriptLogger logger) {
+    public static List<FileElement> parseFileLines(Path filePath, List<String> lines, int expectedIndentation, int lastLine, SkriptLogger logger) {
         List<FileElement> elements = new ArrayList<>();
         boolean multiLineComment = false;
         for (var i = 0; i < lines.size(); i++) {
@@ -42,7 +51,7 @@ public static List<FileElement> parseFileLines(String fileName, List<String> lin
             String content = removeComments(line);
 
             if (multiLineComment || content.isEmpty()) {
-                elements.add(new VoidElement(fileName, lastLine + i, expectedIndentation));
+                elements.add(new VoidElement(filePath, lastLine + i, expectedIndentation));
                 continue;
             }
 
@@ -59,20 +68,20 @@ public static List<FileElement> parseFileLines(String fileName, List<String> lin
             }
             if (content.endsWith(":")) {
                 if (i + 1 == lines.size()) {
-                    elements.add(new FileSection(fileName, lastLine + i, content.substring(0, content.length() - 1),
+                    elements.add(new FileSection(filePath, lastLine + i, content.substring(0, content.length() - 1),
                         new ArrayList<>(), expectedIndentation
                     ));
                 } else {
-                    var sectionElements = parseFileLines(fileName, lines.subList(i + 1, lines.size()),
+                    var sectionElements = parseFileLines(filePath, lines.subList(i + 1, lines.size()),
                         expectedIndentation + 1, lastLine + i + 1,
                         logger);
-                    elements.add(new FileSection(fileName, lastLine + i, content.substring(0, content.length() - 1),
+                    elements.add(new FileSection(filePath, lastLine + i, content.substring(0, content.length() - 1),
                         sectionElements, expectedIndentation
                     ));
                     i += count(sectionElements);
                 }
             } else {
-                elements.add(new FileElement(fileName, lastLine + i, content, expectedIndentation));
+                elements.add(new FileElement(filePath, lastLine + i, content, expectedIndentation));
             }
         }
         return elements;
diff --git a/src/main/java/io/github/syst3ms/skriptparser/file/FileSection.java b/src/main/java/io/github/syst3ms/skriptparser/file/FileSection.java
index 464adab9..5b543d8e 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/file/FileSection.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/file/FileSection.java
@@ -2,6 +2,7 @@
 
 import io.github.syst3ms.skriptparser.lang.entries.OptionLoader;
 
+import java.nio.file.Path;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Stream;
@@ -15,8 +16,16 @@ public class FileSection extends FileElement {
     private final List<FileElement> elements;
     private int length = -1;
 
+    /**
+     * @deprecated Use {@link #FileSection(Path, int, String, List, int)} instead.
+     */
+    @Deprecated(forRemoval = true)
     public FileSection(String fileName, int line, String content, List<FileElement> elements, int indentation) {
-        super(fileName, line, content, indentation);
+        this(Path.of(fileName), line, content, elements, indentation);
+    }
+
+    public FileSection(Path filePath, int line, String content, List<FileElement> elements, int indentation) {
+        super(filePath, line, content, indentation);
         this.elements = elements;
     }
 
diff --git a/src/main/java/io/github/syst3ms/skriptparser/file/VoidElement.java b/src/main/java/io/github/syst3ms/skriptparser/file/VoidElement.java
index f309c12f..357a858b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/file/VoidElement.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/file/VoidElement.java
@@ -1,10 +1,21 @@
 package io.github.syst3ms.skriptparser.file;
 
+import java.nio.file.Path;
+
 /**
  * A {@link FileElement} representing a blank line.
  */
 public class VoidElement extends FileElement {
+
+    /**
+     * @deprecated Use {@link #VoidElement(Path, int, int)} instead.
+     */
+    @Deprecated(forRemoval = true)
     public VoidElement(String fileName, int line, int indentation) {
-        super(fileName, line, "", indentation);
+        this(Path.of(fileName), line, indentation);
+    }
+
+    public VoidElement(Path filePath, int line, int indentation) {
+        super(filePath, line, "", indentation);
     }
 }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/lang/TriggerMap.java b/src/main/java/io/github/syst3ms/skriptparser/lang/TriggerMap.java
index e3f6b1bb..ad764b21 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/lang/TriggerMap.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/lang/TriggerMap.java
@@ -1,5 +1,7 @@
 package io.github.syst3ms.skriptparser.lang;
 
+import io.github.syst3ms.skriptparser.parsing.Script;
+import io.github.syst3ms.skriptparser.parsing.ScriptLoader;
 import io.github.syst3ms.skriptparser.structures.functions.Functions;
 import io.github.syst3ms.skriptparser.variables.Variables;
 
@@ -14,40 +16,67 @@
  */
 public class TriggerMap {
 
-    private static final Map<String, Map<Class<? extends TriggerContext>, List<Trigger>>> TRIGGERS = new TreeMap<>();
+    private static final Map<Script, Map<Class<? extends TriggerContext>, List<Trigger>>> TRIGGERS = new TreeMap<>();
+
+    /**
+     * @deprecated Use {@link #addTrigger(Script, Class, Trigger)} instead.
+     */
+    @Deprecated(forRemoval = true)
+    public static void addTrigger(String scriptName, Class<? extends TriggerContext> context, Trigger trigger) {
+        Script script = ScriptLoader.getScriptByName(scriptName);
+        if (script != null) addTrigger(script, context, trigger);
+    }
 
     /**
      * Add a trigger to the map.
      *
-     * @param scriptName Name of a script
+     * @param script     The script to add the trigger to
      * @param context    Trigger context class to which the trigger should be added
      * @param trigger    Trigger to add
      */
-    public static void addTrigger(String scriptName, Class<? extends TriggerContext> context, Trigger trigger) {
-        TRIGGERS.computeIfAbsent(scriptName, k -> new HashMap<>()).computeIfAbsent(context, k -> new ArrayList<>()).add(trigger);
+    public static void addTrigger(Script script, Class<? extends TriggerContext> context, Trigger trigger) {
+        TRIGGERS.computeIfAbsent(script, k -> new HashMap<>()).computeIfAbsent(context, k -> new ArrayList<>()).add(trigger);
+    }
+
+    /**
+     * @deprecated Use {@link #clearTriggers(Script)} instead.
+     */
+    @Deprecated(forRemoval = true)
+    public static void clearTriggers(String scriptName) {
+        Script script = ScriptLoader.getScriptByName(scriptName);
+        if (script != null) clearTriggers(script);
     }
 
     /**
      * Clear all triggers for a script.
      *
-     * @param scriptName Script name to clear triggers for
+     * @param script Script to clear triggers for
      */
-    public static void clearTriggers(String scriptName) {
-        TRIGGERS.getOrDefault(scriptName, Map.of()).values().forEach(triggers -> {
+    public static void clearTriggers(Script script) {
+        TRIGGERS.getOrDefault(script, Map.of()).values().forEach(triggers -> {
             triggers.forEach(trigger -> trigger.getEvent().unload());
         });
-        TRIGGERS.remove(scriptName);
-        Functions.removeFunctions(scriptName);
+        TRIGGERS.remove(script);
+        Functions.removeFunctions(script);
+    }
+
+    /**
+     * @deprecated Use {@link #getTriggersByScript(Script)} instead.
+     */
+    @Deprecated(forRemoval = true)
+    public static Map<Class<? extends TriggerContext>, List<Trigger>> getTriggersByScript(String scriptName) {
+        Script script = ScriptLoader.getScriptByName(scriptName);
+        return script != null ? getTriggersByScript(script) : Map.of();
     }
 
     /**
      * Get all the triggers associated with a script.
      *
-     * @param scriptName Script name to get triggers for
+     * @param script Script to get triggers for
      * @return Map of trigger contexts to triggers
      */
-    public static Map<Class<? extends TriggerContext>, List<Trigger>> getTriggersByScript(String scriptName) {
-        return TRIGGERS.getOrDefault(scriptName, Map.of());
+    public static Map<Class<? extends TriggerContext>, List<Trigger>> getTriggersByScript(Script script) {
+        return TRIGGERS.getOrDefault(script, Map.of());
     }
 
     /**
diff --git a/src/main/java/io/github/syst3ms/skriptparser/log/SkriptLogger.java b/src/main/java/io/github/syst3ms/skriptparser/log/SkriptLogger.java
index 5dc51d87..befd80cf 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/log/SkriptLogger.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/log/SkriptLogger.java
@@ -2,6 +2,8 @@
 
 import io.github.syst3ms.skriptparser.file.FileElement;
 import io.github.syst3ms.skriptparser.file.FileSection;
+import io.github.syst3ms.skriptparser.parsing.Script;
+import io.github.syst3ms.skriptparser.parsing.ScriptLoader;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
@@ -56,7 +58,7 @@ public class SkriptLogger {
     private boolean hasError = false;
     private final LinkedList<ErrorContext> errorContext = new LinkedList<>();
     // File
-    private String fileName;
+    private Script script;
     private List<FileElement> fileElements;
     private int line = -1;
     // Logs
@@ -72,13 +74,19 @@ public SkriptLogger() {
         this(false);
     }
 
+    @Deprecated(forRemoval = true)
+    public void setFileInfo(String fileName, List<FileElement> fileElements) {
+        Script script = ScriptLoader.getScriptByName(fileName);
+        setFileInfo(script, fileElements);
+    }
+
     /**
      * Provides the logger information about the file it's currently parsing
-     * @param fileName the file name
+     * @param script the {@link Script} this logger is for
      * @param fileElements the {@link FileElement}s of the current file
      */
-    public void setFileInfo(String fileName, List<FileElement> fileElements) {
-        this.fileName = fileName;
+    public void setFileInfo(Script script, List<FileElement> fileElements) {
+        this.script = script;
         this.fileElements = flatten(fileElements);
     }
 
@@ -153,7 +161,7 @@ private void log(String message, LogType type, @Nullable ErrorType error, @Nulla
                                 message,
                                 line + 1,
                                 fileElements.get(line).getLineContent(),
-                                fileName),
+                                script.scriptName()),
                         type, line, ctx, error, tip
                 ));
             }
@@ -298,8 +306,16 @@ public void setDebug(boolean debug) {
         this.debug = debug;
     }
 
+    /**
+     * @deprecated use {@link #getScript()} instead.
+     */
+    @Deprecated(forRemoval = true)
     public String getFileName() {
-        return fileName;
+        return script.scriptName();
+    }
+
+    public Script getScript() {
+        return script;
     }
 
     /**
diff --git a/src/main/java/io/github/syst3ms/skriptparser/parsing/Script.java b/src/main/java/io/github/syst3ms/skriptparser/parsing/Script.java
new file mode 100644
index 00000000..d7cdfe31
--- /dev/null
+++ b/src/main/java/io/github/syst3ms/skriptparser/parsing/Script.java
@@ -0,0 +1,27 @@
+package io.github.syst3ms.skriptparser.parsing;
+
+import java.nio.file.Path;
+
+/**
+ * Represents a script file.
+ * This record just encapsulates the file path of the script.
+ *
+ * @param scriptPath the {@link Path} pointing to the script file
+ */
+public record Script(Path scriptPath) implements Comparable<Script> {
+
+    /**
+     * Get the name of the script, without the {@code .sk} extension
+     */
+    public String scriptName() {
+        String fileName = scriptPath.getFileName().toString();
+        int lastDot = fileName.lastIndexOf('.');
+        return lastDot == -1 ? fileName : fileName.substring(0, lastDot);
+    }
+
+    @Override
+    public int compareTo(Script o) {
+        return this.scriptPath.compareTo(o.scriptPath);
+    }
+
+}
diff --git a/src/main/java/io/github/syst3ms/skriptparser/parsing/ScriptLoader.java b/src/main/java/io/github/syst3ms/skriptparser/parsing/ScriptLoader.java
index 881273c1..64dacce5 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/parsing/ScriptLoader.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/parsing/ScriptLoader.java
@@ -13,10 +13,12 @@
 import io.github.syst3ms.skriptparser.log.LogEntry;
 import io.github.syst3ms.skriptparser.log.SkriptLogger;
 import io.github.syst3ms.skriptparser.util.FileUtils;
+import org.jetbrains.annotations.Nullable;
 
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
@@ -26,6 +28,29 @@
  */
 public class ScriptLoader {
 
+    private static final List<Script> LOADED_SCRIPTS = new ArrayList<>();
+
+    /**
+     * Get a collection of all currently loaded scripts.
+     *
+     * @return A collection of loaded Script objects
+     */
+    public static Collection<Script> getLoadedScripts() {
+        return Collections.unmodifiableCollection(LOADED_SCRIPTS);
+    }
+
+    /**
+     * Get a loaded Script object by its parsed name.
+     * This is method is inconsistent since scripts with the same name in different directories can exist.
+     *
+     * @param scriptName The name of the script
+     * @return The Script object, or null if not loaded
+     */
+    @Deprecated(forRemoval = true)
+    public static @Nullable Script getScriptByName(String scriptName) {
+        return LOADED_SCRIPTS.stream().filter(s -> s.scriptName().equals(scriptName)).findFirst().orElse(null);
+    }
+
     /**
      * Parses and loads the provided script in memory.
      *
@@ -46,15 +71,27 @@ public static List<LogEntry> loadScript(Path scriptPath, boolean debug) {
      */
     public static List<LogEntry> loadScript(Path scriptPath, SkriptLogger logger, boolean debug) {
         List<FileElement> elements;
-        String scriptName = scriptPath.getFileName().toString().replaceAll("(.+)\\..+", "$1");
 
-        // Clear triggers from unloaded events
-        TriggerMap.clearTriggers(scriptName);
+        Script oldScript = LOADED_SCRIPTS.stream()
+            .filter(s -> s.scriptPath().equals(scriptPath))
+            .findFirst()
+            .orElse(null);
+
+        if (oldScript != null) {
+            // Clean up the old instance from everywhere
+            TriggerMap.clearTriggers(oldScript);
+            LOADED_SCRIPTS.remove(oldScript);
+        }
+
+        Script script = new Script(scriptPath);
+        String scriptName = script.scriptName();
 
         try {
             var lines = FileUtils.readAllLines(scriptPath);
 
-            elements = FileParser.parseFileLines(scriptName,
+            LOADED_SCRIPTS.add(script);
+
+            elements = FileParser.parseFileLines(scriptPath,
                 lines,
                 0,
                 1,
@@ -65,8 +102,10 @@ public static List<LogEntry> loadScript(Path scriptPath, SkriptLogger logger, bo
             e.printStackTrace();
             return Collections.emptyList();
         }
-        logger.setFileInfo(scriptPath.getFileName().toString(), elements);
+
+        logger.setFileInfo(script, elements);
         List<UnloadedTrigger> unloadedTriggers = new ArrayList<>();
+
         for (var element : elements) {
             logger.finalizeLogs();
             logger.nextLine();
@@ -100,10 +139,10 @@ public static List<LogEntry> loadScript(Path scriptPath, SkriptLogger logger, bo
             Set<Class<? extends TriggerContext>> contexts = unloaded.eventInfo().getContexts();
             if (contexts.isEmpty()) {
                 // A dummy context will be used for this
-                TriggerMap.addTrigger(scriptName, TriggerContext.class, loaded);
+                TriggerMap.addTrigger(script, TriggerContext.class, loaded);
             } else {
                 for (Class<? extends TriggerContext> context : contexts) {
-                    TriggerMap.addTrigger(scriptName, context, loaded);
+                    TriggerMap.addTrigger(script, context, loaded);
                 }
             }
         }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptAddon.java b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptAddon.java
index f47061e2..a4ec2e2e 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptAddon.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/registration/SkriptAddon.java
@@ -3,6 +3,7 @@
 import io.github.syst3ms.skriptparser.Skript;
 import io.github.syst3ms.skriptparser.lang.Trigger;
 import io.github.syst3ms.skriptparser.lang.event.SkriptEvent;
+import io.github.syst3ms.skriptparser.parsing.Script;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -52,16 +53,31 @@ public final String getAddonName() {
     }
 
     /**
-     * Is called when a script has finished loading. Optionally overridable.
+     * @deprecated Use {@link #finishedLoading(Script)} instead.
      */
+    @Deprecated(forRemoval = true)
     public void finishedLoading(@Nullable String scriptName) {
+
+    }
+
+    /**
+     * Is called when a script has finished loading. Optionally overridable.
+     */
+    public void finishedLoading(@Nullable Script script) {
+        if (script != null) {
+            // this is for backwards compatibility
+            // this should be made to contain no default implementation after removing all the other forRemovals, that are using scriptName instead of Script
+            finishedLoading(script.scriptName());
+        } else {
+            finishedLoading((String) null);
+        }
     }
 
     /**
      * Is called when all scripts have finished loading. Optionally overridable.
      */
     public void finishedLoading() {
-        finishedLoading(null);
+        finishedLoading((Script) null);
     }
 
     /**
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java
index df67a74b..986a5527 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/EffFunctionCall.java
@@ -51,7 +51,7 @@ protected void execute(TriggerContext ctx) {
     public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
         MatchResult result = parseContext.getMatches().get(0); // whole pattern matched because it is one single regex
         String functionName = result.group(1);
-        Optional<Function<?>> optionalFunction = Functions.getFunctionByName(functionName, parseContext.getLogger().getFileName());
+        Optional<Function<?>> optionalFunction = Functions.getFunctionByName(functionName, parseContext.getLogger().getScript());
         SkriptLogger logger = parseContext.getLogger();
         if (optionalFunction.isEmpty()) {
             logger.error("No function was found under the name '" + functionName + "'", ErrorType.SEMANTIC_ERROR);
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ExprFunctionCall.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ExprFunctionCall.java
index f79ddce7..f2bf5dd8 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ExprFunctionCall.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ExprFunctionCall.java
@@ -53,7 +53,7 @@ public Object[] getValues(TriggerContext ctx) {
     public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContext parseContext) {
         MatchResult result = parseContext.getMatches().get(0); // whole pattern matched because it is one single regex
         String functionName = result.group(1);
-        Optional<Function<?>> optionalFunction = Functions.getFunctionByName(functionName, parseContext.getLogger().getFileName());
+        Optional<Function<?>> optionalFunction = Functions.getFunctionByName(functionName, parseContext.getLogger().getScript());
         SkriptLogger logger = parseContext.getLogger();
         if (optionalFunction.isEmpty()) {
             logger.error("No function was found under the name '" + functionName + "'", ErrorType.SEMANTIC_ERROR);
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/Functions.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/Functions.java
index d63d6bd0..69531825 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/Functions.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/Functions.java
@@ -4,9 +4,12 @@
 import io.github.syst3ms.skriptparser.lang.Trigger;
 import io.github.syst3ms.skriptparser.log.ErrorType;
 import io.github.syst3ms.skriptparser.log.SkriptLogger;
+import io.github.syst3ms.skriptparser.parsing.Script;
+import io.github.syst3ms.skriptparser.parsing.ScriptLoader;
 import io.github.syst3ms.skriptparser.registration.SkriptAddon;
 import io.github.syst3ms.skriptparser.registration.SkriptRegistration;
 
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -18,16 +21,31 @@ public class Functions {
 
     static final String FUNCTION_NAME_REGEX = "^[a-zA-Z0-9_]*";
     static final String FUNCTION_CALL_PATTERN = "<(" + Functions.FUNCTION_NAME_REGEX + ")\\((.*)\\)>";
-    private static final Map<String, List<Function<?>>> functionsMap = new HashMap<>();
+    private static final Map<Script, List<Function<?>>> functionsMap = new HashMap<>();
     private static final Map<SkriptAddon, List<Function<?>>> FUNCTIONS_BY_ADDON = new HashMap<>();
-    private static final String JAVA_FUNCTION_NAME = "java_functions_dont_change";
+    private static final Script JAVA_FUNCTIONS_SCRIPT = new Script(Path.of("java_functions_dont_change.sk"));
     private static final Pattern FUNCTION_NAME_PATTERN = Pattern.compile(FUNCTION_NAME_REGEX);
 
     private Functions() {
     }
 
+    /**
+     * @deprecated Use {@link #getFunctions(Script)} instead.
+     */
+    @Deprecated(forRemoval = true)
     public static List<Function<?>> getFunctions(String scriptName) {
-        return functionsMap.getOrDefault(scriptName, List.of());
+        Script script = ScriptLoader.getScriptByName(scriptName);
+        return script != null ? getFunctions(script) : List.of();
+    }
+
+    /**
+     * Get all functions associated with a script.
+     *
+     * @param script Script to get functions for
+     * @return List of functions
+     */
+    public static List<Function<?>> getFunctions(Script script) {
+        return functionsMap.getOrDefault(script, List.of());
     }
 
     public static List<Function<?>> getAllFunctions() {
@@ -39,33 +57,47 @@ public static List<Function<?>> getJavaFunctions(SkriptRegistration registration
     }
 
     static void preRegisterFunction(ScriptFunction<?> function) {
-        String scriptName = function.getScriptName();
-        functionsMap.computeIfAbsent(scriptName, k -> new ArrayList<>()).add(function);
+        Script script = function.getScript();
+        functionsMap.computeIfAbsent(script, k -> new ArrayList<>()).add(function);
     }
 
     public static void registerFunction(ScriptFunction<?> function, Trigger trigger) {
         function.setTrigger(trigger);
     }
 
+    /**
+     * @deprecated Use {@link #removeFunctions(Script)} instead.
+     */
+    @Deprecated(forRemoval = true)
     public static void removeFunctions(String scriptName) {
-        if (functionsMap.containsKey(scriptName)) {
-            for (Function<?> function : functionsMap.get(scriptName)) {
+        Script script = ScriptLoader.getScriptByName(scriptName);
+        if (script != null) removeFunctions(script);
+    }
+
+    /**
+     * Remove all functions for a script.
+     *
+     * @param script Script to remove functions for
+     */
+    public static void removeFunctions(Script script) {
+        if (functionsMap.containsKey(script)) {
+            for (Function<?> function : functionsMap.get(script)) {
                 if (function instanceof ScriptFunction<?> sf) {
                     sf.setTrigger(null);
                 }
             }
+            functionsMap.remove(script);
         }
-        functionsMap.put(scriptName, new ArrayList<>());
     }
 
     public static void registerFunction(SkriptRegistration registration, JavaFunction<?> function) {
-        functionsMap.computeIfAbsent(JAVA_FUNCTION_NAME, k -> new ArrayList<>()).add(function);
+        functionsMap.computeIfAbsent(JAVA_FUNCTIONS_SCRIPT, k -> new ArrayList<>()).add(function);
         FUNCTIONS_BY_ADDON.computeIfAbsent(registration.getRegisterer(), k -> new ArrayList<>()).add(function);
     }
 
     public static boolean isValidFunction(ScriptFunction<?> function, SkriptLogger logger) {
-        String scriptName = function.getScriptName();
-        for (Function<?> registeredFunction : functionsMap.computeIfAbsent(scriptName, k -> new ArrayList<>())) {
+        Script script = function.getScript();
+        for (Function<?> registeredFunction : functionsMap.computeIfAbsent(script, k -> new ArrayList<>())) {
             String registeredFunctionName = registeredFunction.getName();
             String providedFunctionName = function.getName();
             if (!registeredFunctionName.equals(providedFunctionName)) continue;
@@ -75,19 +107,19 @@ public static boolean isValidFunction(ScriptFunction<?> function, SkriptLogger l
                 return false;
             }
             ScriptFunction<?> registeredScriptFunction = (ScriptFunction<?>) registeredFunction;
-            String registeredScriptName = registeredScriptFunction.getScriptName();
+            Script registeredScript = registeredScriptFunction.getScript();
             if (!registeredScriptFunction.isLocal()) { // already registered function is global so it takes name precedence
                 logger.error("A global script function named '" + providedFunctionName + "' already exists in " +
-                    registeredScriptName + ".", ErrorType.SEMANTIC_ERROR);
+                    registeredScript + ".", ErrorType.SEMANTIC_ERROR);
                 return false;
             }
             if (!function.isLocal()) {
                 // if a global function is trying to be defined when a local function already has that name, there will be problems in the script where the local function lies
                 logger.error("A local script function named '" + providedFunctionName + "' already exists in " +
-                    registeredScriptName + ".", ErrorType.SEMANTIC_ERROR);
+                    registeredScript + ".", ErrorType.SEMANTIC_ERROR);
                 return false;
             }
-            if (registeredScriptName.equals(function.getScriptName())) {
+            if (registeredScript.equals(function.getScript())) {
                 logger.error("Two local functions with the same name ('" + registeredFunctionName + "')" +
                     " can't exist in the same script.", ErrorType.SEMANTIC_ERROR);
                 return false;
@@ -96,23 +128,31 @@ public static boolean isValidFunction(ScriptFunction<?> function, SkriptLogger l
         return true;
     }
 
+    /**
+     * @deprecated Use {@link #getFunctionByName(String, Script)} instead.
+     */
+    @Deprecated(forRemoval = true)
     public static Optional<Function<?>> getFunctionByName(String name, String scriptName) {
+        if (scriptName.endsWith(".sk")) scriptName = scriptName.substring(0, scriptName.length() - 3); // old functionality did this too
+        Script script = ScriptLoader.getScriptByName(scriptName);
+        return script != null ? getFunctionByName(name, script) : Optional.empty();
+    }
+
+    public static Optional<Function<?>> getFunctionByName(String name, Script script) {
         // Find a JavaFunction
-        for (Function<?> function : functionsMap.computeIfAbsent(JAVA_FUNCTION_NAME, k -> new ArrayList<>())) {
+        for (Function<?> function : functionsMap.computeIfAbsent(JAVA_FUNCTIONS_SCRIPT, k -> new ArrayList<>())) {
             if (function.getName().equals(name)) {
                 return Optional.of(function);
             }
         }
 
         // Find a function in a script file
-        if (scriptName.endsWith(".sk")) scriptName = scriptName.substring(0, scriptName.length() - 3);
-
         for (Function<?> registeredFunction : getAllFunctions()) {
             if (!registeredFunction.getName().equals(name))
                 continue; // we don't care then!!!! goodbye continue to the next one
             if (registeredFunction instanceof ScriptFunction<?> registeredScriptFunction
                 && registeredScriptFunction.isLocal()
-                && !scriptName.equals(registeredScriptFunction.getScriptName())) {
+                && !script.equals(registeredScriptFunction.getScript())) {
                 continue;
                 //return Optional.of(registeredFunction); handled below
             }
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ScriptFunction.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ScriptFunction.java
index 9a054af4..bd74e64d 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ScriptFunction.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/ScriptFunction.java
@@ -3,18 +3,18 @@
 import io.github.syst3ms.skriptparser.lang.Statement;
 import io.github.syst3ms.skriptparser.lang.Trigger;
 import io.github.syst3ms.skriptparser.lang.TriggerContext;
+import io.github.syst3ms.skriptparser.parsing.Script;
 import io.github.syst3ms.skriptparser.variables.Variables;
 
 public final class ScriptFunction<T> extends Function<T> {
 
-    private final String scriptName;
-
+    private final Script script;
     private final boolean local;
     private Trigger trigger;
 
-    ScriptFunction(String scriptName, boolean local, String name, FunctionParameter<?>[] parameters, Class<? extends T> returnType, boolean returnSingle) {
+    ScriptFunction(Script script, boolean local, String name, FunctionParameter<?>[] parameters, Class<? extends T> returnType, boolean returnSingle) {
         super(name, parameters, returnType, returnSingle);
-        this.scriptName = scriptName;
+        this.script = script;
         this.local = local;
     }
 
@@ -42,8 +42,8 @@ public T[] execute(Object[][] params, TriggerContext ctx) {
         return (T[]) returnValue;
     }
 
-    public String getScriptName() {
-        return scriptName;
+    public Script getScript() {
+        return script;
     }
 
     public boolean isLocal() {
diff --git a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java
index 010228a3..d837912b 100644
--- a/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java
+++ b/src/main/java/io/github/syst3ms/skriptparser/structures/functions/StructFunction.java
@@ -9,6 +9,7 @@
 import io.github.syst3ms.skriptparser.log.ErrorType;
 import io.github.syst3ms.skriptparser.log.SkriptLogger;
 import io.github.syst3ms.skriptparser.parsing.ParseContext;
+import io.github.syst3ms.skriptparser.parsing.Script;
 import io.github.syst3ms.skriptparser.types.Type;
 import io.github.syst3ms.skriptparser.types.TypeManager;
 
@@ -92,8 +93,8 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, ParseContex
             }
             if (type.isPlural(rawReturnType)) returnSingle = false;
         }
-        String scriptName = parseContext.getLogger().getFileName().replace(".sk", "");
-        function = new ScriptFunction<>(scriptName, local, functionName, parameters, returnType, returnSingle);
+        Script script = parseContext.getLogger().getScript();
+        function = new ScriptFunction<>(script, local, functionName, parameters, returnType, returnSingle);
         if (!Functions.isValidFunction(function, parseContext.getLogger())) {
             return false;
         }
diff --git a/src/test/java/io/github/syst3ms/skriptparser/file/FileParserTest.java b/src/test/java/io/github/syst3ms/skriptparser/file/FileParserTest.java
index 5a55d4e8..fe1f71cd 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/file/FileParserTest.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/file/FileParserTest.java
@@ -13,16 +13,19 @@
 import static org.junit.Assert.assertEquals;
 
 public class FileParserTest {
+
+    private static final Path TEST_PATH = Path.of("unit-tests");
+
     private FileElement simpleFileLine(String content, int indentation, int line) {
-        return new FileElement("unit-tests", line, content, indentation);
+        return new FileElement(TEST_PATH, line, content, indentation);
     }
 
     private FileSection fileSection(String content, int indentation, int line, FileElement... elements) {
-        return new FileSection("unit-tests", line, content, Arrays.asList(elements), indentation);
+        return new FileSection(TEST_PATH, line, content, Arrays.asList(elements), indentation);
     }
 
     private List<FileElement> parseLines(List<String> lines) {
-        return FileParser.parseFileLines("unit-tests", lines, 0, 1, new SkriptLogger());
+        return FileParser.parseFileLines(TEST_PATH, lines, 0, 1, new SkriptLogger());
     }
 
     @Test
diff --git a/src/test/java/io/github/syst3ms/skriptparser/syntax/EffAssert.java b/src/test/java/io/github/syst3ms/skriptparser/syntax/EffAssert.java
index cd2ed945..5e72f583 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/syntax/EffAssert.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/syntax/EffAssert.java
@@ -85,18 +85,18 @@ public String toString(TriggerContext ctx, boolean debug) {
     private String errorString(TriggerContext ctx) {
         if (this.message == null) {
             if (pattern == 0) {
-                return "Assertion failed ('" + condition.toString(ctx, logger.isDebug()) + "', " + logger.getFileName() + ")";
+                return "Assertion failed ('" + condition.toString(ctx, logger.isDebug()) + "', " + logger.getScript().scriptName() + ")";
             } else {
                 if (shouldThrow) {
                     assert compiled;
-                    return "Expected a non-parsable expression (" + matched + ", " + logger.getFileName() + ")";
+                    return "Expected a non-parsable expression (" + matched + ", " + logger.getScript().scriptName() + ")";
                 } else {
                     assert !compiled;
-                    return "Expected a parsable expression (" + matched + ", " + logger.getFileName() + ")";
+                    return "Expected a parsable expression (" + matched + ", " + logger.getScript().scriptName() + ")";
                 }
             }
         } else {
-            return message.getSingle(ctx).map(String::new).orElse("No message provided") + " (" + logger.getFileName() + ")";
+            return message.getSingle(ctx).map(String::new).orElse("No message provided") + " (" + logger.getScript().scriptName() + ")";
         }
     }
 }
diff --git a/src/test/java/io/github/syst3ms/skriptparser/syntax/SecBirth.java b/src/test/java/io/github/syst3ms/skriptparser/syntax/SecBirth.java
index aba33ed6..eef6527e 100644
--- a/src/test/java/io/github/syst3ms/skriptparser/syntax/SecBirth.java
+++ b/src/test/java/io/github/syst3ms/skriptparser/syntax/SecBirth.java
@@ -61,8 +61,8 @@ public Optional<? extends Statement> walk(TriggerContext ctx) {
         if (!dead) {
             SyntaxParserTest.addError(new SkriptRuntimeException(
                 message == null
-                    ? "Birth section was not killed afterwards (" + logger.getFileName() + ")"
-                    : message.getSingle(ctx).map(s -> (String) s).orElse(TypeManager.EMPTY_REPRESENTATION) + " (" + logger.getFileName() + ")"
+                    ? "Birth section was not killed afterwards (" + logger.getScript().scriptName() + ")"
+                    : message.getSingle(ctx).map(s -> (String) s).orElse(TypeManager.EMPTY_REPRESENTATION) + " (" + logger.getScript().scriptName() + ")"
             ));
         }
         dead = false;