From 68aca1ff13cb38e3b1e7b83a114e98532b82f5b1 Mon Sep 17 00:00:00 2001
From: Andrew Kane <codemaster@quantumraiders.com>
Date: Sun, 31 Dec 2023 21:02:19 -0800
Subject: [PATCH] Remove std library usage where possible

- Deprecate & remove ILogger and string_format
- Migrate function handlers to delegate definitions, per Unreal structures
- Add [[maybe_unused]] to UnrealLogHandler to indicate the parameters may be unused
- Update parameters to const reference where possible (function handlers, etc.)
- Update map references to use Unreal's TMap, vector references to use Unreal's TArray
- Implement State::ClearStack
- Rename YarnFunction to TYarnFunction and migrate from std::function to TDelegate
---
 Source/YarnSpinner/Private/DialogueRunner.cpp | 128 ++++----
 .../Private/Library/YarnFunctionLibrary.cpp   |   2 +-
 .../Private/Library/YarnLibraryRegistry.cpp   |   4 +-
 Source/YarnSpinner/Private/YarnSpinner.cpp    |  10 +-
 .../Private/YarnSpinnerCore/Library.cpp       | 281 ++++++++++--------
 .../Private/YarnSpinnerCore/State.cpp         |  53 ++--
 .../YarnSpinnerCore/VirtualMachine.cpp        | 260 ++++++++--------
 Source/YarnSpinner/Private/YarnSubsystem.cpp  |  27 +-
 Source/YarnSpinner/Public/DialogueRunner.h    |  17 +-
 .../Public/YarnSpinnerCore/Common.h           |  54 +---
 .../Public/YarnSpinnerCore/Library.h          |  41 ++-
 .../Public/YarnSpinnerCore/State.h            |  29 +-
 .../Public/YarnSpinnerCore/VirtualMachine.h   |  55 ++--
 Source/YarnSpinner/Public/YarnSubsystem.h     |  12 +-
 .../Private/YarnAssetFactory.cpp              |   7 +-
 15 files changed, 469 insertions(+), 511 deletions(-)

diff --git a/Source/YarnSpinner/Private/DialogueRunner.cpp b/Source/YarnSpinner/Private/DialogueRunner.cpp
index eafc862..bb227dd 100644
--- a/Source/YarnSpinner/Private/DialogueRunner.cpp
+++ b/Source/YarnSpinner/Private/DialogueRunner.cpp
@@ -2,11 +2,10 @@
 
 
 #include "DialogueRunner.h"
+
 #include "Line.h"
 #include "Option.h"
 #include "YarnSubsystem.h"
-#include "YarnSpinner.h"
-#include "Kismet/KismetInternationalizationLibrary.h"
 #include "Misc/YSLogging.h"
 
 THIRD_PARTY_INCLUDES_START
@@ -47,20 +46,20 @@ void ADialogueRunner::PreInitializeComponents()
     }
 
     // Create the Library
-    Library = TUniquePtr<Yarn::Library>(new Yarn::Library(*this));
+    Library = MakeUnique<Yarn::Library>();
 
     // Create the VirtualMachine, supplying it with the loaded Program and
     // configuring it to use our library, plus use this ADialogueRunner as the
     // logger and the variable storage
-    VirtualMachine = TUniquePtr<Yarn::VirtualMachine>(new Yarn::VirtualMachine(Program, *(Library), *this, *this));
+    VirtualMachine = MakeUnique<Yarn::VirtualMachine>(Program, *(Library), *this);
 
-    VirtualMachine->LineHandler = [this](Yarn::Line& Line)
+    VirtualMachine->OnLine.AddLambda([this](const Yarn::Line& Line)
     {
-        UE_LOG(LogYarnSpinner, Log, TEXT("Received line %s"), UTF8_TO_TCHAR(Line.LineID.c_str()));
+        YS_LOG("Received line %s", *Line.LineID);
 
         // Get the Yarn line struct, and make a ULine out of it to use
         ULine* LineObject = NewObject<ULine>(this);
-        LineObject->LineID = FName(Line.LineID.c_str());
+        LineObject->LineID = FName(*Line.LineID);
 
         GetDisplayTextForLine(LineObject, Line);
 
@@ -68,24 +67,24 @@ void ADialogueRunner::PreInitializeComponents()
         YS_LOG_FUNC("Got %d line assets for line '%s'", LineAssets.Num(), *LineObject->LineID.ToString())
 
         OnRunLine(LineObject, LineAssets);
-    };
+    });
 
-    VirtualMachine->OptionsHandler = [this](Yarn::OptionSet& OptionSet)
+    VirtualMachine->OnOptions.AddLambda([this](const Yarn::OptionSet& OptionSet)
     {
-        UE_LOG(LogYarnSpinner, Log, TEXT("Received %i options"), OptionSet.Options.size());
+        YS_LOG("Received %llu options", OptionSet.Options.Num());
 
         // Build a TArray for every option in this OptionSet
         TArray<UOption*> Options;
 
-        for (auto Option : OptionSet.Options)
+        for (const Yarn::Option& Option : OptionSet.Options)
         {
-            UE_LOG(LogYarnSpinner, Log, TEXT("- %i: %s"), Option.ID, UTF8_TO_TCHAR(Option.Line.LineID.c_str()));
+            YS_LOG("- %i: %s", Option.ID, *Option.Line.LineID);
 
             UOption* Opt = NewObject<UOption>(this);
             Opt->OptionID = Option.ID;
 
             Opt->Line = NewObject<ULine>(Opt);
-            Opt->Line->LineID = FName(Option.Line.LineID.c_str());
+            Opt->Line->LineID = FName(*Option.Line.LineID);
 
             GetDisplayTextForLine(Opt->Line, Option.Line);
 
@@ -97,47 +96,46 @@ void ADialogueRunner::PreInitializeComponents()
         }
 
         OnRunOptions(Options);
-    };
+    });
 
-    VirtualMachine->DoesFunctionExist = [this](const std::string& FunctionName) -> bool
+    VirtualMachine->OnCheckFunctionExist.BindLambda([this](const FString& FunctionName) -> bool
     {
-        return YarnSubsystem()->GetYarnLibraryRegistry()->HasFunction(FName(UTF8_TO_TCHAR(FunctionName.c_str())));
-    };
+        return YarnSubsystem()->GetYarnLibraryRegistry()->HasFunction(FName(*FunctionName));
+    });
 
-    VirtualMachine->GetExpectedFunctionParamCount = [this](const std::string& FunctionName) -> int
+    VirtualMachine->OnGetFunctionParamNum.BindLambda([this](const FString& FunctionName) -> int
     {
-        return YarnSubsystem()->GetYarnLibraryRegistry()->GetExpectedFunctionParamCount(FName(UTF8_TO_TCHAR(FunctionName.c_str())));
-    };
+        return YarnSubsystem()->GetYarnLibraryRegistry()->GetExpectedFunctionParamCount(FName(*FunctionName));
+    });
 
-    VirtualMachine->CallFunction = [this](const std::string& FunctionName, const std::vector<Yarn::FValue>& Parameters) -> Yarn::FValue
+    VirtualMachine->OnCallFunction.BindLambda([this](const FString& FunctionName, const TArray<Yarn::FValue>& Parameters) -> Yarn::FValue
     {
         return YarnSubsystem()->GetYarnLibraryRegistry()->CallFunction(
-            FName(UTF8_TO_TCHAR(FunctionName.c_str())),
-            TArray<Yarn::FValue>(Parameters.data(), Parameters.size())
+            FName(*FunctionName),
+            Parameters
         );
-    };
+    });
 
-    VirtualMachine->CommandHandler = [this](Yarn::Command& Command)
+    VirtualMachine->OnCommand.AddLambda([this](const Yarn::Command& Command)
     {
-        UE_LOG(LogYarnSpinner, Log, TEXT("Received command \"%s\""), UTF8_TO_TCHAR(Command.Text.c_str()));
+        YS_LOG("Received command \"%s\"", *Command.Text);
 
-        FString CommandText = FString(UTF8_TO_TCHAR(Command.Text.c_str()));
+        const FString& CommandText = Command.Text;
 
         TArray<FString> CommandElements;
         CommandText.ParseIntoArray(CommandElements, TEXT(" "));
 
         if (CommandElements.Num() == 0)
         {
-            TArray<FString> EmptyParameters;
             UE_LOG(LogYarnSpinner, Error, TEXT("Command received, but was unable to parse it."));
-            OnRunCommand(FString("(unknown)"), EmptyParameters);
+            OnRunCommand(FString("(unknown)"), TArray<FString>());
             return;
         }
 
-        FName CommandName = FName(CommandElements[0]);
+        const FName CommandName = FName(CommandElements[0]);
         CommandElements.RemoveAt(0);
 
-        auto Lib = YarnSubsystem()->GetYarnLibraryRegistry();
+        const UYarnLibraryRegistry* const Lib = YarnSubsystem()->GetYarnLibraryRegistry();
 
         if (Lib->HasCommand(CommandName))
         {
@@ -150,23 +148,23 @@ void ADialogueRunner::PreInitializeComponents()
 
         // Haven't handled the function yet, so call the DialogueRunner's handler
         OnRunCommand(CommandName.ToString(), CommandElements);
-    };
+    });
 
-    VirtualMachine->NodeStartHandler = [this](std::string NodeName)
+    VirtualMachine->OnNodeStart.AddLambda( [this](const FString& NodeName)
     {
-        UE_LOG(LogYarnSpinner, Log, TEXT("Received node start \"%s\""), UTF8_TO_TCHAR(NodeName.c_str()));
-    };
+        UE_LOG(LogYarnSpinner, Log, TEXT("Received node start \"%s\""), *NodeName);
+    });
 
-    VirtualMachine->NodeCompleteHandler = [this](std::string NodeName)
+    VirtualMachine->OnNodeComplete.AddLambda([this](const FString& NodeName)
     {
-        UE_LOG(LogYarnSpinner, Log, TEXT("Received node complete \"%s\""), UTF8_TO_TCHAR(NodeName.c_str()));
-    };
+        UE_LOG(LogYarnSpinner, Log, TEXT("Received node complete \"%s\""), *NodeName);
+    });
 
-    VirtualMachine->DialogueCompleteHandler = [this]()
+    VirtualMachine->OnDialogueComplete.AddLambda([this]()
     {
         UE_LOG(LogYarnSpinner, Log, TEXT("Received dialogue complete"));
         OnDialogueEnded();
-    };
+    });
 }
 
 
@@ -223,7 +221,7 @@ void ADialogueRunner::StartDialogue(FName NodeName)
         return;
     }
 
-    bool bNodeSelected = VirtualMachine->SetNode(TCHAR_TO_UTF8(*NodeName.ToString()));
+    bool bNodeSelected = VirtualMachine->SetNode(NodeName.ToString());
 
     if (bNodeSelected)
     {
@@ -289,64 +287,44 @@ void ADialogueRunner::SelectOption(UOption* Option)
     }
 }
 
-
-void ADialogueRunner::Log(std::string Message, Type Severity)
-{
-    FString MessageText = FString(UTF8_TO_TCHAR(Message.c_str()));
-
-    switch (Severity)
-    {
-    case Type::INFO:
-        YS_LOG("YarnSpinner: %s", *MessageText);
-        break;
-    case Type::WARNING:
-        YS_WARN("YarnSpinner: %s", *MessageText);
-        break;
-    case Type::ERROR:
-        YS_ERR("YarnSpinner: %s", *MessageText);
-        break;
-    }
-}
-
-
-void ADialogueRunner::SetValue(std::string Name, bool bValue)
+void ADialogueRunner::SetValue(const FString& Name, bool bValue)
 {
-    YS_LOG("Setting variable %s to bool %i", UTF8_TO_TCHAR(Name.c_str()), bValue)
+    YS_LOG("Setting variable %s to bool %i", *Name, bValue);
     YarnSubsystem()->SetValue(Name, bValue);
 }
 
 
-void ADialogueRunner::SetValue(std::string Name, float Value)
+void ADialogueRunner::SetValue(const FString& Name, float Value)
 {
-    YS_LOG("Setting variable %s to float %f", UTF8_TO_TCHAR(Name.c_str()), Value)
+    YS_LOG("Setting variable %s to float %f", *Name, Value);
     YarnSubsystem()->SetValue(Name, Value);
 }
 
 
-void ADialogueRunner::SetValue(std::string Name, std::string Value)
+void ADialogueRunner::SetValue(const FString& Name, const FString& Value)
 {
-    YS_LOG("Setting variable %s to string %s", UTF8_TO_TCHAR(Name.c_str()), UTF8_TO_TCHAR(Value.c_str()))
+    YS_LOG("Setting variable %s to string %s", *Name, *Value);
     YarnSubsystem()->SetValue(Name, Value);
 }
 
 
-bool ADialogueRunner::HasValue(std::string Name)
+bool ADialogueRunner::HasValue(const FString& Name)
 {
     return YarnSubsystem()->HasValue(Name);
 }
 
 
-Yarn::FValue ADialogueRunner::GetValue(std::string Name)
+Yarn::FValue ADialogueRunner::GetValue(const FString& Name)
 {
     Yarn::FValue Value = YarnSubsystem()->GetValue(Name);
-    YS_LOG("Retrieving variable %s with value %s", UTF8_TO_TCHAR(Name.c_str()), *Value.ConvertToString());
+    YS_LOG("Retrieving variable %s with value %s", *Name, *Value.ConvertToString());
     return Value;
 }
 
 
-void ADialogueRunner::ClearValue(std::string Name)
+void ADialogueRunner::ClearValue(const FString& Name)
 {
-    YS_LOG("Clearing variable %s", UTF8_TO_TCHAR(Name.c_str()))
+    YS_LOG("Clearing variable %s", *Name);
     YarnSubsystem()->ClearValue(Name);
 }
 
@@ -364,7 +342,7 @@ UYarnSubsystem* ADialogueRunner::YarnSubsystem() const
 
 void ADialogueRunner::GetDisplayTextForLine(ULine* Line, const Yarn::Line& YarnLine)
 {
-    const FName LineID = FName(YarnLine.LineID.c_str());
+    const FName LineID = FName(*YarnLine.LineID);
 
     // This assumes that we only ever care about lines that actually exist in .yarn files (rather than allowing extra lines in .csv files)
     if (!YarnProject || !YarnProject->Lines.Contains(LineID))
@@ -379,9 +357,9 @@ void ADialogueRunner::GetDisplayTextForLine(ULine* Line, const Yarn::Line& YarnL
 
     // Apply substitutions
     FFormatOrderedArguments FormatArgs;
-    for (auto Substitution : YarnLine.Substitutions)
+    for (const FString& Substitution : YarnLine.Substitutions)
     {
-        FormatArgs.Emplace(FText::FromString(UTF8_TO_TCHAR(Substitution.c_str())));
+        FormatArgs.Emplace(FText::FromString(Substitution));
     }
 
     const FText TextWithSubstitutions = (LocalisedDisplayText.IsEmptyOrWhitespace()) ? FText::Format(NonLocalisedDisplayText, FormatArgs) : FText::Format(LocalisedDisplayText, FormatArgs);
diff --git a/Source/YarnSpinner/Private/Library/YarnFunctionLibrary.cpp b/Source/YarnSpinner/Private/Library/YarnFunctionLibrary.cpp
index 5056455..8ca6506 100644
--- a/Source/YarnSpinner/Private/Library/YarnFunctionLibrary.cpp
+++ b/Source/YarnSpinner/Private/Library/YarnFunctionLibrary.cpp
@@ -143,7 +143,7 @@ TOptional<Yarn::FValue> UYarnFunctionLibrary::CallFunction(FName FunctionName, T
                 YS_WARN_FUNC("Could not get return parameter '%s' for function '%s'", *ReturnValue->Name.ToString(), *FunctionName.ToString())
                 return Result;
             }
-            Result = Yarn::FValue(TCHAR_TO_UTF8(*StringParam->GetPropertyValue_InContainer(FuncParams.GetStructMemory())));
+            Result = Yarn::FValue(StringParam->GetPropertyValue_InContainer(FuncParams.GetStructMemory()));
             break;
         }
     }
diff --git a/Source/YarnSpinner/Private/Library/YarnLibraryRegistry.cpp b/Source/YarnSpinner/Private/Library/YarnLibraryRegistry.cpp
index 37fdb50..41ed365 100644
--- a/Source/YarnSpinner/Private/Library/YarnLibraryRegistry.cpp
+++ b/Source/YarnSpinner/Private/Library/YarnLibraryRegistry.cpp
@@ -293,7 +293,7 @@ void UYarnLibraryRegistry::AddFunction(const FYSLSAction& Func)
         }
         else
         {
-            Param.Value = Yarn::FValue(TCHAR_TO_UTF8(*InParam.DefaultValue));
+            Param.Value = Yarn::FValue(InParam.DefaultValue);
         }
 
         FuncDetail.InParams.Add(Param);
@@ -355,7 +355,7 @@ void UYarnLibraryRegistry::AddCommand(const FYSLSAction& Cmd)
         }
         else
         {
-            Param.Value = Yarn::FValue(TCHAR_TO_UTF8(*InParam.DefaultValue));
+            Param.Value = InParam.DefaultValue;
         }
 
         CmdDetail.InParams.Add(Param);
diff --git a/Source/YarnSpinner/Private/YarnSpinner.cpp b/Source/YarnSpinner/Private/YarnSpinner.cpp
index cc77807..a029aea 100644
--- a/Source/YarnSpinner/Private/YarnSpinner.cpp
+++ b/Source/YarnSpinner/Private/YarnSpinner.cpp
@@ -2,10 +2,9 @@
 
 #include "YarnSpinner.h"
 
-#include "Modules/ModuleManager.h"
-#include "Interfaces/IPluginManager.h"
 #include "Misc/MessageDialog.h"
 #include "Misc/YSLogging.h"
+#include "Modules/ModuleManager.h"
 
 THIRD_PARTY_INCLUDES_START
 #include <google/protobuf/stubs/logging.h>
@@ -16,9 +15,10 @@ THIRD_PARTY_INCLUDES_END
 
 
 
-void UnrealLogHandler(google::protobuf::LogLevel level, const char* filename, int line,
-                        const std::string& message) {
-	UE_LOG(LogYarnSpinner, Warning, TEXT("Protobuf: %s"), message.c_str());
+void UnrealLogHandler([[maybe_unused]] google::protobuf::LogLevel Level, [[maybe_unused]] const char* Filename,
+						[[maybe_unused]] int Line, const std::string& Message)
+{
+	YS_WARN("Protobuf: %hs", Message.c_str());
 }
 
 
diff --git a/Source/YarnSpinner/Private/YarnSpinnerCore/Library.cpp b/Source/YarnSpinner/Private/YarnSpinnerCore/Library.cpp
index 9a93eed..835a26f 100644
--- a/Source/YarnSpinner/Private/YarnSpinnerCore/Library.cpp
+++ b/Source/YarnSpinner/Private/YarnSpinnerCore/Library.cpp
@@ -1,5 +1,8 @@
 #include "YarnSpinnerCore/Library.h"
 
+#include "Misc/YSLogging.h"
+#include "YarnSpinnerCore/Common.h"
+
 #if defined(_MSC_VER)
 	#pragma warning (disable:4800) // 'type' : forcing value to bool 'true' or 'false' (performance warning)
 #endif
@@ -18,13 +21,13 @@ namespace Yarn
     {
     }
     template <typename T>
-    FunctionInfo<T>::FunctionInfo(int paramCount, T (*f)(std::vector<FValue>))
+    FunctionInfo<T>::FunctionInfo(const int ParamCount, T (*F)(const TArray<FValue>&))
     {
-        Function = f;
-        ExpectedParameterCount = paramCount;
+        Function = F;
+        ExpectedParameterCount = ParamCount;
     }
 
-    Library::Library(ILogger &logger) : logger(logger)
+    Library::Library()
     {
         LoadStandardLibrary();
     }
@@ -43,45 +46,45 @@ namespace Yarn
     // Get function
 
     template <typename T>
-    FunctionInfo<T> Library::GetFunction(std::string name)
+    FunctionInfo<T> Library::GetFunction(const FString& Name)
     {
-        UNUSED(name);
+        UNUSED(Name);
         static_assert(dependent_false<T>::value, "Invalid return type for function");
     }
 
     template <>
-    FunctionInfo<std::string> Library::GetFunction<std::string>(std::string name)
+    FunctionInfo<FString> Library::GetFunction<FString>(const FString& name)
     {
         return stringFunctions[name];
     }
 
     template <>
-    FunctionInfo<float> Library::GetFunction<float>(std::string name)
+    FunctionInfo<float> Library::GetFunction<float>(const FString& name)
     {
         return numberFunctions[name];
     }
 
     template <>
-    FunctionInfo<bool> Library::GetFunction<bool>(std::string name)
+    FunctionInfo<bool> Library::GetFunction<bool>(const FString& name)
     {
         return boolFunctions[name];
     }
 
     template <typename T>
-    FunctionInfo<T> &Library::GetFunctionImpl(std::map<std::string, FunctionInfo<T>> &source, std::string name)
+    FunctionInfo<T> &Library::GetFunctionImpl(TMap<FString, FunctionInfo<T>> &Source, const FString& Name)
     {
-        if (source.count(name) == 0)
+        if (!Source.contains(Name))
         {
-            logger.Log(string_format("Can't get implementation for unknown function '%s'", UTF8_TO_TCHAR(name.c_str())));
+            YS_LOG("Can't get implementation for unknown function '%s'", *Name);
             return FunctionInfo<T>();
         }
-        return source[name];
+        return Source[Name];
     }
 
     // Add Function
 
     // template <typename T>
-    // void Library::AddFunction (std::string name, T(*f)(std::vector<Value>), int parameterCount) {
+    // void Library::AddFunction (FString name, T(*f)(TArray<Value>), int parameterCount) {
     //     // A helper function that can take any function pointer (including lambdas),
     //     // converts them to a YarnFunction<T>, and then forwards that to the regular
     //     // YarnFunction<T> method
@@ -90,7 +93,7 @@ namespace Yarn
     // }
 
     template <typename T>
-    void Library::AddFunction(std::string name, YarnFunction<T> function, int parameterCount)
+    void Library::AddFunction(const FString& name, TYarnFunction<T> function, int parameterCount)
     {
         UNUSED(name);
         UNUSED(function);
@@ -99,36 +102,36 @@ namespace Yarn
     }
 
     template <>
-    void Library::AddFunction<std::string>(std::string name, YarnFunction<std::string> function, int parameterCount)
+    void Library::AddFunction<FString>(const FString& name, TYarnFunction<FString> function, int parameterCount)
     {
         AddFunctionImpl(stringFunctions, name, function, parameterCount);
     }
 
     template <>
-    void Library::AddFunction<float>(std::string name, YarnFunction<float> function, int parameterCount)
+    void Library::AddFunction<float>(const FString& name, TYarnFunction<float> function, int parameterCount)
     {
         AddFunctionImpl(numberFunctions, name, function, parameterCount);
     }
 
     template <>
-    void Library::AddFunction<bool>(std::string name, YarnFunction<bool> function, int parameterCount)
+    void Library::AddFunction<bool>(const FString& name, TYarnFunction<bool> function, int parameterCount)
     {
         AddFunctionImpl(boolFunctions, name, function, parameterCount);
     }
 
     template <typename T>
-    void Library::AddFunctionImpl(std::map<std::string, FunctionInfo<T>> &source, std::string name, YarnFunction<T> func, int parameterCount)
+    void Library::AddFunctionImpl(TMap<FString, FunctionInfo<T>> &source, const FString& name, TYarnFunction<T> func, int parameterCount)
     {
         // Report an error if this function is already defined across any of our
         // function tables
         if (
-            stringFunctions.count(name) > 0 ||
-            numberFunctions.count(name) > 0 ||
-            boolFunctions.count(name) > 0 ||
-            source.count(name) > 0) // strictly unnecessary but might help catch future bugs
+            stringFunctions.Contains(name) ||
+            numberFunctions.Contains(name) ||
+            boolFunctions.Contains(name) ||
+            source.Contains(name)) // strictly unnecessary but might help catch future bugs
 
         {
-            logger.Log(string_format("Function %s is already defined", UTF8_TO_TCHAR(name.c_str())));
+            YS_LOG("Function %s is already defined", *name);
             return;
         }
 
@@ -136,99 +139,96 @@ namespace Yarn
         FunctionInfo<T> info;
         info.ExpectedParameterCount = parameterCount;
         info.Function = func;
-        source[name] = info;
+        source.Emplace(name, MoveTemp(info));
     }
 
     // Remove function
 
     template <typename T>
-    void Library::RemoveFunction(std::string name)
+    void Library::RemoveFunction(const FString& Name)
     {
-        UNUSED(name);
+        UNUSED(Name);
         static_assert(dependent_false<T>::value, "Invalid return type for function");
     }
 
     template <>
-    void Library::RemoveFunction<std::string>(std::string name)
+    void Library::RemoveFunction<FString>(const FString& name)
     {
         RemoveFunctionImpl(stringFunctions, name);
     }
 
     template <>
-    void Library::RemoveFunction<float>(std::string name)
+    void Library::RemoveFunction<float>(const FString& name)
     {
         RemoveFunctionImpl(stringFunctions, name);
     }
 
     template <>
-    void Library::RemoveFunction<bool>(std::string name)
+    void Library::RemoveFunction<bool>(const FString& name)
     {
         RemoveFunctionImpl(stringFunctions, name);
     }
 
     template <typename T>
-    void Library::RemoveFunctionImpl(std::map<std::string, FunctionInfo<T>> &source, std::string name)
+    void Library::RemoveFunctionImpl(TMap<FString, FunctionInfo<T>> &source, const FString& name)
     {
-        if (source.count(name) > 0)
-        {
-            source.erase(name);
-        }
+        source.Remove(name);
     }
 
     // Has Function
     template <typename T>
-    bool Library::HasFunction(std::string name)
+    bool Library::HasFunction(const FString& Name)
     {
-        UNUSED(name);
+        UNUSED(Name);
         static_assert(dependent_false<T>::value, "Invalid return type for function");
     }
 
     template <>
-    bool Library::HasFunction<std::string>(std::string name)
+    bool Library::HasFunction<FString>(const FString& name)
     {
-        return HasFunctionImpl<std::string>(stringFunctions, name);
+        return HasFunctionImpl<FString>(stringFunctions, name);
     }
 
     template <>
-    bool Library::HasFunction<float>(std::string name)
+    bool Library::HasFunction<float>(const FString& name)
     {
         return HasFunctionImpl<float>(numberFunctions, name);
     }
 
     template <>
-    bool Library::HasFunction<bool>(std::string name)
+    bool Library::HasFunction<bool>(const FString& name)
     {
         return HasFunctionImpl<bool>(boolFunctions, name);
     }
 
     template <typename T>
-    bool Library::HasFunctionImpl(std::map<std::string, FunctionInfo<T>> &source, std::string name)
+    bool Library::HasFunctionImpl(TMap<FString, FunctionInfo<T>> &source, const FString& name)
     {
-        return source.count(name) > 0;
+        return source.Contains(name);
     }
 
     // Remove all functions
     void Library::RemoveAllFunctions()
     {
-        stringFunctions.clear();
-        numberFunctions.clear();
-        boolFunctions.clear();
+        stringFunctions.Empty();
+        numberFunctions.Empty();
+        boolFunctions.Empty();
     }
 
     // Get parameter count
-    int Library::GetExpectedParameterCount(std::string name)
+    int Library::GetExpectedParameterCount(const FString& Name)
     {
-        if (HasFunction<std::string>(name))
+        if (HasFunction<FString>(Name))
         {
-            return GetFunction<std::string>(name).ExpectedParameterCount;
+            return GetFunction<FString>(Name).ExpectedParameterCount;
         }
-        else if (HasFunction<float>(name))
+        else if (HasFunction<float>(Name))
         {
-            return GetFunction<float>(name).ExpectedParameterCount;
+            return GetFunction<float>(Name).ExpectedParameterCount;
         }
-        else if (HasFunction<bool>(name))
+        else if (HasFunction<bool>(Name))
         {
-            return GetFunction<bool>(name).ExpectedParameterCount;
+            return GetFunction<bool>(Name).ExpectedParameterCount;
         }
         else
         {
@@ -240,153 +240,176 @@ namespace Yarn
     void Library::LoadStandardLibrary()
     {
         // Number methods
-        AddFunction<bool>(
+        AddFunction(
             "Number.EqualTo",
-            [](std::vector<FValue> values)
+            TYarnFunction<bool>::CreateLambda(
+            [](const TArray<FValue>& Values)
             {
-                return values.at(0).GetValue<double>() == values.at(1).GetValue<double>();
-            },
+                return Values[0].GetValue<double>() == Values[1].GetValue<double>();
+            }),
             2);
 
-        AddFunction<bool>(
+        AddFunction(
             "Number.NotEqualTo",
-            [](std::vector<FValue> values)
+            TYarnFunction<bool>::CreateLambda(
+            [](const TArray<FValue>& Values)
             {
-                return values.at(0).GetValue<double>() != values.at(1).GetValue<double>();
-            },
+                return Values[0].GetValue<double>() != Values[1].GetValue<double>();
+            }),
             2);
 
-        AddFunction<float>(
+        AddFunction(
             "Number.Add",
-            [](std::vector<FValue> values)
+            TYarnFunction<float>::CreateLambda(
+            [](const TArray<FValue>& Values)
             {
-                return values.at(0).GetValue<double>() + values.at(1).GetValue<double>();
-            },
+                return Values[0].GetValue<double>() + Values[1].GetValue<double>();
+            }),
             2);
 
-        AddFunction<float>(
+        AddFunction(
             "Number.Minus",
-            [](std::vector<FValue> values)
+            TYarnFunction<float>::CreateLambda(
+            [](const TArray<FValue>& Values)
             {
-                return values.at(0).GetValue<double>() - values.at(1).GetValue<double>();
-            },
+                return Values[0].GetValue<double>() - Values[1].GetValue<double>();
+            }),
             2);
 
-        AddFunction<float>(
+        AddFunction(
             "Number.Divide",
-            [](std::vector<FValue> values)
+            TYarnFunction<float>::CreateLambda(
+            [](const TArray<FValue>& Values)
             {
-                return values.at(0).GetValue<double>() / values.at(1).GetValue<double>();
-            },
+                return Values[0].GetValue<double>() / Values[1].GetValue<double>();
+            }),
             2);
 
-        AddFunction<float>(
+        AddFunction(
             "Number.Multiply",
-            [](std::vector<FValue> values)
+            TYarnFunction<float>::CreateLambda(
+            [](const TArray<FValue>& Values)
             {
-                return values.at(0).GetValue<double>() * values.at(1).GetValue<double>();
-            },
+                return Values[0].GetValue<double>() * Values[1].GetValue<double>();
+            }),
             2);
 
-        AddFunction<float>(
+        AddFunction(
             "Number.Modulo",
-            [](std::vector<FValue> values)
+            TYarnFunction<float>::CreateLambda(
+            [](const TArray<FValue>& Values)
             {
-                return (int)(values.at(0).GetValue<double>()) % (int)(values.at(1).GetValue<double>());
-            },
+                return static_cast<int>(Values[0].GetValue<double>()) % static_cast<int>(Values[1].GetValue<double>());
+            }),
             2);
 
-        AddFunction<float>(
+        AddFunction(
             "Number.UnaryMinus",
-            [](std::vector<FValue> values)
+            TYarnFunction<float>::CreateLambda(
+            [](const TArray<FValue>& Values)
             {
-                return -(values.at(0).GetValue<double>());
-            },
+                return -Values[0].GetValue<double>();
+            }),
             1);
 
-        AddFunction<bool>(
+        AddFunction(
             "Number.GreaterThan",
-            [](std::vector<FValue> values)
+            TYarnFunction<bool>::CreateLambda(
+            [](const TArray<FValue>& Values)
             {
-                return values.at(0).GetValue<double>() > values.at(1).GetValue<double>();
-            },
+                return Values[0].GetValue<double>() > Values[1].GetValue<double>();
+            }),
             2);
 
-        AddFunction<bool>(
+        AddFunction(
             "Number.GreaterThanOrEqualTo",
-            [](std::vector<FValue> values)
+            TYarnFunction<bool>::CreateLambda(
+            [](const TArray<FValue>& Values)
             {
-                return values.at(0).GetValue<double>() >= values.at(1).GetValue<double>();
-            },
+                return Values[0].GetValue<double>() >= Values[1].GetValue<double>();
+            }),
             2);
 
-        AddFunction<bool>(
+        AddFunction(
             "Number.LessThan",
-            [](std::vector<FValue> values)
+            TYarnFunction<bool>::CreateLambda(
+            [](const TArray<FValue>& Values)
             {
-                return values.at(0).GetValue<double>() < values.at(1).GetValue<double>();
-            },
+                return Values[0].GetValue<double>() < Values[1].GetValue<double>();
+            }),
             2);
 
-        AddFunction<bool>(
+        AddFunction(
             "Number.LessThanOrEqualTo",
-            [](std::vector<FValue> values)
+            TYarnFunction<bool>::CreateLambda(
+            [](const TArray<FValue>& Values)
             {
-                return values.at(0).GetValue<double>() <= values.at(1).GetValue<double>();
-            },
+                return Values[0].GetValue<double>() <= Values[1].GetValue<double>();
+            }),
             2);
 
         // Boolean methods
-        AddFunction<bool>(
-            "Bool.EqualTo", [](std::vector<FValue> values)
-            { return values.at(0).GetValue<bool>() == values.at(1).GetValue<bool>(); },
+        AddFunction(
+            "Bool.EqualTo", 
+            TYarnFunction<bool>::CreateLambda(
+                [](const TArray<FValue>& Values)
+                { return Values[0].GetValue<bool>() == Values[1].GetValue<bool>(); }),
             2);
 
-        AddFunction<bool>(
-            "Bool.NotEqualTo", [](std::vector<FValue> values)
-            { return values.at(0).GetValue<bool>() != values.at(1).GetValue<bool>(); },
+        AddFunction(
+            "Bool.NotEqualTo",
+            TYarnFunction<bool>::CreateLambda(
+                [](const TArray<FValue>& Values)
+                { return Values[0].GetValue<bool>() != Values[1].GetValue<bool>(); }),
             2);
 
-        AddFunction<bool>(
-            "Bool.And", [](std::vector<FValue> values)
-            { return values.at(0).GetValue<bool>() && values.at(1).GetValue<bool>(); },
+        AddFunction(
+            "Bool.And", TYarnFunction<bool>::CreateLambda(
+                [](const TArray<FValue>& Values)
+                { return Values[0].GetValue<bool>() && Values[1].GetValue<bool>(); }),
             2);
 
-        AddFunction<bool>(
-            "Bool.Or", [](std::vector<FValue> values)
-            { return values.at(0).GetValue<bool>() || values.at(1).GetValue<bool>(); },
+        AddFunction(
+            "Bool.Or", TYarnFunction<bool>::CreateLambda(
+                [](const TArray<FValue>& Values)
+                { return Values[0].GetValue<bool>() || Values[1].GetValue<bool>(); }),
             2);
 
         AddFunction<bool>(
-            "Bool.Xor", [](std::vector<FValue> values)
-            { return values.at(0).GetValue<bool>() ^ values.at(1).GetValue<bool>(); },
+            "Bool.Xor", TYarnFunction<bool>::CreateLambda(
+                [](const TArray<FValue>& Values)
+                { return Values[0].GetValue<bool>() ^ Values[1].GetValue<bool>(); }),
             2);
 
-        AddFunction<bool>(
-            "Bool.Not", [](std::vector<FValue> values)
-            { return !values.at(0).GetValue<bool>(); },
+        AddFunction(
+            "Bool.Not", TYarnFunction<bool>::CreateLambda(
+                [](const TArray<FValue>& Values)
+                { return !Values[0].GetValue<bool>(); }),
             1);
 
         // String functions
 
-        AddFunction<bool>(
-            "String.EqualTo", [](std::vector<FValue> values)
-            { return values.at(0).GetValue<FString>() == values.at(1).GetValue<FString>(); },
+        AddFunction(
+            "String.EqualTo", TYarnFunction<bool>::CreateLambda(
+                [](const TArray<FValue>& Values)
+                { return Values[0].GetValue<FString>() == Values[1].GetValue<FString>(); }),
             2);
 
-        AddFunction<bool>(
-            "String.NotEqualTo", [](std::vector<FValue> values)
-            { return values.at(0).GetValue<FString>() != values.at(1).GetValue<FString>(); },
+        AddFunction(
+            "String.NotEqualTo", TYarnFunction<bool>::CreateLambda(
+                [](const TArray<FValue>& Values)
+                { return Values[0].GetValue<FString>() != Values[1].GetValue<FString>(); }),
             2);
 
-        AddFunction<std::string>(
-            "String.Add", [](std::vector<FValue> values)
-            { return TCHAR_TO_UTF8(*(values.at(0).GetValue<FString>() + values.at(1).GetValue<FString>())); },
+        AddFunction(
+            "String.Add", TYarnFunction<FString>::CreateLambda(
+                [](const TArray<FValue>& Values)
+                { return Values[0].GetValue<FString>() + Values[1].GetValue<FString>(); }),
             2);
     }
 
-    std::string Library::GenerateUniqueVisitedVariableForNode(std::string nodeName)
+    FString Library::GenerateUniqueVisitedVariableForNode(const FString& NodeName)
     {
-        return "$Yarn.Internal.Visiting." + nodeName;
+        return FString::Printf(TEXT("$Yarn.Internal.Visiting.%s"), *NodeName);
     }
 }
diff --git a/Source/YarnSpinner/Private/YarnSpinnerCore/State.cpp b/Source/YarnSpinner/Private/YarnSpinnerCore/State.cpp
index ff0425a..6f43f23 100644
--- a/Source/YarnSpinner/Private/YarnSpinnerCore/State.cpp
+++ b/Source/YarnSpinner/Private/YarnSpinnerCore/State.cpp
@@ -3,77 +3,76 @@
 namespace Yarn
 {
 
-    void State::AddOption(Line &line, const char *destination, bool enabled)
+    void State::AddOption(const Line &Line, const FString& Destination, const bool bEnabled)
     {
         auto option = Option();
 
-        option.Line = line;
-        option.DestinationNode = destination;
-        option.IsAvailable = enabled;
-        option.ID = currentOptions.size();
+        option.Line = Line;
+        option.DestinationNode = Destination;
+        option.IsAvailable = bEnabled;
+        option.ID = currentOptions.Num();
 
-        currentOptions.push_back(option);
+        currentOptions.Add(option);
     }
 
     void State::ClearOptions()
     {
-        currentOptions.clear();
+        currentOptions.Empty();
     }
 
-    const std::vector<Option> State::GetCurrentOptions()
+    TArray<Option> State::GetCurrentOptions()
     {
         return currentOptions;
     }
 
-    void State::PushValue(std::string string)
+    void State::PushValue(const FString& Str)
     {
-        stack.push_back(FValue(string));
+        stack.Emplace(FValue(Str));
     }
 
-    void State::PushValue(const char *string)
+    void State::PushValue(const char* String)
     {
-        stack.push_back(FValue(string));
+        stack.Add(FValue(String));
     }
 
-    void State::PushValue(double number)
+    void State::PushValue(const double Number)
     {
-        stack.push_back(FValue(number));
+        stack.Add(FValue(Number));
     }
 
-    void State::PushValue(float number)
+    void State::PushValue(const float Number)
     {
-        stack.push_back(FValue(number));
+        stack.Add(FValue(Number));
     }
 
-    void State::PushValue(int number)
+    void State::PushValue(const int Number)
     {
-        stack.push_back(FValue(number));
+        stack.Add(FValue(Number));
     }
 
-    void State::PushValue(bool boolean)
+    void State::PushValue(const bool bVal)
     {
-        stack.push_back(FValue(boolean));
+        stack.Add(FValue(bVal));
     }
 
-    void State::PushValue(FValue value)
+    void State::PushValue(const FValue& Value)
     {
-        stack.push_back(value);
+        stack.Add(Value);
     }
 
     FValue State::PopValue()
     {
-        auto last = stack.back();
-        stack.pop_back();
-        return last;
+        return stack.Pop();
     }
 
-    FValue State::PeekValue()
+    FValue& State::PeekValue()
     {
-        return stack.back();
+        return stack.Last();
     }
 
     void State::ClearStack()
     {
+        stack.Empty();
     }
 
 }
\ No newline at end of file
diff --git a/Source/YarnSpinner/Private/YarnSpinnerCore/VirtualMachine.cpp b/Source/YarnSpinner/Private/YarnSpinnerCore/VirtualMachine.cpp
index 55117c5..b95bddd 100644
--- a/Source/YarnSpinner/Private/YarnSpinnerCore/VirtualMachine.cpp
+++ b/Source/YarnSpinner/Private/YarnSpinnerCore/VirtualMachine.cpp
@@ -1,60 +1,48 @@
 #include "YarnSpinnerCore/VirtualMachine.h"
 
-#include "CoreMinimal.h"
-#include "YarnSubsystem.h"
-
-#include <stack>
 #include <regex>
 #include <string>
-#include <sstream>
+#include <string>
+
+#include "CoreMinimal.h"
+#include "Misc/YSLogging.h"
 
 
 namespace Yarn
 {
-    VirtualMachine::VirtualMachine(Yarn::Program program, Library& library, IVariableStorage& variableStorage, ILogger& logger)
+    VirtualMachine::VirtualMachine(Yarn::Program program, Library& library, IVariableStorage& variableStorage)
         : program(program),
           state(State()),
           executionState(STOPPED),
           library(library),
-          logger(logger),
           variableStorage(variableStorage)
     {
         // Add the 'visited' and 'visited_count' functions, which query the variable
         // storage for information about how many times a node has been visited.
-        library.AddFunction<bool>(
+        library.AddFunction(
             "visited",
-            [&variableStorage](std::vector<FValue> values)
+            TYarnFunction<bool>::CreateLambda(
+            [&variableStorage](const TArray<FValue>& Values)
             {
-                std::string nodeName = TCHAR_TO_UTF8(*values.at(0).GetValue<FString>());
-                std::string visitTrackingVariable = Library::GenerateUniqueVisitedVariableForNode(nodeName);
-                if (variableStorage.HasValue(visitTrackingVariable))
-                {
-                    int visitCount = variableStorage.GetValue(visitTrackingVariable).GetValue<double>();
-                    return visitCount > 0;
-                }
-                else
-                {
-                    return false;
-                }
-            },
+                const FString NodeName = Values[0].GetValue<FString>();
+                const FString VisitTrackingVariable = Library::GenerateUniqueVisitedVariableForNode(NodeName);
+                return variableStorage.HasValue(VisitTrackingVariable) ?
+                    variableStorage.GetValue(VisitTrackingVariable).GetValue<double>() > 0 :
+                    false;
+            }),
             1);
 
-        library.AddFunction<float>(
+        library.AddFunction(
             "visited_count",
-            [&variableStorage](std::vector<FValue> values)
+            TYarnFunction<float>::CreateLambda(
+            [&variableStorage](const TArray<FValue>& Values)
             {
-                std::string nodeName = TCHAR_TO_UTF8(*values.at(0).GetValue<FString>());
-                std::string visitTrackingVariable = Library::GenerateUniqueVisitedVariableForNode(nodeName);
-                if (variableStorage.HasValue(visitTrackingVariable))
-                {
-                    int visitCount = (int)variableStorage.GetValue(visitTrackingVariable).GetValue<double>();
-                    return visitCount;
-                }
-                else
-                {
-                    return 0;
-                }
-            },
+                const FString NodeName = Values[0].GetValue<FString>();
+                const FString VisitTrackingVariable = Library::GenerateUniqueVisitedVariableForNode(NodeName);
+                return variableStorage.HasValue(VisitTrackingVariable) ?
+                    static_cast<int>(variableStorage.GetValue(VisitTrackingVariable).GetValue<double>()) :
+                    0;
+            }),
             1);
     }
 
@@ -78,25 +66,25 @@ namespace Yarn
     }
 
 
-    bool VirtualMachine::SetNode(const char* nodeName)
+    bool VirtualMachine::SetNode(const FString& NodeName)
     {
-        if (program.nodes().contains(nodeName) == false)
+        if (program.nodes().contains(TCHAR_TO_UTF8(*NodeName)) == false)
         {
-            logger.Log(string_format("No node named %s has been loaded.", nodeName), ILogger::ERROR);
+            YS_ERR("No node named %s has been loaded.", *NodeName);
             return false;
         }
 
-        logger.Log(string_format("Running node %s", nodeName));
+        YS_LOG("Running node %s", *NodeName);
 
-        currentNode = program.nodes().at(nodeName);
+        currentNode = program.nodes().at(TCHAR_TO_UTF8(*NodeName));
 
         // Clear our State and return to the Stopped execution state
         state = State();
         SetCurrentExecutionState(ExecutionState::STOPPED);
 
-        state.currentNodeName = nodeName;
+        state.currentNodeName = NodeName;
 
-        NodeStartHandler(nodeName);
+        OnNodeStart.Broadcast(NodeName);
 
         return true;
     }
@@ -164,10 +152,10 @@ namespace Yarn
 
             if (state.programCounter >= currentNode.instructions_size() && GetCurrentExecutionState() != STOPPED)
             {
-                NodeCompleteHandler(currentNode.name());
+                OnNodeComplete.Broadcast(currentNode.name().c_str());
                 SetCurrentExecutionState(STOPPED);
-                DialogueCompleteHandler();
-                logger.Log("Run complete.", ILogger::INFO);
+                OnDialogueComplete.Broadcast();
+                YS_LOG("Run complete.");
             }
         }
 
@@ -177,30 +165,31 @@ namespace Yarn
 
     bool VirtualMachine::RunInstruction(Yarn::Instruction& instruction)
     {
-        std::stringstream str;
+        TStringBuilder<NAME_SIZE> StrBuilder;
 
-        str << Yarn::Instruction_OpCode_Name(instruction.opcode());
+        StrBuilder << Instruction_OpCode_Name(instruction.opcode()).c_str();
 
         for (auto operand : instruction.operands())
         {
-            str << " ";
+            StrBuilder << " ";
             switch (operand.value_case())
             {
             case Yarn::Operand::kBoolValue:
-                str << (operand.bool_value() ? "true" : "false");
+                StrBuilder << (operand.bool_value() ? "true" : "false");
                 break;
             case Yarn::Operand::kFloatValueFieldNumber:
-                str << operand.float_value();
+                StrBuilder << FString::SanitizeFloat(operand.float_value());
                 break;
             case Yarn::Operand::kStringValue:
-                str << operand.string_value();
+                StrBuilder << operand.string_value().c_str();
                 break;
             default:
-                str << "(unknown operand type!)";
+                StrBuilder << "(unknown operand type!)";
             }
         }
 
-        logger.Log(str.str());
+        YS_LOG("%s", StrBuilder.ToString());
+        
         switch (instruction.opcode())
         {
         case Yarn::Instruction_OpCode_RUN_LINE:
@@ -208,9 +197,9 @@ namespace Yarn
                 // Fetch line ID
                 auto lineID = instruction.operands(0).string_value();
 
-                // Build line struct
+                // Build line structs
                 Line line = Line();
-                line.LineID = lineID;
+                line.LineID = lineID.c_str();
 
                 // If we have 2+ operands, get the second operand as a number
                 if (instruction.operands_size() > 1)
@@ -219,16 +208,16 @@ namespace Yarn
 
                     // And get that many expressions off the stack and build the
                     // collection of substitutions (in reverse order)
-                    std::vector<std::string> substitutions;
+                    TArray<FString> substitutions;
 
                     for (int expressionIndex = expressionCount - 1; expressionIndex >= 0; expressionIndex--)
                     {
                         auto top = state.PopValue();
-                        std::string topAsString = TCHAR_TO_UTF8(*top.ConvertToString());
-                        substitutions.push_back(topAsString);
+                        FString topAsString = top.ConvertToString();
+                        substitutions.Add(topAsString);
                     }
 
-                    std::reverse(substitutions.begin(), substitutions.end());
+                    Algo::Reverse(substitutions);
 
                     line.Substitutions = substitutions;
                 }
@@ -237,7 +226,7 @@ namespace Yarn
                 SetCurrentExecutionState(DELIVERING_CONTENT);
 
                 // Call the line handler
-                LineHandler(line);
+                OnLine.Broadcast(line);
 
                 // If we're still marked as delivering content, then the line
                 // handler didn't call Continue, so we'll wait here
@@ -259,14 +248,14 @@ namespace Yarn
 
                     // And get that many expressions off the stack and build the
                     // collection of substitutions (in reverse order)
-                    std::vector<std::string> substitutions;
+                    TArray<FString> substitutions;
 
                     for (int expressionIndex = expressionCount - 1; expressionIndex >= 0; expressionIndex--)
                     {
                         auto top = state.PopValue();
-                        std::string topAsString = TCHAR_TO_UTF8(*top.ConvertToString());
+                        const std::string topAsString = TCHAR_TO_UTF8(*top.ConvertToString());
 
-                        // std::string placeholder("\\{" << expressionIndex << "\\}");
+                        // FString placeholder("\\{" << expressionIndex << "\\}");
                         commandText = std::regex_replace(commandText, std::regex("\\{" + std::to_string(expressionIndex) + "\\}"), topAsString);
                     }
                 }
@@ -274,9 +263,9 @@ namespace Yarn
                 SetCurrentExecutionState(DELIVERING_CONTENT);
 
                 auto command = Command();
-                command.Text = commandText;
+                command.Text = commandText.c_str();
 
-                CommandHandler(command);
+                OnCommand.Broadcast(command);
 
                 if (GetCurrentExecutionState() == DELIVERING_CONTENT)
                 {
@@ -288,8 +277,8 @@ namespace Yarn
             }
         case Yarn::Instruction_OpCode_STOP:
             {
-                NodeCompleteHandler(currentNode.name());
-                DialogueCompleteHandler();
+                OnNodeComplete.Broadcast(currentNode.name().c_str());
+                OnDialogueComplete.Broadcast();
                 SetCurrentExecutionState(STOPPED);
                 break;
             }
@@ -307,7 +296,7 @@ namespace Yarn
             }
         case Yarn::Instruction_OpCode_PUSH_STRING:
             {
-                std::string value = instruction.operands(0).string_value();
+                FString value = instruction.operands(0).string_value().c_str();
                 state.PushValue(value);
                 break;
             }
@@ -316,21 +305,21 @@ namespace Yarn
                 bool topOfStack = state.PeekValue().GetValue<bool>();
                 if (topOfStack == false)
                 {
-                    auto label = instruction.operands(0).string_value();
+                    auto label = instruction.operands(0).string_value().c_str();
                     state.programCounter = FindInstructionPointForLabel(label) - 1;
                 }
                 break;
             }
         case Yarn::Instruction_OpCode_JUMP_TO:
             {
-                auto label = instruction.operands(0).string_value();
+                auto label = instruction.operands(0).string_value().c_str();
                 state.programCounter = FindInstructionPointForLabel(label) - 1;
                 break;
             }
         case Yarn::Instruction_OpCode_JUMP:
             {
                 // Jumps to a label whose name is on the stack.
-                std::string jumpDestination = TCHAR_TO_UTF8(*state.PeekValue().GetValue<FString>());
+                FString jumpDestination = state.PeekValue().GetValue<FString>();
                 state.programCounter = FindInstructionPointForLabel(jumpDestination) - 1;
                 break;
             }
@@ -338,8 +327,8 @@ namespace Yarn
             {
                 Line line = Line();
 
-                line.LineID = instruction.operands(0).string_value();
-                std::string destination = instruction.operands(1).string_value();
+                line.LineID = instruction.operands(0).string_value().c_str();
+                FString destination = instruction.operands(1).string_value().c_str();
 
                 if (instruction.operands_size() > 2)
                 {
@@ -350,16 +339,16 @@ namespace Yarn
 
                     // Get that many expressions off the stack and build the collection
                     // of substitutions (in reverse order)
-                    std::vector<std::string> substitutions;
+                    TArray<FString> substitutions;
 
                     for (int expressionIndex = expressionCount - 1; expressionIndex >= 0; expressionIndex--)
                     {
                         auto top = state.PopValue();
-                        std::string topAsString = TCHAR_TO_UTF8(*top.ConvertToString());
-                        substitutions.push_back(topAsString);
+                        FString topAsString = top.ConvertToString();
+                        substitutions.Add(topAsString);
                     }
 
-                    std::reverse(substitutions.begin(), substitutions.end());
+                    Algo::Reverse(substitutions);
 
                     line.Substitutions = substitutions;
                 }
@@ -384,7 +373,7 @@ namespace Yarn
                     }
                 }
 
-                state.AddOption(line, destination.c_str(), lineConditionPassed);
+                state.AddOption(line, destination, lineConditionPassed);
                 break;
             }
         case Yarn::Instruction_OpCode_SHOW_OPTIONS:
@@ -393,10 +382,10 @@ namespace Yarn
 
                 // If we have no options to show, immediately stop.
 
-                if (state.currentOptions.size() == 0)
+                if (state.currentOptions.IsEmpty())
                 {
                     SetCurrentExecutionState(STOPPED);
-                    DialogueCompleteHandler();
+                    OnDialogueComplete.Broadcast();
                     break;
                 }
 
@@ -412,7 +401,7 @@ namespace Yarn
                 // Pass the options set to the client, as well as a
                 // delegate for them to call when the user has made
                 // a selection
-                OptionsHandler(optionSet);
+                OnOptions.Broadcast(optionSet);
 
                 if (GetCurrentExecutionState() == WAITING_FOR_CONTINUE)
                 {
@@ -429,7 +418,7 @@ namespace Yarn
             {
                 // Push a null value. This is not a valid instruction as of Yarn Spinner
                 // 2.0.
-                logger.Log("PUSH_NULL is not a valid instruction in Yarn Spinner 2.0+", ILogger::ERROR);
+                YS_ERR("PUSH_NULL is not a valid instruction in Yarn Spinner 2.0+");
                 return false;
                 break;
             }
@@ -443,40 +432,39 @@ namespace Yarn
             {
                 // Call a named function, with parameters found on the stack, and push
                 // the resulting value onto the stack.
-                auto functionName = instruction.operands(0).string_value();
+                const FString functionName = instruction.operands(0).string_value().c_str();
 
                 auto actualParamCount = (int)state.PopValue().GetValue<double>();
-
-                if (!DoesFunctionExist(functionName))
+                if (!OnCheckFunctionExist.Execute(functionName))
                 {
-                    logger.Log(string_format("Unknown function '%s'", functionName.c_str()), ILogger::ERROR);
+                    YS_ERR("Unknown function '%s'", *functionName);
                     return false;
                 }
 
                 // auto expectedParamCount = library.GetExpectedParameterCount(functionName);
-                auto expectedParamCount = GetExpectedFunctionParamCount(functionName);
+                auto expectedParamCount = OnGetFunctionParamNum.Execute(functionName);
 
                 if (expectedParamCount >= 0 && expectedParamCount != actualParamCount)
                 {
-                    logger.Log(string_format("Function '%s' expects %i parameters, but %i were provided", functionName.c_str(), expectedParamCount, actualParamCount), ILogger::ERROR);
+                    YS_ERR("Function '%s' expects %i parameters, but %i were provided", *functionName, expectedParamCount, actualParamCount);
                     return false;
                 }
 
-                std::vector<FValue> parameters;
+                TArray<FValue> parameters;
 
                 for (int param = actualParamCount - 1; param >= 0; param--)
                 {
                     auto value = state.PopValue();
-                    parameters.push_back(value);
+                    parameters.Add(value);
                 }
-                std::reverse(parameters.begin(), parameters.end());
+                Algo::Reverse(parameters);
 
-                auto result = CallFunction(functionName, parameters);
+                auto result = OnCallFunction.Execute(functionName, parameters);
                 state.PushValue(result);
 
-                // if (library.HasFunction<std::string>(functionName))
+                // if (library.HasFunction<FString>(functionName))
                 // {
-                //     auto function = library.GetFunction<std::string>(functionName);
+                //     auto function = library.GetFunction<FString>(functionName);
                 //     auto result = function.Function(parameters);
                 //     state.PushValue(result);
                 // }
@@ -494,18 +482,18 @@ namespace Yarn
                 // }
                 // else
                 // {
-                //     logger.Log(string_format("Unknown function %s", functionName.c_str()), ILogger::ERROR);
+                //     YS_ERR("Unknown function %s", *functionName);
                 //     return false;
                 // }
 
-                logger.Log(string_format("Function call returned \"%s\" (type: %d)", *state.PeekValue().ConvertToString(), state.PeekValue().GetType()));
+                YS_LOG("Function call returned \"%s\" (type: %d)", *state.PeekValue().ConvertToString(), state.PeekValue().GetType());
 
                 break;
             }
         case Yarn::Instruction_OpCode_PUSH_VARIABLE:
             {
                 // Get the contents of a variable, and push that onto the stack.
-                auto variableName = instruction.operands(0).string_value();
+                const FString variableName = instruction.operands(0).string_value().c_str();
 
                 if (variableStorage.HasValue(variableName))
                 {
@@ -513,34 +501,34 @@ namespace Yarn
                     FValue v = variableStorage.GetValue(variableName);
                     state.PushValue(v);
                 }
-                else if (program.initial_values().count(variableName) > 0)
+                else if (program.initial_values().count(TCHAR_TO_UTF8(*variableName)) > 0)
                 {
                     // We don't have a value for this. The initial value may be found in
                     // the program. (If it's not, then the variable's value is
                     // undefined, which isn't allowed.)
-                    auto operand = program.initial_values().at(variableName);
+                    auto operand = program.initial_values().at(TCHAR_TO_UTF8(*variableName));
                     switch (operand.value_case())
                     {
                     case Yarn::Operand::ValueCase::kBoolValue:
                         state.PushValue(operand.bool_value());
                         break;
                     case Yarn::Operand::ValueCase::kStringValue:
-                        state.PushValue(operand.string_value());
+                        state.PushValue(operand.string_value().c_str());
                         break;
                     case Yarn::Operand::ValueCase::kFloatValue:
                         state.PushValue(operand.float_value());
                         break;
                     default:
-                        logger.Log(string_format("Unknown initial value type %i for variable %s", operand.value_case(), variableName.c_str()), ILogger::ERROR);
+                        YS_ERR("Unknown initial value type %i for variable %s", operand.value_case(), *variableName);
                         return false;
                     }
                 }
                 else
                 {
                     // We didn't find a value for this variable in storage or in the
-                    // program's intial values. This is an error - the variable must not
+                    // program's initial values. This is an error - the variable must not
                     // have been defined.
-                    logger.Log(string_format("Undefined variable %s", variableName.c_str()), ILogger::ERROR);
+                    YS_ERR("Undefined variable %s", *variableName);
                     return false;
                 }
                 break;
@@ -548,15 +536,15 @@ namespace Yarn
         case Yarn::Instruction_OpCode_STORE_VARIABLE:
             {
                 // Store the top value on the stack in a variable.
-                auto topValue = state.PeekValue();
-                auto destinationVariableName = instruction.operands(0).string_value();
+                const FValue topValue = state.PeekValue();
+                const FString destinationVariableName = instruction.operands(0).string_value().c_str();
 
-                logger.Log(string_format("Set %s to %s", destinationVariableName.c_str(), *topValue.ConvertToString()));
+                YS_LOG("Set %ss to %s", *destinationVariableName, *topValue.ConvertToString());
 
                 switch (topValue.GetType())
                 {
                 case FValue::EValueType::String:
-                    variableStorage.SetValue(destinationVariableName, TCHAR_TO_UTF8(*topValue.GetValue<FString>()));
+                    variableStorage.SetValue(destinationVariableName, topValue.GetValue<FString>());
                     break;
                 case FValue::EValueType::Number:
                     variableStorage.SetValue(destinationVariableName, static_cast<float>(topValue.GetValue<double>()));
@@ -565,7 +553,7 @@ namespace Yarn
                     variableStorage.SetValue(destinationVariableName, topValue.GetValue<bool>());
                     break;
                 default:
-                    logger.Log(string_format("Invalid Yarn value type %i for variable %s", topValue.GetType(), destinationVariableName.c_str()), ILogger::ERROR);
+                    YS_ERR("Invalid Yarn value type %i for variable %s", topValue.GetType(), *destinationVariableName);
                     return false;
                 }
                 break;
@@ -573,11 +561,11 @@ namespace Yarn
         case Yarn::Instruction_OpCode_RUN_NODE:
             {
                 // Pop a string from the stack, and jump to a node with that name.
-                const std::string nodeName = TCHAR_TO_UTF8(*state.PopValue().GetValue<FString>());
+                const FString& nodeName = state.PopValue().GetValue<FString>();
 
-                NodeCompleteHandler(currentNode.name());
+                OnNodeComplete.Broadcast(currentNode.name().c_str());
 
-                SetNode(nodeName.c_str());
+                SetNode(nodeName);
 
                 // Decrement program counter here, because it will be incremented when
                 // this function returns, and would mean skipping the first instruction
@@ -586,7 +574,7 @@ namespace Yarn
                 break;
             }
         default:
-            logger.Log(string_format("Unhandled instruction type %i", instruction.opcode()));
+            YS_LOG("Unhandled instruction type %i", instruction.opcode());
             return false;
             break;
         }
@@ -602,15 +590,15 @@ namespace Yarn
     }
 
 
-    int VirtualMachine::FindInstructionPointForLabel(std::string label)
+    int VirtualMachine::FindInstructionPointForLabel(const FString& Label)
     {
-        if (currentNode.labels().count(label) == 0)
+        if (currentNode.labels().count(TCHAR_TO_UTF8(*Label)) == 0)
         {
-            logger.Log(string_format("Unknown label %s in node %s", label.c_str(), currentNode.name().c_str()), ILogger::ERROR);
+            YS_ERR("Unknown label %s in node %s", *Label, currentNode.name().c_str());
             SetCurrentExecutionState(ERROR);
             return -1;
         }
-        return currentNode.labels().at(label);
+        return currentNode.labels().at(TCHAR_TO_UTF8(*Label));
     }
 
 
@@ -618,33 +606,33 @@ namespace Yarn
     {
         if (executionState == WAITING_ON_OPTION_SELECTION)
         {
-            logger.Log("Cannot continue running dialogue. Still waiting on option selection.", ILogger::Type::ERROR);
+            YS_ERR("Cannot continue running dialogue. Still waiting on option selection.");
             return false;
         }
 
-        if (!LineHandler)
+        if (!OnLine.IsBound())
         {
-            logger.Log("Cannot continue dialogue: LineHandler has not been set.", ILogger::Type::ERROR);
+            YS_ERR("Cannot continue dialogue: OnLine handler has not been set.");
             return false;
         }
-        if (!OptionsHandler)
+        if (!OnOptions.IsBound())
         {
-            logger.Log("Cannot continue dialogue: OptionsHandler has not been set.", ILogger::Type::ERROR);
+            YS_ERR("Cannot continue dialogue: OnOptions handler has not been set.");
             return false;
         }
-        if (!CommandHandler)
+        if (!OnCommand.IsBound())
         {
-            logger.Log("Cannot continue dialogue: CommandHandler has not been set.", ILogger::Type::ERROR);
+            YS_ERR("Cannot continue dialogue: OnCommand handler has not been set.");
             return false;
         }
-        if (!NodeCompleteHandler)
+        if (!OnNodeComplete.IsBound())
         {
-            logger.Log("Cannot continue dialogue: NodeCompleteHandler has not been set.", ILogger::Type::ERROR);
+            YS_ERR("Cannot continue dialogue: OnNodeComplete handler has not been set.");
             return false;
         }
-        if (!DialogueCompleteHandler)
+        if (!OnDialogueComplete.IsBound())
         {
-            logger.Log("Cannot continue dialogue: DialogueCompleteHandler has not been set.", ILogger::Type::ERROR);
+            YS_ERR("Cannot continue dialogue: OnDialogueComplete handler has not been set.");
             return false;
         }
         return true;
@@ -655,36 +643,36 @@ namespace Yarn
     {
         if (GetCurrentExecutionState() != WAITING_ON_OPTION_SELECTION)
         {
-            logger.Log("SetSelectedOption was called, but Dialogue wasn't waiting for a selection. This method should only be called after the Dialogue is waiting for the user to select an option.", ILogger::ERROR);
+            YS_ERR("SetSelectedOption was called, but Dialogue wasn't waiting for a selection. This method should only be called after the Dialogue is waiting for the user to select an option.");
             SetCurrentExecutionState(VirtualMachine::ERROR);
             return;
         }
 
-        if (selectedOptionIndex < 0 || selectedOptionIndex >= (int)state.currentOptions.size())
+        if (selectedOptionIndex < 0 || selectedOptionIndex >= state.currentOptions.Num())
         {
-            logger.Log("SetSelectedOption was called with an invalid option index");
+            YS_LOG("SetSelectedOption was called with an invalid option index");
         }
 
         auto destinationNode = state.currentOptions[selectedOptionIndex].DestinationNode;
         state.PushValue(destinationNode);
 
-        state.currentOptions.clear();
+        state.currentOptions.Empty();
 
         SetCurrentExecutionState(WAITING_FOR_CONTINUE);
     }
 
 
-    std::string VirtualMachine::ExpandSubstitutions(std::string templateString, std::vector<std::string> substitutions)
+    FString VirtualMachine::ExpandSubstitutions(const FString& TemplateString, const TArray<FString>& Substitutions)
     {
         int i = 0;
 
-        std::string output = templateString;
-        for (std::string& sub : substitutions)
+        std::string Output = TCHAR_TO_UTF8(*TemplateString);
+        for (const FString& Sub : Substitutions)
         {
-            output = std::regex_replace(output, std::regex("\\{" + std::to_string(i) + "\\}"), sub);
+            Output = std::regex_replace(Output, std::regex("\\{" + std::to_string(i) + "\\}"), TCHAR_TO_UTF8(*Sub));
             i++;
         }
 
-        return output;
+        return FString(Output.c_str());
     }
 }
diff --git a/Source/YarnSpinner/Private/YarnSubsystem.cpp b/Source/YarnSpinner/Private/YarnSubsystem.cpp
index d0825e9..9ae4491 100644
--- a/Source/YarnSpinner/Private/YarnSubsystem.cpp
+++ b/Source/YarnSpinner/Private/YarnSubsystem.cpp
@@ -3,13 +3,10 @@
 
 #include "YarnSubsystem.h"
 
-#include "DisplayLine.h"
 #include "Engine/ObjectLibrary.h"
 #include "Library/YarnCommandLibrary.h"
 #include "Library/YarnFunctionLibrary.h"
 #include "Library/YarnLibraryRegistry.h"
-#include "Misc/OutputDeviceHelper.h"
-#include "Misc/OutputDeviceNull.h"
 #include "Misc/YarnAssetHelpers.h"
 #include "Misc/YSLogging.h"
 
@@ -101,39 +98,39 @@ void UYarnSubsystem::Deinitialize()
 }
 
 
-void UYarnSubsystem::SetValue(std::string name, bool value)
+void UYarnSubsystem::SetValue(const FString& name, bool value)
 {
-    Variables.FindOrAdd(FString(UTF8_TO_TCHAR(name.c_str()))) = Yarn::FValue(value);
+    Variables.FindOrAdd(name) = value;
 }
 
 
-void UYarnSubsystem::SetValue(std::string name, float value)
+void UYarnSubsystem::SetValue(const FString& name, float value)
 {
-    Variables.FindOrAdd(FString(UTF8_TO_TCHAR(name.c_str()))) = Yarn::FValue(value);
+    Variables.FindOrAdd(name) = value;
 }
 
 
-void UYarnSubsystem::SetValue(std::string name, std::string value)
+void UYarnSubsystem::SetValue(const FString& name, const FString& value)
 {
-    Variables.FindOrAdd(FString(UTF8_TO_TCHAR(name.c_str()))) = Yarn::FValue(value);
+    Variables.FindOrAdd(name) = value;
 }
 
 
-bool UYarnSubsystem::HasValue(std::string name)
+bool UYarnSubsystem::HasValue(const FString& name)
 {
-    return Variables.Contains(FString(UTF8_TO_TCHAR(name.c_str())));
+    return Variables.Contains(name);
 }
 
 
-Yarn::FValue UYarnSubsystem::GetValue(std::string name)
+Yarn::FValue UYarnSubsystem::GetValue(const FString& name)
 {
-    return Variables.FindOrAdd(FString(UTF8_TO_TCHAR(name.c_str())));
+    return Variables.FindOrAdd(name);
 }
 
 
-void UYarnSubsystem::ClearValue(std::string name)
+void UYarnSubsystem::ClearValue(const FString& name)
 {
-    Variables.Remove(FString(UTF8_TO_TCHAR(name.c_str())));
+    Variables.Remove(name);
 }
 
 
diff --git a/Source/YarnSpinner/Public/DialogueRunner.h b/Source/YarnSpinner/Public/DialogueRunner.h
index 6776d0c..8809074 100644
--- a/Source/YarnSpinner/Public/DialogueRunner.h
+++ b/Source/YarnSpinner/Public/DialogueRunner.h
@@ -17,7 +17,7 @@ THIRD_PARTY_INCLUDES_END
 DECLARE_DELEGATE(FYarnDialogueRunnerContinueDelegate);
 
 UCLASS()
-class YARNSPINNER_API ADialogueRunner : public AActor, public Yarn::ILogger, public Yarn::IVariableStorage
+class YARNSPINNER_API ADialogueRunner : public AActor, public Yarn::IVariableStorage
 {
     GENERATED_BODY()
     
@@ -71,18 +71,15 @@ class YARNSPINNER_API ADialogueRunner : public AActor, public Yarn::ILogger, pub
 
     FYarnDialogueRunnerContinueDelegate ContinueDelegate;
 
-    // ILogger
-    virtual void Log(std::string Message, Type Severity = Type::INFO) override;
-
     // IVariableStorage
-    virtual void SetValue(std::string Name, bool bValue) override;
-    virtual void SetValue(std::string Name, float Value) override;
-    virtual void SetValue(std::string Name, std::string Value) override;
+    virtual void SetValue(const FString& Name, bool bValue) override;
+    virtual void SetValue(const FString& Name, float Value) override;
+    virtual void SetValue(const FString& Name, const FString& Value) override;
 
-    virtual bool HasValue(std::string Name) override;
-    virtual Yarn::FValue GetValue(std::string Name) override;
+    virtual bool HasValue(const FString& Name) override;
+    virtual Yarn::FValue GetValue(const FString& Name) override;
 
-    virtual void ClearValue(std::string Name) override;
+    virtual void ClearValue(const FString& Name) override;
 
     FString GetLine(FName LineID, FName Language);
 
diff --git a/Source/YarnSpinner/Public/YarnSpinnerCore/Common.h b/Source/YarnSpinner/Public/YarnSpinnerCore/Common.h
index b7888ec..2e73ae2 100644
--- a/Source/YarnSpinner/Public/YarnSpinnerCore/Common.h
+++ b/Source/YarnSpinner/Public/YarnSpinnerCore/Common.h
@@ -2,79 +2,45 @@
 
 #include <string>
 #include <vector>
-#include <iostream>
 
 #define UNUSED(x) (void)(x)
 
 namespace Yarn
 {
-
-    class YARNSPINNER_API ILogger
-    {
-    public:
-        enum Type
-        {
-            ERROR,
-            WARNING,
-            INFO
-        };
-        /**
-         * @brief Logs a message.
-         * 
-         * @param message The message to log.
-         * @param severity The severity of the log.
-         */
-        virtual void Log(std::string message, Type severity = Type::INFO) = 0;
-    };
-
     struct Line
     {
-        std::string LineID;
-        std::vector<std::string> Substitutions;
+        FString LineID;
+        TArray<FString> Substitutions;
 
-        friend std::ostream &operator<<(std::ostream &os, const Line &line)
+        friend std::ostream &operator<<(std::ostream &OutputStream, const Line &AddedLine)
         {
-            os << "ID: " << line.LineID;
+            OutputStream << "ID: " << TCHAR_TO_UTF8(*AddedLine.LineID);
 
             int i = 0;
-            for (auto sub : line.Substitutions)
+            for (const FString& Sub : AddedLine.Substitutions)
             {
-                os << ", {" << i << "} :" << sub;
+                OutputStream << ", {" << i << "} :" << TCHAR_TO_UTF8(*Sub);
                 i++;
             }
-            return os;
+            return OutputStream;
         }
     };
 
     struct OptionSet
     {
-        std::vector<struct Option> Options;
+        TArray<struct Option> Options;
     };
 
     struct Option
     {
         Line Line;
         int ID = -1;
-        std::string DestinationNode;
+        FString DestinationNode;
         bool IsAvailable = true;
     };
 
     struct Command
     {
-        std::string Text;
+        FString Text;
     };
-
-    template <typename... Args>
-    std::string string_format(const std::string &format, Args... args)
-    {
-        int size_s = std::snprintf(nullptr, 0, format.c_str(), args...) + 1; // Extra space for '\0'
-        if (size_s <= 0)
-        {
-            throw std::runtime_error("Error during formatting.");
-        }
-        auto size = static_cast<size_t>(size_s);
-        std::unique_ptr<char[]> buf(new char[size]);
-        std::snprintf(buf.get(), size, format.c_str(), args...);
-        return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
-    }
 }
\ No newline at end of file
diff --git a/Source/YarnSpinner/Public/YarnSpinnerCore/Library.h b/Source/YarnSpinner/Public/YarnSpinnerCore/Library.h
index 28a8b86..35deb38 100644
--- a/Source/YarnSpinner/Public/YarnSpinnerCore/Library.h
+++ b/Source/YarnSpinner/Public/YarnSpinnerCore/Library.h
@@ -1,74 +1,69 @@
 #pragma once
 
-#include <map>
-#include <functional>
 #include <string>
 
 #include "Value.h"
 
 namespace Yarn
 {
-
     template <typename T>
-    using YarnFunction = std::function<T(std::vector<FValue>)>;
+    using TYarnFunction = TDelegate<T(const TArray<FValue>&)>;
 
     template <typename T>
     class YARNSPINNER_API FunctionInfo
     {
     public:
         int ExpectedParameterCount;
-        YarnFunction<T> Function;
+        TYarnFunction<T> Function;
 
         FunctionInfo();
-        FunctionInfo(int paramCount, T (*f)(std::vector<FValue>));
+        FunctionInfo(int ParamCount, T (*F)(const TArray<FValue>&));
     };
 
     class YARNSPINNER_API Library
     {
     private:
-        ILogger &logger;
-
-        std::map<std::string, FunctionInfo<std::string>> stringFunctions;
-        std::map<std::string, FunctionInfo<float>> numberFunctions;
-        std::map<std::string, FunctionInfo<bool>> boolFunctions;
+        TMap<FString, FunctionInfo<FString>> stringFunctions;
+        TMap<FString, FunctionInfo<float>> numberFunctions;
+        TMap<FString, FunctionInfo<bool>> boolFunctions;
 
         template <typename T>
-        FunctionInfo<T> &GetFunctionImpl(std::map<std::string, FunctionInfo<T>> &source, std::string name);
+        FunctionInfo<T> &GetFunctionImpl(TMap<FString, FunctionInfo<T>> &Source, const FString& Name);
 
         template <typename T>
-        void AddFunctionImpl(std::map<std::string, FunctionInfo<T>> &source, std::string name, YarnFunction<T> func, int parameterCount);
+        void AddFunctionImpl(TMap<FString, FunctionInfo<T>> &source, const FString& name, TYarnFunction<T> func, int parameterCount);
 
         template <typename T>
-        void RemoveFunctionImpl(std::map<std::string, FunctionInfo<T>> &source, std::string name);
+        void RemoveFunctionImpl(TMap<FString, FunctionInfo<T>> &source, const FString& name);
 
         template <typename T>
-        bool HasFunctionImpl(std::map<std::string, FunctionInfo<T>> &source, std::string name);
+        bool HasFunctionImpl(TMap<FString, FunctionInfo<T>> &source, const FString& name);
 
     public:
-        Library(ILogger &logger);
+        Library();
 
         template <typename T>
-        FunctionInfo<T> GetFunction(std::string name);
+        FunctionInfo<T> GetFunction(const FString& Name);
 
         template <typename T>
-        void AddFunction(std::string name, YarnFunction<T> function, int parameterCount);
+        void AddFunction(const FString& name, TYarnFunction<T> function, int parameterCount);
 
         // template <typename T>
-        // void AddFunction (std::string name, T(*f)(std::vector<::Value>), int parameterCount);
+        // void AddFunction (const FString& name, T(*f)(TArray<::Value>), int parameterCount);
 
         template <typename T>
-        void RemoveFunction(std::string name);
+        void RemoveFunction(const FString& Name);
 
         template <typename T>
-        bool HasFunction(std::string name);
+        bool HasFunction(const FString& Name);
 
         void RemoveAllFunctions();
 
-        int GetExpectedParameterCount(std::string name);
+        int GetExpectedParameterCount(const FString& Name);
 
         void LoadStandardLibrary();
 
-        static std::string GenerateUniqueVisitedVariableForNode(std::string nodeName);
+        static FString GenerateUniqueVisitedVariableForNode(const FString& NodeName);
     };
 
 }
\ No newline at end of file
diff --git a/Source/YarnSpinner/Public/YarnSpinnerCore/State.h b/Source/YarnSpinner/Public/YarnSpinnerCore/State.h
index d3e5a36..3d3dd21 100644
--- a/Source/YarnSpinner/Public/YarnSpinnerCore/State.h
+++ b/Source/YarnSpinner/Public/YarnSpinnerCore/State.h
@@ -1,39 +1,38 @@
 #pragma once
 
 #include <string>
-#include <stack>
 #include <vector>
 
-#include "YarnSpinnerCore/Common.h"
 #include "Value.h"
+#include "YarnSpinnerCore/Common.h"
 
 namespace Yarn
 {
     class YARNSPINNER_API State
     {
     public:
-        std::vector<FValue> stack;
-        std::vector<Option> currentOptions;
+        TArray<FValue> stack;
+        TArray<Option> currentOptions;
 
-        std::string currentNodeName;
+        FString currentNodeName;
 
         int programCounter = 0;
 
-        void AddOption(Line &line, const char *destination, bool enabled);
+        void AddOption(const Line &Line, const FString& Destination, bool bEnabled);
         void ClearOptions();
-        const std::vector<Option> GetCurrentOptions();
+        TArray<Option> GetCurrentOptions();
 
-        void PushValue(std::string string);
-        void PushValue(const char *string);
-        void PushValue(double number);
-        void PushValue(float number);
-        void PushValue(int number);
-        void PushValue(bool boolean);
+        void PushValue(const FString& Str);
+        void PushValue(const char *String);
+        void PushValue(double Number);
+        void PushValue(float Number);
+        void PushValue(int Number);
+        void PushValue(bool bVal);
 
-        void PushValue(FValue value);
+        void PushValue(const FValue& Value);
 
         FValue PopValue();
-        FValue PeekValue();
+        FValue& PeekValue();
 
         void ClearStack();
     };
diff --git a/Source/YarnSpinner/Public/YarnSpinnerCore/VirtualMachine.h b/Source/YarnSpinner/Public/YarnSpinnerCore/VirtualMachine.h
index 30bf57b..5f63f2c 100644
--- a/Source/YarnSpinner/Public/YarnSpinnerCore/VirtualMachine.h
+++ b/Source/YarnSpinner/Public/YarnSpinnerCore/VirtualMachine.h
@@ -17,16 +17,29 @@ namespace Yarn
     class YARNSPINNER_API IVariableStorage
     {
     public:
-        virtual void SetValue(std::string name, bool value) = 0;
-        virtual void SetValue(std::string name, float value) = 0;
-        virtual void SetValue(std::string name, std::string value) = 0;
+        virtual ~IVariableStorage() = default;
+        
+        virtual void SetValue(const FString& name, bool value) = 0;
+        virtual void SetValue(const FString& name, float value) = 0;
+        virtual void SetValue(const FString& name, const FString& value) = 0;
 
-        virtual bool HasValue(std::string name) = 0;
-        virtual FValue GetValue(std::string name) = 0;
+        virtual bool HasValue(const FString& name) = 0;
+        virtual FValue GetValue(const FString& name) = 0;
 
-        virtual void ClearValue(std::string name) = 0;
+        virtual void ClearValue(const FString& name) = 0;
     };
 
+    // Function handler delegate definitions
+    DECLARE_MULTICAST_DELEGATE_OneParam(FOnLine, const Line&);
+    DECLARE_MULTICAST_DELEGATE_OneParam(FOnOptions, const OptionSet&);
+    DECLARE_MULTICAST_DELEGATE_OneParam(FOnCommand, const Command&);
+    DECLARE_MULTICAST_DELEGATE_OneParam(FOnNodeStart, const FString&);
+    DECLARE_MULTICAST_DELEGATE_OneParam(FOnNodeComplete, const FString&);
+    DECLARE_MULTICAST_DELEGATE(FOnDialogueComplete);
+    DECLARE_DELEGATE_RetVal_OneParam(bool, FOnCheckFunctionExist, const FString&);
+    DECLARE_DELEGATE_RetVal_OneParam(int, FOnGetFunctionParamNum, const FString&);
+    DECLARE_DELEGATE_RetVal_TwoParams(FValue, FOnCallFunction, const FString&, const TArray<FValue>&);
+
     class YARNSPINNER_API VirtualMachine
     {
     public:
@@ -59,24 +72,23 @@ namespace Yarn
 
         Yarn::Node currentNode;
 
-        std::string currentNodeName;
+        FString currentNodeName;
 
         State state;
 
         ExecutionState executionState;
 
         Library &library;
-        ILogger &logger;
         IVariableStorage &variableStorage;
 
     public:
-        VirtualMachine(Yarn::Program program, Library &library, IVariableStorage &variableStorage, ILogger &logger);
+        VirtualMachine(Yarn::Program program, Library &library, IVariableStorage &variableStorage);
         ~VirtualMachine();
 
         void SetProgram(Yarn::Program program);
         const Yarn::Program &GetProgram();
 
-        bool SetNode(const char *nodeName);
+        bool SetNode(const FString& NodeName);
         const char *GetCurrentNodeName();
 
         ExecutionState GetCurrentExecutionState();
@@ -84,24 +96,25 @@ namespace Yarn
         // Begins or continues execution of the virtual machine.
         bool Continue();
 
-        std::function<void(Line &)> LineHandler;
-        std::function<void(OptionSet &)> OptionsHandler;
-        std::function<void(Command &)> CommandHandler;
-        std::function<void(std::string)> NodeStartHandler;
-        std::function<void(std::string)> NodeCompleteHandler;
-        std::function<void()> DialogueCompleteHandler;
-        std::function<bool(std::string)> DoesFunctionExist;
-        std::function<int(std::string)> GetExpectedFunctionParamCount;
-        std::function<Yarn::FValue(std::string, std::vector<Yarn::FValue>)> CallFunction;
+        // Function handlers
+        FOnLine OnLine;
+        FOnOptions OnOptions;
+        FOnCommand OnCommand;
+        FOnNodeStart OnNodeStart;
+        FOnNodeComplete OnNodeComplete;
+        FOnDialogueComplete OnDialogueComplete;
+        FOnCheckFunctionExist OnCheckFunctionExist;
+        FOnGetFunctionParamNum OnGetFunctionParamNum;
+        FOnCallFunction OnCallFunction;
 
         void SetSelectedOption(int selectedOptionIndex);
 
-        static std::string ExpandSubstitutions(std::string templateString, std::vector<std::string> substitutions);
+        static FString ExpandSubstitutions(const FString& TemplateString, const TArray<FString>& Substitutions);
 
     private:
         void SetCurrentExecutionState(ExecutionState state);
         bool CheckCanContinue();
         bool RunInstruction(Yarn::Instruction &instruction);
-        int FindInstructionPointForLabel(std::string label);
+        int FindInstructionPointForLabel(const FString& Label);
     };
 }
diff --git a/Source/YarnSpinner/Public/YarnSubsystem.h b/Source/YarnSpinner/Public/YarnSubsystem.h
index cfbffd7..3fc7fbf 100644
--- a/Source/YarnSpinner/Public/YarnSubsystem.h
+++ b/Source/YarnSpinner/Public/YarnSubsystem.h
@@ -27,14 +27,14 @@ class YARNSPINNER_API UYarnSubsystem : public UGameInstanceSubsystem, public Yar
     virtual void Initialize(FSubsystemCollectionBase& Collection) override;
     virtual void Deinitialize() override;
 
-    virtual void SetValue(std::string name, bool value);
-    virtual void SetValue(std::string name, float value);
-    virtual void SetValue(std::string name, std::string value);
+    virtual void SetValue(const FString& name, bool value);
+    virtual void SetValue(const FString& name, float value);
+    virtual void SetValue(const FString& name, const FString& value);
 
-    virtual bool HasValue(std::string name);
-    virtual Yarn::FValue GetValue(std::string name);
+    virtual bool HasValue(const FString& name);
+    virtual Yarn::FValue GetValue(const FString& name);
 
-    virtual void ClearValue(std::string name);
+    virtual void ClearValue(const FString& name);
 
     const UYarnLibraryRegistry* GetYarnLibraryRegistry() const { return YarnFunctionRegistry; }
 
diff --git a/Source/YarnSpinnerEditor/Private/YarnAssetFactory.cpp b/Source/YarnSpinnerEditor/Private/YarnAssetFactory.cpp
index 13e177c..cd1a913 100644
--- a/Source/YarnSpinnerEditor/Private/YarnAssetFactory.cpp
+++ b/Source/YarnSpinnerEditor/Private/YarnAssetFactory.cpp
@@ -107,10 +107,13 @@ UObject* UYarnAssetFactory::FactoryCreateBinary(UClass* InClass, UObject* InPare
     }
 
     // Now convert the Program into binary wire format for saving
-    std::string Data = CompilerOutput.program().SerializeAsString();
+    const FString Data(CompilerOutput.program().SerializeAsString().c_str());
+    const int32 DataSize = Data.Len();
 
     // And convert THAT into a TArray of bytes for storage
-    TArray<uint8> Output = TArray<uint8>((const uint8*)Data.c_str(), Data.size());
+    TArray<uint8> Output;
+    Output.AddUninitialized(DataSize);
+    StringToBytes(Data, Output.GetData(), DataSize);
 
     YarnProject->Data = Output;