diff --git a/src/editor/editor_cache.cpp b/src/editor/editor_cache.cpp
new file mode 100644
index 00000000..b3b44b7e
--- /dev/null
+++ b/src/editor/editor_cache.cpp
@@ -0,0 +1,133 @@
+// This file is part of the Godot Orchestrator project.
+//
+// Copyright (c) 2023-present Vahera Studios LLC and its contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//		http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "editor/editor_cache.h"
+#include "plugins/orchestrator_editor_debugger_plugin.h"
+#include "plugins/orchestrator_editor_plugin.h"
+
+#include <godot_cpp/classes/editor_paths.hpp>
+
+#if GODOT_VERSION >= 0x040300
+PackedInt64Array OrchestratorEditorCache::_get_breakpoints_for_path(const String& p_path, bool p_disabled) const
+{
+    return _cache->get_value(p_path, p_disabled ? "disabled_breakpoints" : "breakpoints", PackedInt64Array());
+}
+#endif
+
+Error OrchestratorEditorCache::load()
+{
+    const EditorInterface* ei = OrchestratorPlugin::get_singleton()->get_editor_interface();
+
+    _cache = Ref<ConfigFile>(memnew(ConfigFile));
+
+    Error result = _cache->load(ei->get_editor_paths()->get_project_settings_dir().path_join(CACHE_FILE));
+    if (result != OK)
+        return result;
+
+    #if GODOT_VERSION >= 0x040300
+    if (OrchestratorEditorDebuggerPlugin* debugger = OrchestratorEditorDebuggerPlugin::get_singleton())
+    {
+        for (const String& section : _cache->get_sections())
+        {
+            if (_cache->has_section_key(section, "breakpoints"))
+            {
+                PackedInt64Array breakpoints = _get_breakpoints_for_path(section, false);
+                for (int i = 0; i < breakpoints.size(); i++)
+                    debugger->set_breakpoint(section, breakpoints[i], true);
+            }
+            if (_cache->has_section_key(section, "disabled_breakpoints"))
+            {
+                PackedInt64Array disabled_breakpoints = _get_breakpoints_for_path(section, true);
+                for (int i = 0; i < disabled_breakpoints.size(); i++)
+                    debugger->set_breakpoint(section, disabled_breakpoints[i], true);
+            }
+        }
+    }
+    #endif
+
+    return OK;
+}
+
+Error OrchestratorEditorCache::save()
+{
+    if (_cache.is_valid())
+    {
+        const EditorInterface* ei = OrchestratorPlugin::get_singleton()->get_editor_interface();
+        return _cache->save(ei->get_editor_paths()->get_project_settings_dir().path_join(CACHE_FILE));
+    }
+
+    return ERR_FILE_CANT_WRITE;
+}
+
+#if GODOT_VERSION >= 0x040300
+void OrchestratorEditorCache::clear_all_breakpoints()
+{
+    for (const String& section : _cache->get_sections())
+    {
+        PackedInt64Array breakpoints = _get_breakpoints_for_path(section, false);
+        if (!breakpoints.is_empty())
+            _cache->set_value(section, "breakpoints", Variant());
+
+        PackedInt64Array disabled_breakpoints = _get_breakpoints_for_path(section, true);
+        if (!disabled_breakpoints.is_empty())
+            _cache->set_value(section, "disabled_breakpoints", Variant());
+    }
+}
+
+bool OrchestratorEditorCache::is_node_breakpoint(const String& p_path, int p_node_id) const
+{
+    return _get_breakpoints_for_path(p_path, false).has(p_node_id);
+}
+
+bool OrchestratorEditorCache::is_node_disabled_breakpoint(const String& p_path, int p_node_id) const
+{
+    return _get_breakpoints_for_path(p_path, true).has(p_node_id);
+}
+
+void OrchestratorEditorCache::set_breakpoint(const String& p_path, int p_node_id, bool p_enabled)
+{
+    PackedInt64Array breakpoints = _get_breakpoints_for_path(p_path, false);
+    if (p_enabled && !breakpoints.has(p_node_id))
+    {
+        breakpoints.push_back(p_node_id);
+        _cache->set_value(p_path, "breakpoints", breakpoints);
+    }
+    else if (!p_enabled && breakpoints.has(p_node_id))
+    {
+        breakpoints.remove_at(breakpoints.find(p_node_id));
+        _cache->set_value(p_path, "breakpoints", breakpoints);
+    }
+}
+
+void OrchestratorEditorCache::set_disabled_breakpoint(const String& p_path, int p_node_id, bool p_remove)
+{
+    PackedInt64Array breakpoints = _get_breakpoints_for_path(p_path, true);
+    if (p_remove && breakpoints.has(p_node_id))
+    {
+        breakpoints.remove_at(breakpoints.find(p_node_id));
+        _cache->set_value(p_path, "disabled_breakpoints", breakpoints);
+    }
+    else if (!p_remove && !breakpoints.has(p_node_id))
+    {
+        breakpoints.push_back(p_node_id);
+        _cache->set_value(p_path, "disabled_breakpoints", breakpoints);
+    }
+}
+#endif
+
+void OrchestratorEditorCache::_bind_methods()
+{
+}
\ No newline at end of file
diff --git a/src/editor/editor_cache.h b/src/editor/editor_cache.h
new file mode 100644
index 00000000..d36d482b
--- /dev/null
+++ b/src/editor/editor_cache.h
@@ -0,0 +1,85 @@
+// This file is part of the Godot Orchestrator project.
+//
+// Copyright (c) 2023-present Vahera Studios LLC and its contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//		http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef ORCHESTRATOR_EDITOR_CACHE_H
+#define ORCHESTRATOR_EDITOR_CACHE_H
+
+#include "common/version.h"
+
+#include <godot_cpp/classes/config_file.hpp>
+#include <godot_cpp/classes/ref_counted.hpp>
+
+using namespace godot;
+
+/// A simple cache that maintains editor state details for Orchestrator.
+class OrchestratorEditorCache : public RefCounted
+{
+    GDCLASS(OrchestratorEditorCache, RefCounted);
+    static void _bind_methods();
+
+protected:
+    const String CACHE_FILE = "orchestrator_editor_cache.cfg";  //! The cache file name
+    Ref<ConfigFile> _cache;                                     //! Cache file
+
+    #if GODOT_VERSION >= 0x040300
+    /// Get breakpoints for the specified path
+    /// @param p_path the path
+    /// @param p_disabled when true, returns disabled breakpoints, false returns enabled breakpoints
+    /// @return array of breakpoints
+    PackedInt64Array _get_breakpoints_for_path(const String& p_path, bool p_disabled) const;
+    #endif
+
+public:
+    /// Loads the script editor cache from disk.
+    /// @return the error code based on the load operation
+    Error load();
+
+    /// Saves the script editor cache to disk.
+    /// @return the error code based on the save operation
+    Error save();
+
+    #if GODOT_VERSION >= 0x040300
+    /// Clears all breakpoints
+    void clear_all_breakpoints();
+
+    /// Check whether the node in a script is a breakpoint
+    /// @param p_path the script path
+    /// @param p_node_id the node id
+    /// @return true if the node is a breakpoint, false otherwise
+    bool is_node_breakpoint(const String& p_path, int p_node_id) const;
+
+    /// Check whether the node in a script is a breakpoint and is disabled
+    /// @param p_path the script path
+    /// @param p_node_id the node id
+    /// @return true if the node is a breakpoint that is disabled, false otherwise
+    bool is_node_disabled_breakpoint(const String& p_path, int p_node_id) const;
+
+    /// Set whether a breakpoint is enabled
+    /// @param p_path the script path
+    /// @param p_node_id the node id
+    /// @param p_enabled whether the breakpoint is enabled or disabled
+    void set_breakpoint(const String& p_path, int p_node_id, bool p_enabled);
+
+    /// Set the breakpoint as disabled
+    /// @param p_path the script path
+    /// @param p_node_id the node id
+    /// @param p_remove whether to remove the disabled entry
+    void set_disabled_breakpoint(const String& p_path, int p_node_id, bool p_remove = false);
+    #endif
+
+};
+
+#endif // ORCHESTRATOR_EDITOR_CACHE_H
\ No newline at end of file
diff --git a/src/editor/editor_panel.cpp b/src/editor/editor_panel.cpp
index fbc31570..4735026b 100644
--- a/src/editor/editor_panel.cpp
+++ b/src/editor/editor_panel.cpp
@@ -157,10 +157,31 @@ void OrchestratorEditorPanel::_update_scene_tab_signals(bool p_connect)
     if (p_connect)
     {
         OCONNECT(scene_tabs, "tab_changed", callable_mp(this, &OrchestratorEditorPanel::_scene_tab_changed));
+
+        #if GODOT_VERSION >= 0x040300
+        OrchestratorEditorDebuggerPlugin* debugger = OrchestratorEditorDebuggerPlugin::get_singleton();
+        if (debugger)
+        {
+            OCONNECT(debugger, "goto_script_line", callable_mp(this, &OrchestratorEditorPanel::_goto_script_line));
+            OCONNECT(debugger, "breakpoints_cleared_in_tree", callable_mp(this, &OrchestratorEditorPanel::_clear_all_breakpoints));
+            OCONNECT(debugger, "breakpoint_set_in_tree", callable_mp(this, &OrchestratorEditorPanel::_set_breakpoint));
+        }
+        #endif
+
         return;
     }
 
     ODISCONNECT(scene_tabs, "tab_changed", callable_mp(this, &OrchestratorEditorPanel::_scene_tab_changed));
+
+    #if GODOT_VERSION >= 0x040300
+    OrchestratorEditorDebuggerPlugin* debugger = OrchestratorEditorDebuggerPlugin::get_singleton();
+    if (debugger)
+    {
+        ODISCONNECT(debugger, "goto_script_line", callable_mp(this, &OrchestratorEditorPanel::_goto_script_line));
+        ODISCONNECT(debugger, "breakpoints_cleared_in_tree", callable_mp(this, &OrchestratorEditorPanel::_clear_all_breakpoints));
+        ODISCONNECT(debugger, "breakpoint_set_in_tree", callable_mp(this, &OrchestratorEditorPanel::_set_breakpoint));
+    }
+    #endif
 }
 
 void OrchestratorEditorPanel::_update_file_system_dock_signals(bool p_connect)
@@ -649,6 +670,53 @@ void OrchestratorEditorPanel::_folder_removed(const String& p_folder_name)
     }
 }
 
+#if GODOT_VERSION >= 0x040300
+void OrchestratorEditorPanel::_goto_script_line(const Ref<Script>& p_script, int p_line)
+{
+    if (p_script.is_valid())
+    {
+        for (const OrchestrationFile& file : _files_context.open_files)
+        {
+            if (file.file_name == p_script->get_path())
+            {
+                // Make plugin active
+                OrchestratorPlugin::get_singleton()->make_active();
+                // Show viewport
+                _show_editor_viewport(file.file_name);
+                // Goto node
+                file.viewport->goto_node(p_line + 1);
+                break;
+            }
+        }
+    }
+}
+
+void OrchestratorEditorPanel::_clear_all_breakpoints()
+{
+    // Clear all breakpoints in the script editors
+    for (const OrchestrationFile& file : _files_context.open_files)
+        file.viewport->clear_breakpoints();
+
+    // Clear cache breakpoints
+    OrchestratorPlugin::get_singleton()->get_editor_cache()->clear_all_breakpoints();
+}
+
+void OrchestratorEditorPanel::_set_breakpoint(const Ref<Script>& p_script, int p_line, bool p_enabled)
+{
+    const int node_id = p_line + 1;
+
+    Ref<OrchestratorEditorCache> cache = OrchestratorPlugin::get_singleton()->get_editor_cache();
+    cache->set_breakpoint(p_script->get_path(), node_id, p_enabled);
+    cache->set_disabled_breakpoint(p_script->get_path(), node_id, true); // todo: is this right?
+
+    for (const OrchestrationFile& file : _files_context.open_files)
+    {
+        if (file.viewport->is_same_script(p_script))
+            file.viewport->set_breakpoint(node_id, p_enabled);
+    }
+}
+#endif
+
 void OrchestratorEditorPanel::_window_changed(bool p_visible)
 {
     _select_separator->set_visible(!p_visible);
@@ -775,6 +843,16 @@ void OrchestratorEditorPanel::set_window_layout(const Ref<ConfigFile>& p_configu
     }
 }
 
+#if GODOT_VERSION >= 0x040300
+PackedStringArray OrchestratorEditorPanel::get_breakpoints() const
+{
+    PackedStringArray breakpoints;
+    for (const OrchestrationFile& file : _files_context.open_files)
+        breakpoints.append_array(file.viewport->get_breakpoints());
+    return breakpoints;
+}
+#endif
+
 void OrchestratorEditorPanel::_notification(int p_what)
 {
     switch(p_what)
diff --git a/src/editor/editor_panel.h b/src/editor/editor_panel.h
index 34c48d2a..c1579a8a 100644
--- a/src/editor/editor_panel.h
+++ b/src/editor/editor_panel.h
@@ -17,6 +17,8 @@
 #ifndef ORCHESTRATOR_EDITOR_PANEL_H
 #define ORCHESTRATOR_EDITOR_PANEL_H
 
+#include "common/version.h"
+
 #include <godot_cpp/classes/config_file.hpp>
 #include <godot_cpp/classes/file_dialog.hpp>
 #include <godot_cpp/classes/file_system_dock.hpp>
@@ -179,6 +181,12 @@ class OrchestratorEditorPanel : public PanelContainer
     void _file_moved(const String& p_old_file_name, const String& p_new_file_name);
     void _folder_removed(const String& p_folder_name);
 
+    #if GODOT_VERSION >= 0x040300
+    void _goto_script_line(const Ref<Script>& p_script, int p_line);
+    void _clear_all_breakpoints();
+    void _set_breakpoint(const Ref<Script>& p_script, int p_line, bool p_enabled);
+    #endif
+
     /// Constructor, intentially protected
     OrchestratorEditorPanel() = default;
 
@@ -206,6 +214,12 @@ class OrchestratorEditorPanel : public PanelContainer
     /// @param p_config the configuration to read from
     void set_window_layout(const Ref<ConfigFile>& p_config);
 
+    #if GODOT_VERSION >= 0x040300
+    /// Get all active, defined breakpoints
+    /// @return list of breakpoints
+    PackedStringArray get_breakpoints() const;
+    #endif
+
     /// Constructs the editor panel
     /// @param p_window_wrapper
     explicit OrchestratorEditorPanel(OrchestratorWindowWrapper* p_window_wrapper);
diff --git a/src/editor/editor_viewport.cpp b/src/editor/editor_viewport.cpp
index d2f70343..0f674323 100644
--- a/src/editor/editor_viewport.cpp
+++ b/src/editor/editor_viewport.cpp
@@ -19,6 +19,7 @@
 #include "common/scene_utils.h"
 #include "editor/graph/graph_edit.h"
 #include "orchestration/orchestration.h"
+#include "plugins/orchestrator_editor_debugger_plugin.h"
 #include "plugins/orchestrator_editor_plugin.h"
 
 #include <godot_cpp/classes/json.hpp>
@@ -275,6 +276,36 @@ bool OrchestratorEditorViewport::build(bool p_show_success)
     return true;
 }
 
+#if GODOT_VERSION >= 0x040300
+void OrchestratorEditorViewport::clear_breakpoints()
+{
+    OrchestratorEditorDebuggerPlugin* debugger = OrchestratorEditorDebuggerPlugin::get_singleton();
+    for (const Ref<OScriptNode>& node : _orchestration->get_nodes())
+    {
+        node->set_breakpoint_flag(OScriptNode::BREAKPOINT_NONE);
+        debugger->set_breakpoint(_orchestration->get_self()->get_path(), node->get_id(), false);
+    }
+}
+
+void OrchestratorEditorViewport::set_breakpoint(int p_node_id, bool p_enabled)
+{
+    const Ref<OScriptNode> node = _orchestration->get_node(p_node_id);
+    if (node.is_valid())
+        node->set_breakpoint_flag(p_enabled ? OScriptNode::BREAKPOINT_ENABLED : OScriptNode::BREAKPOINT_NONE);
+}
+
+PackedStringArray OrchestratorEditorViewport::get_breakpoints() const
+{
+    PackedStringArray breakpoints;
+    for (const Ref<OScriptNode>& node : _orchestration->get_nodes())
+    {
+        if (node->has_breakpoint())
+            breakpoints.push_back(vformat("%s:%d", _orchestration->get_self()->get_path(), node->get_id()));
+    }
+    return breakpoints;
+}
+#endif
+
 void OrchestratorEditorViewport::goto_node(int p_node_id)
 {
     Ref<OScriptNode> node = _orchestration->get_node(p_node_id);
diff --git a/src/editor/editor_viewport.h b/src/editor/editor_viewport.h
index 089cdc10..ae4becfb 100644
--- a/src/editor/editor_viewport.h
+++ b/src/editor/editor_viewport.h
@@ -17,6 +17,8 @@
 #ifndef ORCHESTRATOR_EDITOR_VIEWPORT_H
 #define ORCHESTRATOR_EDITOR_VIEWPORT_H
 
+#include "common/version.h"
+
 #include <godot_cpp/classes/accept_dialog.hpp>
 #include <godot_cpp/classes/h_split_container.hpp>
 #include <godot_cpp/classes/rich_text_label.hpp>
@@ -164,6 +166,20 @@ class OrchestratorEditorViewport : public HSplitContainer
     /// @return true if the build is successful, false otherwise
     bool build(bool p_show_success = false);
 
+    #if GODOT_VERSION >= 0x040300
+    /// Clear all breakpoints in the script view
+    void clear_breakpoints();
+
+    /// Sets the breakpoint status on the specified node
+    /// @param p_node_id the graph node id
+    /// @param p_enabled whether the breakpoint is enabled
+    void set_breakpoint(int p_node_id, bool p_enabled);
+
+    /// Get a list of breakpoints
+    /// @return the list of breakpoints for this script editor
+    PackedStringArray get_breakpoints() const;
+    #endif
+
     /// Focuses on the specified node
     /// @param p_node_id the node ID
     void goto_node(int p_node_id);
diff --git a/src/editor/graph/graph_node.cpp b/src/editor/graph/graph_node.cpp
index f13b7a0a..6adb7807 100644
--- a/src/editor/graph/graph_node.cpp
+++ b/src/editor/graph/graph_node.cpp
@@ -50,6 +50,10 @@ OrchestratorGraphNode::OrchestratorGraphNode(OrchestratorGraphEdit* p_graph, con
     set_v_size_flags(SIZE_EXPAND_FILL);
     set_meta("__script_node", p_node);
 
+    #if GODOT_VERSION >= 0x040300
+    _initialize_node_beakpoint_state();
+    #endif
+
     _update_tooltip();
 }
 
@@ -277,6 +281,26 @@ void OrchestratorGraphNode::_update_indicators()
         notification->set_tooltip_text("Node is experimental and behavior may change without notice.");
         _indicators->add_child(notification);
     }
+
+    #if GODOT_VERSION >= 0x040300
+    if (_node->has_breakpoint())
+    {
+        TextureRect* breakpoint = memnew(TextureRect);
+        breakpoint->set_custom_minimum_size(Vector2(0, 24));
+        breakpoint->set_stretch_mode(TextureRect::STRETCH_KEEP_ASPECT_CENTERED);
+        if (!_node->has_disabled_breakpoint())
+        {
+            breakpoint->set_texture(SceneUtils::get_editor_icon("DebugSkipBreakpointsOff"));
+            breakpoint->set_tooltip_text("Debugger will break when processing this node");
+        }
+        else
+        {
+            breakpoint->set_texture(SceneUtils::get_editor_icon("DebugSkipBreakpointsOn"));
+            breakpoint->set_tooltip_text("Debugger will skip the breakpoint when processing this node");
+        }
+        _indicators->add_child(breakpoint);
+    }
+    #endif
 }
 
 void OrchestratorGraphNode::_update_titlebar()
@@ -446,11 +470,18 @@ void OrchestratorGraphNode::_show_context_menu(const Vector2& p_position)
     if (!call_script_function.is_valid())
         _context_menu->set_item_disabled(_context_menu->get_item_index(CM_EXPAND_NODE), true);
 
-
-    // todo: support breakpoints (See Trello)
-    // _context_menu->add_separator("Breakpoints");
-    // _context_menu->add_item("Toggle Breakpoint", CM_TOGGLE_BREAKPOINT, KEY_F9);
-    // _context_menu->add_item("Add Breakpoint", CM_ADD_BREAKPOINT);
+    #if GODOT_VERSION >= 0x040300
+    _context_menu->add_separator("Breakpoints");
+    _context_menu->add_item("Toggle Breakpoint", CM_TOGGLE_BREAKPOINT, KEY_F9);
+    if (_node->has_breakpoint())
+    {
+        _context_menu->add_item("Remove breakpoint", CM_REMOVE_BREAKPOINT);
+        if (_node->has_disabled_breakpoint())
+            _context_menu->add_item("Enable breakpoint", CM_ADD_BREAKPOINT);
+        else
+            _context_menu->add_item("Disable breakpoint", CM_DISABLE_BREAKPOINT);
+    }
+    #endif
 
     _context_menu->add_separator("Documentation");
     _context_menu->add_icon_item(SceneUtils::get_editor_icon("Help"), "View Documentation", CM_VIEW_DOCUMENTATION);
@@ -470,6 +501,46 @@ void OrchestratorGraphNode::_simulate_action_pressed(const String& p_action_name
     get_graph()->execute_action(p_action_name);
 }
 
+#if GODOT_VERSION >= 0x040300
+void OrchestratorGraphNode::_initialize_node_beakpoint_state()
+{
+    Ref<OrchestratorEditorCache> cache = OrchestratorPlugin::get_singleton()->get_editor_cache();
+    if (cache.is_valid())
+    {
+        const String path = _node->get_orchestration()->get_self()->get_path();
+        #if GODOT_VERSION >= 0x040300
+        const bool disabled = cache->is_node_disabled_breakpoint(path, _node->get_id());
+        const bool enabled  = cache->is_node_breakpoint(path, _node->get_id());
+        if (disabled || enabled)
+            _set_breakpoint_state(disabled ? OScriptNode::BREAKPOINT_DISABLED : OScriptNode::BREAKPOINT_ENABLED);
+        else
+            _set_breakpoint_state(OScriptNode::BREAKPOINT_NONE);
+        #endif
+    }
+}
+
+void OrchestratorGraphNode::_set_breakpoint_state(OScriptNode::BreakpointFlags p_flag)
+{
+    _node->set_breakpoint_flag(p_flag);
+
+    OrchestratorEditorDebuggerPlugin* debugger = OrchestratorEditorDebuggerPlugin::get_singleton();
+    if (!debugger)
+        return;
+
+    const int node_id = _node->get_id();
+    const String path = _node->get_orchestration()->get_self()->get_path();
+
+    debugger->set_breakpoint(path, node_id, p_flag != OScriptNode::BreakpointFlags::BREAKPOINT_NONE);
+
+    Ref<OrchestratorEditorCache> cache = OrchestratorPlugin::get_singleton()->get_editor_cache();
+    if (cache.is_valid())
+    {
+        cache->set_breakpoint(path, node_id, p_flag == OScriptNode::BreakpointFlags::BREAKPOINT_ENABLED);
+        cache->set_disabled_breakpoint(path, node_id, p_flag != OScriptNode::BreakpointFlags::BREAKPOINT_DISABLED);
+    }
+}
+#endif
+
 void OrchestratorGraphNode::_on_changed()
 {
     // Notifications can bubble up to the OrchestratorGraphNode from either the OrchestratorGraphNodePin
@@ -671,6 +742,39 @@ void OrchestratorGraphNode::_on_context_menu_selection(int p_id)
                 get_graph()->emit_signal("expand_node", _node->get_id());
                 break;
             }
+            #if GODOT_VERSION >= 0x040300
+            case CM_TOGGLE_BREAKPOINT:
+            {
+                // An OScriptNode registers the breakpoint data from the current open session.
+                // This data is transient and is lost across restarts, although GDScript persists
+                // this and we should implement this too.
+                //
+                // What we need to integrate with is EditorDebugNode. It is what will be responsible
+                // for coordinating the breakpoint communication with the EngineDebugger that runs
+                // in the separate prcoess that runs the game in F5. It uses Local/Remove debuggers.
+                if (_node->has_breakpoint())
+                    _set_breakpoint_state(OScriptNode::BreakpointFlags::BREAKPOINT_NONE);
+                else
+                    _set_breakpoint_state(OScriptNode::BreakpointFlags::BREAKPOINT_ENABLED);
+                break;
+            }
+            case CM_ADD_BREAKPOINT:
+            case CM_ENABLE_BREAKPOINT:
+            {
+                _set_breakpoint_state(OScriptNode::BreakpointFlags::BREAKPOINT_ENABLED);
+                break;
+            }
+            case CM_REMOVE_BREAKPOINT:
+            {
+                _set_breakpoint_state(OScriptNode::BreakpointFlags::BREAKPOINT_NONE);
+                break;
+            }
+            case CM_DISABLE_BREAKPOINT:
+            {
+                _set_breakpoint_state(OScriptNode::BreakpointFlags::BREAKPOINT_DISABLED);
+                break;
+            }
+            #endif
             #ifdef _DEBUG
             case CM_SHOW_DETAILS:
             {
diff --git a/src/editor/graph/graph_node.h b/src/editor/graph/graph_node.h
index 4adb66b6..d74c5a94 100644
--- a/src/editor/graph/graph_node.h
+++ b/src/editor/graph/graph_node.h
@@ -17,6 +17,7 @@
 #ifndef ORCHESTRATOR_GRAPH_NODE_H
 #define ORCHESTRATOR_GRAPH_NODE_H
 
+#include "common/version.h"
 #include "script/node.h"
 
 #include <godot_cpp/classes/graph_node.hpp>
@@ -57,6 +58,9 @@ class OrchestratorGraphNode : public GraphNode
         CM_RENAME,
         CM_TOGGLE_BREAKPOINT,
         CM_ADD_BREAKPOINT,
+        CM_ENABLE_BREAKPOINT,
+        CM_REMOVE_BREAKPOINT,
+        CM_DISABLE_BREAKPOINT,
         CM_VIEW_DOCUMENTATION,
         CM_COLLAPSE_FUNCTION,
         CM_EXPAND_NODE,
@@ -207,6 +211,15 @@ class OrchestratorGraphNode : public GraphNode
     /// @param p_action_name the action to simulate
     void _simulate_action_pressed(const String& p_action_name);
 
+    #if GODOT_VERSION >= 0x040300
+    /// Initializes the node's breakpoint state
+    void _initialize_node_beakpoint_state();
+
+    /// Set the breakpoint state
+    /// @param p_flag the breakpoint flag state
+    void _set_breakpoint_state(OScriptNode::BreakpointFlags p_flag);
+    #endif
+
 private:
     /// Called when the graph node is moved
     /// @param p_old_pos old position
diff --git a/src/editor/plugins/orchestrator_editor_debugger_plugin.cpp b/src/editor/plugins/orchestrator_editor_debugger_plugin.cpp
new file mode 100644
index 00000000..36c59d10
--- /dev/null
+++ b/src/editor/plugins/orchestrator_editor_debugger_plugin.cpp
@@ -0,0 +1,97 @@
+// This file is part of the Godot Orchestrator project.
+//
+// Copyright (c) 2023-present Vahera Studios LLC and its contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//		http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "editor/plugins/orchestrator_editor_debugger_plugin.h"
+
+#if GODOT_VERSION >= 0x040300
+OrchestratorEditorDebuggerPlugin* OrchestratorEditorDebuggerPlugin::_singleton = nullptr;
+
+void OrchestratorEditorDebuggerPlugin::_session_started(int32_t p_session_id)
+{
+    // Session id is 0, when game starts.
+}
+
+void OrchestratorEditorDebuggerPlugin::_session_stopped(int32_t p_session_id)
+{
+    // Session id is 0, when game ends.
+}
+
+void OrchestratorEditorDebuggerPlugin::_session_breaked(int32_t p_session_id)
+{
+    // Always reports session id with 1 when breakpoints happen
+}
+
+void OrchestratorEditorDebuggerPlugin::_session_continued(int32_t p_session_id)
+{
+    // Reports continuation of breakpoints with session id 0
+    // Why is there a disconnect between break and continue?
+}
+
+void OrchestratorEditorDebuggerPlugin::_setup_session(int32_t p_session_id)
+{
+    Ref<EditorDebuggerSession> session = get_session(p_session_id);
+    if (session.is_valid())
+    {
+        _current_session = session;
+
+        session->connect("started", callable_mp(this, &OrchestratorEditorDebuggerPlugin::_session_started).bind(p_session_id));
+        session->connect("stopped", callable_mp(this, &OrchestratorEditorDebuggerPlugin::_session_stopped).bind(p_session_id));
+        session->connect("breaked", callable_mp(this, &OrchestratorEditorDebuggerPlugin::_session_breaked).bind(p_session_id));
+        session->connect("continued", callable_mp(this, &OrchestratorEditorDebuggerPlugin::_session_continued).bind(p_session_id));
+    }
+}
+
+void OrchestratorEditorDebuggerPlugin::_goto_script_line(const Ref<Script>& p_script, int p_line)
+{
+    emit_signal("goto_script_line", p_script, p_line);
+}
+
+void OrchestratorEditorDebuggerPlugin::_breakpoints_cleared_in_tree()
+{
+    emit_signal("breakpoints_cleared_in_tree");
+}
+
+void OrchestratorEditorDebuggerPlugin::_breakpoint_set_in_tree(const Ref<Script>& p_script, int p_line, bool p_enabled)
+{
+    emit_signal("breakpoint_set_in_tree", p_script, p_line, p_enabled);
+}
+
+void OrchestratorEditorDebuggerPlugin::set_breakpoint(const String& p_file, int32_t p_line, bool p_enabled)
+{
+    // todo: find a way to pass session id to this call
+    if (!_current_session.is_valid())
+        return;
+
+    _current_session->set_breakpoint(p_file, p_line, p_enabled);
+}
+
+void OrchestratorEditorDebuggerPlugin::_bind_methods()
+{
+    ADD_SIGNAL(MethodInfo("goto_script_line", PropertyInfo(Variant::OBJECT, "script"), PropertyInfo(Variant::INT, "line")));
+    ADD_SIGNAL(MethodInfo("breakpoints_cleared_in_tree"));
+    ADD_SIGNAL(MethodInfo("breakpoint_set_in_tree", PropertyInfo(Variant::OBJECT, "script"), PropertyInfo(Variant::INT, "line"), PropertyInfo(Variant::BOOL, "enabled")));
+}
+
+OrchestratorEditorDebuggerPlugin::OrchestratorEditorDebuggerPlugin()
+{
+    _singleton = this;
+}
+
+OrchestratorEditorDebuggerPlugin::~OrchestratorEditorDebuggerPlugin()
+{
+    _singleton = nullptr;
+}
+#endif
\ No newline at end of file
diff --git a/src/editor/plugins/orchestrator_editor_debugger_plugin.h b/src/editor/plugins/orchestrator_editor_debugger_plugin.h
new file mode 100644
index 00000000..336bfe38
--- /dev/null
+++ b/src/editor/plugins/orchestrator_editor_debugger_plugin.h
@@ -0,0 +1,73 @@
+// This file is part of the Godot Orchestrator project.
+//
+// Copyright (c) 2023-present Vahera Studios LLC and its contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//		http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef ORCHESTRATOR_EDITOR_DEBUGGER_PLUGIN_H
+#define ORCHESTRATOR_EDITOR_DEBUGGER_PLUGIN_H
+
+#include "common/version.h"
+
+#if GODOT_VERSION >= 0x040300
+#include <godot_cpp/classes/editor_debugger_plugin.hpp>
+#include <godot_cpp/classes/editor_debugger_session.hpp>
+#include <godot_cpp/classes/script.hpp>
+#include <godot_cpp/templates/hash_map.hpp>
+
+using namespace godot;
+
+/// Provides Orchestrator with Godot editor debugger integration
+class OrchestratorEditorDebuggerPlugin : public EditorDebuggerPlugin
+{
+    GDCLASS(OrchestratorEditorDebuggerPlugin, EditorDebuggerPlugin);
+    static void _bind_methods();
+
+protected:
+    static OrchestratorEditorDebuggerPlugin* _singleton;  //! Singleton instance
+    Ref<EditorDebuggerSession> _current_session;          //! Current debugger session
+
+    //~ Begin Signal Handlers
+    void _session_started(int32_t p_session_id);
+    void _session_stopped(int32_t p_session_id);
+    void _session_breaked(int32_t p_session_id);
+    void _session_continued(int32_t p_session_id);
+    //~ End Signal Handlers
+
+public:
+    //~ Begin EditorDebuggerPlugin Interface
+    void _setup_session(int32_t p_session_id) override;
+    void _goto_script_line(const Ref<Script>& p_script, int p_line) override;
+    void _breakpoints_cleared_in_tree() override;
+    void _breakpoint_set_in_tree(const Ref<Script>& p_script, int p_line, bool p_enabled) override;
+    //~ End EditorDebuggerPlugin Interface
+
+    /// Get the singleton instance for this plugin
+    /// @return the singleton instance
+    static OrchestratorEditorDebuggerPlugin* get_singleton() { return _singleton; }
+
+    /// Set a specific breakpoint state for a given script file and line number
+    /// @param p_file the script file
+    /// @param p_line the line number, mapped to an Orchestrator script node ID
+    /// @param p_enabled whether the breakpoint is enabled
+    void set_breakpoint(const String& p_file, int32_t p_line, bool p_enabled);
+
+    /// Constructor
+    OrchestratorEditorDebuggerPlugin();
+
+    /// Destructor
+    ~OrchestratorEditorDebuggerPlugin() override;
+};
+#endif
+
+#endif  // ORCHESTRATOR_EDITOR_DEBUGGER_PLUGIN_H
\ No newline at end of file
diff --git a/src/editor/plugins/orchestrator_editor_plugin.cpp b/src/editor/plugins/orchestrator_editor_plugin.cpp
index 2b68d55f..aee0fde0 100644
--- a/src/editor/plugins/orchestrator_editor_plugin.cpp
+++ b/src/editor/plugins/orchestrator_editor_plugin.cpp
@@ -66,11 +66,19 @@ void OrchestratorPlugin::_notification(int p_what)
         for (const Ref<EditorExportPlugin>& plugin : _export_plugins)
             add_export_plugin(plugin);
 
+        #if GODOT_VERSION >= 0x040300
+        _debugger_plugin.instantiate();
+        add_debugger_plugin(_debugger_plugin);
+        #endif
+
         // Register the plugin's icon for CreateScript Dialog
         Ref<Theme> theme = ThemeDB::get_singleton()->get_default_theme();
         if (theme.is_valid() && !theme->has_icon(_get_plugin_name(), "EditorIcons"))
             theme->set_icon(_get_plugin_name(), "EditorIcons", _get_plugin_icon());
 
+        _editor_cache.instantiate();
+        _editor_cache->load();
+
         _window_wrapper = memnew(OrchestratorWindowWrapper);
         _window_wrapper->set_window_title(vformat("Orchestrator - Godot Engine"));
         _window_wrapper->set_margins_enabled(true);
@@ -212,6 +220,11 @@ void OrchestratorPlugin::save_metadata(const Ref<ConfigFile>& p_metadata)
     p_metadata->save(file);
 }
 
+void OrchestratorPlugin::make_active()
+{
+    _editor.set_main_screen_editor(_get_plugin_name());
+}
+
 void OrchestratorPlugin::request_editor_restart()
 {
     AcceptDialog* request = memnew(AcceptDialog);
@@ -239,6 +252,9 @@ void OrchestratorPlugin::_apply_changes()
 {
     if (_editor_panel)
         _editor_panel->apply_changes();
+
+    if (_editor_cache.is_valid())
+        _editor_cache->save();
 }
 
 void OrchestratorPlugin::_set_window_layout(const Ref<ConfigFile>& p_configuration)
@@ -300,6 +316,18 @@ void OrchestratorPlugin::_disable_plugin()
 {
 }
 
+PackedStringArray OrchestratorPlugin::_get_breakpoints() const
+{
+    #if GODOT_VERSION >= 0x040300
+    // When the game is started with the debugger, it uses this method to gather all breakpoints,
+    // and these are passed to the CLI of the game process. this should obtain all breakpoints
+    // currently set and return them using the format of "<script_file>:<node_id>".
+    return _editor_panel->get_breakpoints();
+    #else
+    return PackedStringArray();
+    #endif
+}
+
 void OrchestratorPlugin::_on_window_visibility_changed(bool p_visible)
 {
     // todo: see script_editor_plugin.cpp
diff --git a/src/editor/plugins/orchestrator_editor_plugin.h b/src/editor/plugins/orchestrator_editor_plugin.h
index 298fdad0..6913d44a 100644
--- a/src/editor/plugins/orchestrator_editor_plugin.h
+++ b/src/editor/plugins/orchestrator_editor_plugin.h
@@ -17,6 +17,8 @@
 #ifndef ORCHESTRATOR_EDITOR_PLUGIN_H
 #define ORCHESTRATOR_EDITOR_PLUGIN_H
 
+#include "editor/editor_cache.h"
+#include "editor/plugins/orchestrator_editor_debugger_plugin.h"
 #include "editor/theme/theme_cache.h"
 
 #include <godot_cpp/classes/config_file.hpp>
@@ -47,6 +49,10 @@ class OrchestratorPlugin : public EditorPlugin
     Vector<Ref<EditorInspectorPlugin>> _inspector_plugins;
     Vector<Ref<EditorExportPlugin>> _export_plugins;
     Ref<OrchestratorThemeCache> _theme_cache;
+    Ref<OrchestratorEditorCache> _editor_cache;               //! Script editor cache
+    #if GODOT_VERSION >= 0x040300
+    Ref<OrchestratorEditorDebuggerPlugin> _debugger_plugin;   //! Debugger plugin
+    #endif
 
 public:
     /// Constructor
@@ -90,7 +96,11 @@ class OrchestratorPlugin : public EditorPlugin
     /// @param p_metadata the metadata to save
     void save_metadata(const Ref<ConfigFile>& p_metadata);
 
+    /// Makes this plugin's view active, if it isn't already.
+    void make_active();
+
     Ref<OrchestratorThemeCache> get_theme_cache() { return _theme_cache; }
+    Ref<OrchestratorEditorCache> get_editor_cache() { return _editor_cache; }
 
     //~ Begin EditorPlugin interface
     String get_plugin_version() const;
@@ -106,6 +116,7 @@ class OrchestratorPlugin : public EditorPlugin
     bool _build() override;
     void _enable_plugin() override;
     void _disable_plugin() override;
+    PackedStringArray _get_breakpoints() const override;
     //~ End EditorPlugin interface
 
     /// Get the editor inspector plugin by type
diff --git a/src/editor/register_editor_types.cpp b/src/editor/register_editor_types.cpp
index 987bd3db..47b1c977 100644
--- a/src/editor/register_editor_types.cpp
+++ b/src/editor/register_editor_types.cpp
@@ -55,10 +55,14 @@ void register_editor_types()
 {
     // Plugin bits
     ORCHESTRATOR_REGISTER_CLASS(OrchestratorPlugin)
+    #if GODOT_VERSION >= 0x040300
+    ORCHESTRATOR_REGISTER_CLASS(OrchestratorEditorDebuggerPlugin)
+    #endif
     ORCHESTRATOR_REGISTER_CLASS(OrchestratorEditorExportPlugin)
     ORCHESTRATOR_REGISTER_CLASS(OrchestratorEditorInspectorPluginVariable)
     ORCHESTRATOR_REGISTER_CLASS(OrchestratorEditorPropertyVariableClassification)
     ORCHESTRATOR_REGISTER_CLASS(OrchestratorThemeCache)
+    ORCHESTRATOR_REGISTER_CLASS(OrchestratorEditorCache)
 
     // Editor bits
     ORCHESTRATOR_REGISTER_INTERNAL_CLASS(OrchestratorFileDialog)
diff --git a/src/script/instances/node_instance.h b/src/script/instances/node_instance.h
index e145e465..f2cf7f3a 100644
--- a/src/script/instances/node_instance.h
+++ b/src/script/instances/node_instance.h
@@ -42,6 +42,7 @@ class OScriptVirtualMachine;
 class OScriptNodeInstance : public Object
 {
     friend class OScriptInstance;
+    friend class OScriptLanguage;
     friend class OScriptVirtualMachine;
 
 public:
diff --git a/src/script/instances/script_instance.cpp b/src/script/instances/script_instance.cpp
index 046c70e4..102fb4a6 100644
--- a/src/script/instances/script_instance.cpp
+++ b/src/script/instances/script_instance.cpp
@@ -266,5 +266,5 @@ OScriptInstance* OScriptInstance::from_object(GDExtensionObjectPtr p_object)
 void OScriptInstance::call(const StringName& p_method, const Variant* const* p_args, GDExtensionInt p_arg_count,
                            Variant* r_return, GDExtensionCallError* r_err)
 {
-    _vm.call_method(p_method, p_args, p_arg_count, r_return, r_err);
+    _vm.call_method(this, p_method, p_args, p_arg_count, r_return, r_err);
 }
diff --git a/src/script/instances/script_instance.h b/src/script/instances/script_instance.h
index e512808d..9517a451 100644
--- a/src/script/instances/script_instance.h
+++ b/src/script/instances/script_instance.h
@@ -40,12 +40,15 @@ class OScriptState;
 ///
 class OScriptInstance : public OScriptInstanceBase
 {
+    friend class OScript;
+    friend class OScriptLanguage;
     friend class OScriptState;
 
     Ref<OScript> _script;                       //! The script this instance represents
     Object* _owner{ nullptr };                  //! The owning object of the script
     OScriptLanguage* _language{ nullptr };      //! The language the script represents
     OScriptVirtualMachine _vm;                  //! The virtual machine instance
+    void* _script_instance{ nullptr };          //! Godot script instance
 
 public:
     /// Defines details about the script instance to be passed to Godot
diff --git a/src/script/language.cpp b/src/script/language.cpp
index fe917c11..fbd04dcf 100644
--- a/src/script/language.cpp
+++ b/src/script/language.cpp
@@ -21,9 +21,13 @@
 #include "common/settings.h"
 #include "common/string_utils.h"
 #include "script/script.h"
+#include "script/vm/script_vm.h"
 
 #include <godot_cpp/classes/engine.hpp>
 #include <godot_cpp/classes/engine_debugger.hpp>
+#if GODOT_VERSION >= 0x040300
+  #include <godot_cpp/classes/os.hpp>
+#endif
 #ifdef TOOLS_ENABLED
   #include <godot_cpp/core/mutex_lock.hpp>
 #endif
@@ -40,6 +44,14 @@ OScriptLanguage::OScriptLanguage()
 OScriptLanguage::~OScriptLanguage()
 {
     _singleton = nullptr;
+
+    #if GODOT_VERSION >= 0x040300
+    if (_call_stack)
+    {
+        memdelete_arr(_call_stack);
+        _call_stack = nullptr;
+    }
+    #endif
 }
 
 OScriptLanguage* OScriptLanguage::get_singleton()
@@ -79,6 +91,21 @@ void OScriptLanguage::_init()
         if (format.match("Binary"))
             _extension = ORCHESTRATOR_SCRIPT_EXTENSION;
     }
+
+    #if GODOT_VERSION >= 0x040300
+    if (EngineDebugger::get_singleton()->is_active())
+    {
+        OrchestratorSettings* os = OrchestratorSettings::get_singleton();
+        int max_call_stack = os->get_setting("settings/runtime/max_call_stack", 1024);
+        _debug_max_call_stack = max_call_stack;
+        _call_stack = memnew_arr(CallStack, _debug_max_call_stack + 1);
+    }
+    else
+    {
+        _debug_max_call_stack = 0;
+        _call_stack = nullptr;
+    }
+    #endif
 }
 
 String OScriptLanguage::_get_name() const
@@ -329,9 +356,192 @@ void OScriptLanguage::_finish()
 {
 }
 
+#if GODOT_VERSION >= 0x040300
+String OScriptLanguage::_debug_get_stack_level_source(int32_t p_level) const
+{
+    if (_debug_parse_err_line >= 0)
+        return _debug_parse_err_file;
+
+    ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, {});
+    int l = _debug_call_stack_pos - p_level - 1;
+    return _call_stack[l].instance->get_script()->get_path();
+}
+
+int32_t OScriptLanguage::_debug_get_stack_level_line(int32_t p_level) const
+{
+    if (_debug_parse_err_line >= 0)
+        return _debug_parse_err_line;
+
+    ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, -1);
+    int l = _debug_call_stack_pos - p_level - 1;
+    return *_call_stack[l].id;
+}
+
+String OScriptLanguage::_debug_get_stack_level_function(int32_t p_level) const
+{
+    if (_debug_parse_err_line >= 0)
+        return {};
+
+    ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, {});
+    int l = _debug_call_stack_pos - p_level - 1;
+    return *(_call_stack[l].current_function);
+}
+
+void* OScriptLanguage::_debug_get_stack_level_instance(int32_t p_level)
+{
+    if (_debug_parse_err_line >= 0)
+         return nullptr;
+
+    ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, nullptr);
+    int l = _debug_call_stack_pos - p_level - 1;
+    return _call_stack[l].instance->_script_instance;
+}
+
+Dictionary OScriptLanguage::_debug_get_stack_level_members(int32_t p_level, int32_t p_max_subitems, int32_t p_max_depth)
+{
+    if (_debug_parse_err_line >= 0)
+        return {};
+
+    ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, {});
+    int l =_debug_call_stack_pos - p_level - 1;
+
+    Ref<OScript> script = _call_stack[l].instance->get_script();
+    if (!script.is_valid())
+        return {};
+
+    PackedStringArray member_names;
+    Array member_values;
+
+    for (const String& variable_name: script->get_variable_names())
+    {
+        Variant value;
+        if (_call_stack[l].instance->get_variable(variable_name, value))
+        {
+            member_names.push_back("Variables/" + variable_name);
+            member_values.push_back(value);
+        }
+    }
+
+    Dictionary members;
+    members["members"] = member_names;
+    members["values"] = member_values;
+
+    return members;
+}
+
+Dictionary OScriptLanguage::_debug_get_stack_level_locals(int32_t p_level, int32_t p_max_subitems, int32_t p_max_depth)
+{
+    if (_debug_parse_err_line >= 0)
+        return {};
+
+    ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, {});
+
+    int l =_debug_call_stack_pos - p_level - 1;
+    const StringName* function_name = _call_stack[l].current_function;
+    ERR_FAIL_COND_V(!_call_stack[l].instance->_vm._functions.has(*function_name), {});
+
+    OScriptNodeInstance* node = _call_stack[l].instance->_vm._nodes[*_call_stack[l].id];
+    ERR_FAIL_COND_V(!node, {});
+
+    PackedStringArray local_names;
+    Array local_values;
+
+    local_names.push_back("Script Node Name");
+    local_values.push_back(node->get_base_node()->get_node_title());
+    local_names.push_back("Script Node ID");
+    local_values.push_back(node->get_base_node()->get_id());
+    local_names.push_back("Script Node Type");
+    local_values.push_back(node->get_base_node()->get_class());
+
+    int offset = 0;
+    for (int i = 0; i < node->input_pin_count; i++)
+    {
+        Ref<OScriptNodePin> pin = node->get_base_node()->find_pin(i, PD_Input);
+        if (pin->is_execution())
+        {
+            offset++;
+            continue;
+        }
+
+        if (!pin->get_label().is_empty())
+            local_names.push_back("Inputs/" + pin->get_label());
+        else
+            local_names.push_back("Inputs/" + pin->get_pin_name());
+
+        int in_from = node->input_pins[i - offset];
+        int in_value = in_from & OScriptNodeInstance::INPUT_MASK;
+        if (in_from & OScriptNodeInstance::INPUT_DEFAULT_VALUE_BIT)
+            local_values.push_back(_call_stack[l].instance->_vm._default_values[in_value]);
+        else
+            local_values.push_back(_call_stack[l].stack[in_value]);
+    }
+
+    offset = 0;
+    for (int i = 0; i < node->output_pin_count; i++)
+    {
+        Ref<OScriptNodePin> pin = node->get_base_node()->find_pin(i, PD_Output);
+        if (pin->is_execution())
+        {
+            offset++;
+            continue;
+        }
+
+        if (!pin->get_label().is_empty())
+            local_names.push_back("Outputs/" + pin->get_label());
+        else
+            local_names.push_back("Outputs/" + pin->get_pin_name());
+
+        int out = node->output_pins[i - offset];
+        local_values.push_back(_call_stack[l].stack[out]);
+    }
+
+    Dictionary locals;
+    locals["locals"] = local_names;
+    locals["values"] = local_values;
+    return locals;
+}
+
+Dictionary OScriptLanguage::_debug_get_globals(int32_t p_max_subitems, int32_t p_max_depth)
+{
+    Dictionary results;
+    results["globals"] = get_global_constant_names();
+
+    Array values;
+    for (const String& name : get_global_constant_names())
+        values.push_back(get_any_global_constant(name));
+    results["values"] = values;
+
+    return results;
+}
+
+String OScriptLanguage::_debug_get_error() const
+{
+    return _debug_error;
+}
+
+int32_t OScriptLanguage::_debug_get_stack_level_count() const
+{
+    if (_debug_parse_err_line >= 0)
+        return 1;
+
+    return _debug_call_stack_pos;
+}
+#endif
+
 TypedArray<Dictionary> OScriptLanguage::_debug_get_current_stack_info()
 {
-    return {};
+    TypedArray<Dictionary> array;
+    #if GODOT_VERSION >= 0x040300
+    for (int i = 0; i < _debug_call_stack_pos; i++)
+    {
+        Dictionary data;
+        data["file"] = _call_stack[i].instance->get_script()->get_path();
+        data["func"] = *_call_stack[i].current_function;
+        data["line"] = *_call_stack[i].id;
+        array.append(data);
+    }
+    #endif
+    return array;
 }
 
 bool OScriptLanguage::_handles_global_class_type(const String& p_type) const
@@ -403,20 +613,107 @@ PackedStringArray OScriptLanguage::get_global_constant_names() const
 
 bool OScriptLanguage::debug_break(const String& p_error, bool p_allow_continue)
 {
-    // TODO:    GodotCPP Feature Request
-    //          Currently the EngineDebugger::debug method is not exposed to GDE and so it is
-    //          not presently possible to actually execute any type of debugger operation.
+    #if GODOT_VERSION >= 0x040300
+    if (EngineDebugger::get_singleton()->is_active())
+    {
+        if (OS::get_singleton()->get_thread_caller_id() == OS::get_singleton()->get_main_thread_id())
+        {
+            _debug_parse_err_line = -1;
+            _debug_parse_err_file = "";
+            _debug_error = p_error;
+
+            EngineDebugger::get_singleton()->script_debug(this, p_allow_continue, true);
+            return true;
+        }
+    }
+    #endif
     return false;
 }
 
 bool OScriptLanguage::debug_break_parse(const String& p_file, int p_node, const String& p_error)
 {
-    // TODO:    GodotCPP Feature Request
-    //          Currently the EngineDebugger::debug method is not exposed to GDE and so it is
-    //          not presently possible to actually execute any type of debugger operation.
+    #if GODOT_VERSION >= 0x040300
+    if (EngineDebugger::get_singleton()->is_active())
+    {
+        if (OS::get_singleton()->get_thread_caller_id() == OS::get_singleton()->get_main_thread_id())
+        {
+            _debug_parse_err_line = p_node;
+            _debug_parse_err_file = p_file;
+            _debug_error = p_error;
+
+            EngineDebugger::get_singleton()->script_debug(this, false, true);
+            return true;
+        }
+    }
+    #endif
     return false;
 }
 
+#if GODOT_VERSION >= 0x040300
+void OScriptLanguage::function_entry(const StringName* p_method, const OScriptExecutionContext* p_context)
+{
+    // Debugging can only happen within main thread
+    if (OS::get_singleton()->get_thread_caller_id() != OS::get_singleton()->get_main_thread_id())
+        return;
+
+    EngineDebugger* debugger = EngineDebugger::get_singleton();
+    if (!debugger || !debugger->is_active())
+        return;
+
+    if (debugger->get_lines_left() > 0 && debugger->get_depth() >= 0)
+        debugger->set_depth(debugger->get_depth() + 1);
+
+    if (_debug_call_stack_pos >= _debug_max_call_stack)
+    {
+        // Stack overflow
+        _debug_error = vformat("Stack overflow detected (stack size: %s)", _debug_max_call_stack);
+        debugger->script_debug(this, false, false);
+        return;
+    }
+
+    Variant* ptr = p_context->_working_memory;
+    _call_stack[_debug_call_stack_pos].stack = reinterpret_cast<Variant*>(p_context->_stack);
+    _call_stack[_debug_call_stack_pos].instance = p_context->_script_instance;
+    _call_stack[_debug_call_stack_pos].current_function = p_method;
+    _call_stack[_debug_call_stack_pos].working_memory = &ptr;
+    _call_stack[_debug_call_stack_pos].id = const_cast<int*>(p_context->get_current_node_ref());
+    _debug_call_stack_pos++;
+}
+
+void OScriptLanguage::function_exit(const StringName* p_method, const OScriptExecutionContext* p_context)
+{
+    // Debugging can only happen within main thread
+    if (OS::get_singleton()->get_thread_caller_id() != OS::get_singleton()->get_main_thread_id())
+        return;
+
+    EngineDebugger* debugger = EngineDebugger::get_singleton();
+    if (!debugger || !debugger->is_active())
+        return;
+
+    if (debugger->get_lines_left() > 0 && debugger->get_depth() >= 0)
+        debugger->set_depth(debugger->get_depth() - 1);
+
+    if (_debug_call_stack_pos == 0)
+    {
+        // Stack underflow
+        _debug_error = "Stack underflow detected";
+        debugger->script_debug(this, false, false);
+        return;
+    }
+
+    if (_call_stack[_debug_call_stack_pos - 1].instance != p_context->_script_instance
+        || *_call_stack[_debug_call_stack_pos - 1].current_function != *p_method)
+    {
+        // Function mismatch
+        _debug_error = "Function mismatch detected";
+        debugger->script_debug(this, false, false);
+        return;
+    }
+
+    _debug_call_stack_pos--;
+}
+#endif
+
 String OScriptLanguage::get_script_extension_filter() const
 {
     PackedStringArray results;
diff --git a/src/script/language.h b/src/script/language.h
index f6c29222..ddd425c5 100644
--- a/src/script/language.h
+++ b/src/script/language.h
@@ -18,6 +18,7 @@
 #define ORCHESTRATOR_SCRIPT_LANGUAGE_H
 
 #include "common/logger.h"
+#include "common/version.h"
 #include "serialization/format_defs.h"
 
 #include <godot_cpp/classes/mutex.hpp>
@@ -32,7 +33,10 @@ using namespace godot;
 /// Forward declarations
 class Orchestration;
 class OScript;
+class OScriptExecutionContext;
+class OScriptInstance;
 class OScriptNode;
+class OScriptVirtualMachine;
 
 /// Defines the script node creation function callback
 typedef Ref<OScriptNode> (*OScriptNodeRegisterFunc)(const String& p_type);
@@ -62,6 +66,17 @@ class OScriptLanguage : public ScriptLanguageExtension
         ~ScriptNodeInfo() = default;
     };
 
+    #if GODOT_VERSION >= 0x040300
+    struct CallStack
+    {
+        Variant* stack{ nullptr };
+        Variant** working_memory{ nullptr };
+        const StringName* current_function{ nullptr };
+        OScriptInstance* instance{ nullptr };
+        int* id{ nullptr };
+    };
+    #endif
+
     static OScriptLanguage* _singleton;                        //! The one and only instance
     static HashMap<StringName, ScriptNodeInfo> _nodes;         //! Script node registration data
     SelfList<OScript>::List _scripts;                          //! all loaded scripts
@@ -69,6 +84,15 @@ class OScriptLanguage : public ScriptLanguageExtension
     HashMap<StringName, Variant> _named_global_constants;      //! Stores named global constants
     String _extension{ ORCHESTRATOR_SCRIPT_TEXT_EXTENSION };   //! The language's extension
 
+    #if GODOT_VERSION >= 0x040300
+    int _debug_parse_err_line{ -1 };    //! The line number of the parse error
+    String _debug_parse_err_file;       //! The script file name of the parse error
+    String _debug_error;                //! The error message
+    int _debug_call_stack_pos{ 0 };     //! The current call stack position
+    int _debug_max_call_stack{ 0 };     //! The maximum call stack size
+    CallStack* _call_stack{ nullptr };  //! The call stack
+    #endif
+
 protected:
 
     /// Standard creator method for nodes
@@ -148,6 +172,17 @@ class OScriptLanguage : public ScriptLanguageExtension
     void _profiling_stop() override;
     void _frame() override;
     void _finish() override;
+    #if GODOT_VERSION >= 0x040300
+    String _debug_get_stack_level_source(int32_t p_level) const override;
+    int32_t _debug_get_stack_level_line(int32_t p_level) const override;
+    String _debug_get_stack_level_function(int32_t p_level) const override;
+    void* _debug_get_stack_level_instance(int32_t p_level) override;
+    Dictionary _debug_get_stack_level_members(int32_t p_level, int32_t p_max_subitems, int32_t p_max_depth) override;
+    Dictionary _debug_get_stack_level_locals(int32_t p_level, int32_t p_max_subitems, int32_t p_max_depth) override;
+    Dictionary _debug_get_globals(int32_t p_max_subitems, int32_t p_max_depth) override;
+    String _debug_get_error() const override;
+    int32_t _debug_get_stack_level_count() const override;
+    #endif
     TypedArray<Dictionary> _debug_get_current_stack_info() override;
     bool _handles_global_class_type(const String& p_type) const override;
     Dictionary _get_global_class_name(const String& p_path) const override;
@@ -160,6 +195,10 @@ class OScriptLanguage : public ScriptLanguageExtension
     // Debugging
     bool debug_break(const String& p_error, bool p_allow_continue);
     bool debug_break_parse(const String& p_file, int p_node, const String& p_error);
+    #if GODOT_VERSION >= 0x040300
+    void function_entry(const StringName* p_method, const OScriptExecutionContext* p_context);
+    void function_exit(const StringName* p_method, const OScriptExecutionContext* p_context);
+    #endif
 
     String get_script_extension_filter() const;
 
diff --git a/src/script/node.cpp b/src/script/node.cpp
index 0a7916f1..e26408f4 100644
--- a/src/script/node.cpp
+++ b/src/script/node.cpp
@@ -28,6 +28,9 @@ OScriptNode::OScriptNode()
     , _initialized(false)
     , _id(-1)
     , _flags(ScriptNodeFlags::CATALOGABLE)
+    #if GODOT_VERSION >= 0x040300
+    , _breakpoint_flag(BreakpointFlags::BREAKPOINT_NONE)
+    #endif
 {
 }
 
@@ -103,6 +106,17 @@ void OScriptNode::set_position(const Vector2& p_position)
     _position = p_position;
 }
 
+#if GODOT_VERSION >= 0x040300
+void OScriptNode::set_breakpoint_flag(BreakpointFlags p_flag)
+{
+    if (_breakpoint_flag != p_flag)
+    {
+        _breakpoint_flag = p_flag;
+        emit_changed();
+    }
+}
+#endif
+
 void OScriptNode::set_flags(BitField<ScriptNodeFlags> p_flags)
 {
     _flags = p_flags;
diff --git a/src/script/node.h b/src/script/node.h
index 1afdb9f1..72498ebc 100644
--- a/src/script/node.h
+++ b/src/script/node.h
@@ -80,6 +80,15 @@ class OScriptNode : public Resource
         EXPERIMENTAL = 1 << 3       //! Node is experimental and may change
     };
 
+    #if GODOT_VERSION >= 0x040300
+    enum BreakpointFlags
+    {
+        BREAKPOINT_NONE,
+        BREAKPOINT_ENABLED,
+        BREAKPOINT_DISABLED
+    };
+    #endif
+
 protected:
     Orchestration* _orchestration{ nullptr };  //! Owning orchestration
     bool _initialized{ false };                //! Manages whether the node is initialized
@@ -89,6 +98,9 @@ class OScriptNode : public Resource
     BitField<ScriptNodeFlags> _flags;          //! Flags
     Vector<Ref<OScriptNodePin>> _pins;         //! Pins
     bool _reconstructing{ false };             //! Tracks if the node is in reconstruction
+    #if GODOT_VERSION >= 0x040300
+    BreakpointFlags _breakpoint_flag;          //! Transient state for breakpoints
+    #endif
 
 private:
     // Serialization for pins
@@ -137,6 +149,20 @@ class OScriptNode : public Resource
     /// @param p_position the node's position coordinates
     void set_position(const Vector2& p_position);
 
+    #if GODOT_VERSION >= 0x040300
+    /// Returns whether this node has a breakpoint, regardless if breakpoint is disabled.
+    /// @return if this node has a breakpoint
+    bool has_breakpoint() const { return _breakpoint_flag != BreakpointFlags::BREAKPOINT_NONE; }
+
+    /// Returns whether the breakpoint on this node is disabled.
+    /// @return if this node's breakpoint is disabled
+    bool has_disabled_breakpoint() const { return _breakpoint_flag == BreakpointFlags::BREAKPOINT_DISABLED; }
+
+    /// Sets the node's breakpoint flag
+    /// @param p_flag the breakpoint flag state
+    void set_breakpoint_flag(BreakpointFlags p_flag);
+    #endif
+
     /// Get the node's flags.
     /// @return flags, defaults to none.
     virtual BitField<ScriptNodeFlags> get_flags() const { return _flags; }
diff --git a/src/script/script.cpp b/src/script/script.cpp
index b5cd5e98..780948d7 100644
--- a/src/script/script.cpp
+++ b/src/script/script.cpp
@@ -132,7 +132,7 @@ void* OScript::_instance_create(Object* p_object) const
         _instances[p_object] = si;
     }
 
-    void* godot_inst = GDEXTENSION_SCRIPT_INSTANCE_CREATE(&OScriptInstance::INSTANCE_INFO, si);
+    si->_script_instance = GDEXTENSION_SCRIPT_INSTANCE_CREATE(&OScriptInstance::INSTANCE_INFO, si);
 
     // Dispatch the "Init Event" if its wired
     if (has_function("_init"))
@@ -142,7 +142,7 @@ void* OScript::_instance_create(Object* p_object) const
         si->call("_init", nullptr, 0, &result, &err);
     }
 
-    return godot_inst;
+    return si->_script_instance;
 }
 
 bool OScript::_instance_has(Object* p_object) const
diff --git a/src/script/vm/execution_context.h b/src/script/vm/execution_context.h
index 86906c66..e1944f48 100644
--- a/src/script/vm/execution_context.h
+++ b/src/script/vm/execution_context.h
@@ -22,6 +22,8 @@
 using namespace godot;
 
 /// Forward declarations
+class OScriptInstance;
+class OScriptLanguage;
 class OScriptNodeInstance;
 class OScriptState;
 class OScriptVirtualMachine;
@@ -60,6 +62,7 @@ struct OScriptExecutionStackInfo
 /// The main script execution context which manages the execution state, stack and other runtime details.
 class OScriptExecutionContext
 {
+    friend class OScriptLanguage;
     friend class OScriptState;
     friend class OScriptVirtualMachine;
 
@@ -73,6 +76,7 @@ class OScriptExecutionContext
     int* _flow_stack{ nullptr };                  //! The flow stack
     int* _pass_stack{ nullptr };                  //! The node pass stack
 
+    OScriptInstance* _script_instance{ nullptr }; //! The script instance
     OScriptVirtualMachine* _instance{ nullptr };  //! The virtual machine instance
 
     int _initial_node_id{ -1 };                   //! Initial starting node ID
@@ -200,6 +204,10 @@ class OScriptExecutionContext
     /// @return the current node unique ID
     int get_current_node() const { return _current_node_id; }
 
+    /// Gets the current executing node unique ID reference
+    /// @returns a reference to the current node unique ID
+    const int* get_current_node_ref() const { return &_current_node_id; }
+
     /// Get the current node port that received the impulse
     /// @return the current node port with the impulse
     _FORCE_INLINE_ int get_current_node_port() const { return _current_node_port; }
diff --git a/src/script/vm/script_state.cpp b/src/script/vm/script_state.cpp
index b16db6ea..4a1c409f 100644
--- a/src/script/vm/script_state.cpp
+++ b/src/script/vm/script_state.cpp
@@ -63,6 +63,7 @@ Variant OScriptState::_call_method(GDExtensionCallError& r_error)
 {
     void* stack = const_cast<unsigned char*>(_stack.ptr());
     OScriptExecutionContext context(_stack_info, stack, _flow_stack_pos, _pass);
+    context._script_instance = _script_instance;
 
     Variant result;
     _instance->_call_method_internal(_function, &context, true, _node, _func_ptr, result, r_error);
diff --git a/src/script/vm/script_state.h b/src/script/vm/script_state.h
index 407f6b28..0fcc345a 100644
--- a/src/script/vm/script_state.h
+++ b/src/script/vm/script_state.h
@@ -44,6 +44,7 @@ class OScriptState : public RefCounted
 protected:
     ObjectID _instance_id;                                  //! Script intance object ID
     ObjectID _script_id;                                    //! Script intance ID
+    OScriptInstance* _script_instance{ nullptr };           //! Script instance
     OScriptVirtualMachine* _instance{ nullptr };            //! Virtual machine runtime (owned by script instance)
     OScriptVirtualMachine::Function* _func_ptr{ nullptr };  //! Executing function pointer
     OScriptNodeInstance* _node{ nullptr };                  //! Node that requested the yield/await
diff --git a/src/script/vm/script_vm.cpp b/src/script/vm/script_vm.cpp
index aa86b9e3..72c16b0d 100644
--- a/src/script/vm/script_vm.cpp
+++ b/src/script/vm/script_vm.cpp
@@ -22,6 +22,8 @@
 #include "script/nodes/variables/local_variable.h"
 #include "script/vm/script_state.h"
 
+#include <godot_cpp/classes/engine_debugger.hpp>
+
 static int get_exec_pin_index_of_port(const Ref<OScriptNode>& p_node, int p_port, EPinDirection p_direction)
 {
     int exec_index{ 0 };
@@ -546,9 +548,44 @@ void OScriptVirtualMachine::_dependency_step(OScriptExecutionContext& p_context,
 
 int OScriptVirtualMachine::_execute_step(OScriptExecutionContext& p_context, OScriptNodeInstance* p_instance)
 {
+    // In the case of dependency steps, adjust current node id
+    int current_node_id = p_instance->get_id();
+    if (p_context.get_current_node() != current_node_id)
+        p_context._current_node_id = p_instance->get_id();
+
     // Setup step details
     p_context._set_current_node_working_memory(p_instance->get_working_memory_size());
 
+    #if GODOT_VERSION >= 0x040300
+    EngineDebugger* debugger = EngineDebugger::get_singleton();
+    if (debugger && debugger->is_active())
+    {
+        Orchestration* orchestration = p_instance->get_base_node()->get_orchestration();
+
+        bool do_break = false;
+        const int node_id = p_instance->get_base_node()->get_id();
+
+        if (debugger->get_lines_left() > 0)
+        {
+            if (debugger->get_depth() <= 0)
+                debugger->set_lines_left(debugger->get_lines_left() - 1);
+            if (debugger->get_lines_left() <= 0)
+                do_break = true;
+        }
+
+        if (!do_break && debugger->is_breakpoint(node_id, orchestration->get_self()->get_path()))
+            do_break = true;
+
+        if (do_break && !debugger->is_skipping_breakpoints())
+            OScriptLanguage::get_singleton()->debug_break("Breakpoint: Before Node " + itos(node_id) + " executes.", true);
+
+        debugger->line_poll();
+    }
+    #endif
+
+    // Reset node
+    p_context._current_node_id = current_node_id;
+
     // Execute
     return p_instance->step(p_context);
 }
@@ -658,6 +695,11 @@ void OScriptVirtualMachine::_call_method_internal(const StringName& p_method, OS
     OScriptNodeInstance* node = p_instance;
     int node_port = 0; // always assumes 0 for now
 
+    #if GODOT_VERSION >= 0x040300
+    if (EngineDebugger::get_singleton()->is_active())
+        OScriptLanguage::get_singleton()->function_entry(&p_method, p_context);
+    #endif
+
     while (node)
     {
         // Track current node details
@@ -723,6 +765,7 @@ void OScriptVirtualMachine::_call_method_internal(const StringName& p_method, OS
             state->_instance_id = _owner->get_instance_id();
             state->_script_id = _script->get_instance_id();
             state->_instance = this;
+            state->_script_instance = p_context->_script_instance;
             state->_function = p_method;
             state->_working_memory_index = node->working_memory_index;
             state->_variant_stack_size = p_function->max_stack;
@@ -737,6 +780,11 @@ void OScriptVirtualMachine::_call_method_internal(const StringName& p_method, OS
             context.set_error(GDEXTENSION_CALL_OK);
             r_return = state;
 
+            #if GODOT_VERSION >= 0x040300
+            if (EngineDebugger::get_singleton()->is_active())
+                OScriptLanguage::get_singleton()->function_exit(&p_method, p_context);
+            #endif
+
             return;
         }
 
@@ -750,6 +798,23 @@ void OScriptVirtualMachine::_call_method_internal(const StringName& p_method, OS
             break;
         }
 
+        #if GODOT_VERSION >= 0x040300
+        if (EngineDebugger::get_singleton()->is_active())
+        {
+            bool do_break = false;
+
+            const int node_id = node->get_base_node()->get_id();
+            const String path = node->get_base_node()->get_orchestration()->get_self()->get_path();
+            if (EngineDebugger::get_singleton()->is_breakpoint(node_id, path))
+                do_break = true;
+
+            if (do_break && !EngineDebugger::get_singleton()->is_skipping_breakpoints())
+                OScriptLanguage::get_singleton()->debug_break("Breakpoint: After Node " + itos(node_id) + " has executed.", true);
+
+            EngineDebugger::get_singleton()->line_poll();
+        }
+        #endif
+
         // Calculate the output node
         const int next_node_id = result & OScriptNodeInstance::STEP_MASK;
 
@@ -858,6 +923,11 @@ void OScriptVirtualMachine::_call_method_internal(const StringName& p_method, OS
     if (context.has_error())
         _report_error(context, node, p_method);
 
+    #if GODOT_VERSION >= 0x040300
+    if (EngineDebugger::get_singleton()->is_active())
+        OScriptLanguage::get_singleton()->function_exit(&p_method, p_context);
+    #endif
+
     // Cleanup
     context._cleanup();
 }
@@ -946,7 +1016,7 @@ bool OScriptVirtualMachine::register_function(const Ref<OScriptFunction>& p_func
     return true;
 }
 
-void OScriptVirtualMachine::call_method(const StringName& p_method, const Variant* const* p_args, GDExtensionInt p_arg_count, Variant* r_return, GDExtensionCallError* r_err)
+void OScriptVirtualMachine::call_method(OScriptInstance* p_instance, const StringName& p_method, const Variant* const* p_args, GDExtensionInt p_arg_count, Variant* r_return, GDExtensionCallError* r_err)
 {
     ERR_FAIL_COND_MSG(!r_err, "No error code argument provided.");
 
@@ -1003,6 +1073,7 @@ void OScriptVirtualMachine::call_method(const StringName& p_method, const Varian
     context._initialize_variant_stack();
     context._push_node_onto_flow_stack(F->node);
     context._push_arguments(p_args, static_cast<int>(p_arg_count));
+    context._script_instance = p_instance;
 
     // Dispatch to the internal handler
     _call_method_internal(p_method, &context, false, F->instance, F, *r_return, *r_err);
diff --git a/src/script/vm/script_vm.h b/src/script/vm/script_vm.h
index 66ae67c8..f6acf815 100644
--- a/src/script/vm/script_vm.h
+++ b/src/script/vm/script_vm.h
@@ -31,6 +31,7 @@ class OScriptExecutionContext;
 class OScriptExecutionStack;
 class OScriptFunction;
 class OScriptInstance;
+class OScriptLanguage;
 class OScriptNode;
 class OScriptNodeInstance;
 class OScriptVariable;
@@ -41,6 +42,7 @@ struct OScriptConnection;
 /// The runtime virtual machine for Orchestrations
 class OScriptVirtualMachine
 {
+    friend class OScriptLanguage;
     friend class OScriptState;
 
 public:
@@ -228,12 +230,13 @@ class OScriptVirtualMachine
     bool register_function(const Ref<OScriptFunction>& p_function);
 
     /// Executes or calls the specified method
+    /// @param p_instance the script instance that made the call
     /// @param p_method the method name to run
     /// @param p_args the method arguments
     /// @param p_arg_count the number of method arguments
     /// @param r_return the return value, if applicable
     /// @param r_err the return code, if applicable
-    void call_method(const StringName& p_method, const Variant* const* p_args, GDExtensionInt p_arg_count, Variant* r_return, GDExtensionCallError* r_err);
+    void call_method(OScriptInstance* p_instance, const StringName& p_method, const Variant* const* p_args, GDExtensionInt p_arg_count, Variant* r_return, GDExtensionCallError* r_err);
 
     /// Constructs the virtual machine
     OScriptVirtualMachine();