diff --git a/icons/muybridge_saveup.png b/icons/muybridge_saveup.png
deleted file mode 100644
index d60ee85000304915d2467ff511d6ca757777ed08..0000000000000000000000000000000000000000
Binary files a/icons/muybridge_saveup.png and /dev/null differ
diff --git a/icons/muybridge_update.png b/icons/muybridge_update.png
deleted file mode 100644
index 8af498e9cdfbeca9eda55df29aceed6e165e4c1c..0000000000000000000000000000000000000000
Binary files a/icons/muybridge_update.png and /dev/null differ
diff --git a/muybridge/__init__.py b/muybridge/__init__.py
deleted file mode 100644
index 1f3a6679ec96f690b2df875bfbf2b8672f480396..0000000000000000000000000000000000000000
--- a/muybridge/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from main import run
diff --git a/muybridge/main.py b/muybridge/main.py
deleted file mode 100644
index 325747d4adf048989c27eb4b171ab2c9515dac21..0000000000000000000000000000000000000000
--- a/muybridge/main.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import nuke
-
-
-def run():
-    """
-    import modo guizmo
-    :return: None
-    """
-    nuke.createNode("muybridge")
\ No newline at end of file
diff --git a/muybridge/menu.py b/muybridge/menu.py
deleted file mode 100644
index 65875dde1dd8d102c0758c5d17d752d2b2f29bda..0000000000000000000000000000000000000000
--- a/muybridge/menu.py
+++ /dev/null
@@ -1,6 +0,0 @@
-import nuke
-from muybridge.main import run
-
-toolbar = nuke.menu("Nodes")
-blink_menu = toolbar.addMenu("Inkubator")
-blink_menu.addCommand("Lighting/Muybridge", "run()", "ctrl+m")
diff --git a/muybridge/scripts/__init__.py b/muybridge/scripts/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/muybridge/scripts/constants.py b/muybridge/scripts/constants.py
deleted file mode 100644
index ec8588adfeecada84fdaaad35b30b27309810e28..0000000000000000000000000000000000000000
--- a/muybridge/scripts/constants.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import getpass
-import os
-from helpers.bip_helpers import get_bip_username as bip_get_user
-
-
-# Formats
-OPENEXR = "openexr"
-SUPPORTED_FORMAT = {OPENEXR: ".exr"}
-
-# Default values
-INITIAL_ID = 0
-PADDING = 2
-SOURCE = 0
-USER_OVERRIDE = False
-
-# Json default user settings (to populate UI)
-RENDER_PATTERN = "preview_%02d"
-LOCAL_PATH = "C:/Users/%os_user/Documents/Muybridge/%bip_user"
-STUDIO_PATH = "//studio/tech/.Inkubator/.muybridge/%bip_user"
-
-# From OS
-OS_USER = getpass.getuser()
-HOME = os.path.expanduser("~")
-# from bip
-USER = bip_get_user()
-
-# Create Setting file path
-SETTING_FILENAME = "settings.json"
-SETTING_FILE = os.path.join(HOME, "Documents", "Muybridge", USER, SETTING_FILENAME)
-
-# Guizmo nodes
-READ_NODES = ["preview_read_left", "preview_read_right"]
-
-# Dynamic UI change nodes
-# Reset slider
-RESET_NODES = ["slider_transform"]
-RESET_KNOBS = ["translate", "rotate"]
diff --git a/muybridge/scripts/gizmo_buttons.py b/muybridge/scripts/gizmo_buttons.py
deleted file mode 100644
index d8f7bf71c2505f8299a2cc80d9990895ff4a4974..0000000000000000000000000000000000000000
--- a/muybridge/scripts/gizmo_buttons.py
+++ /dev/null
@@ -1,403 +0,0 @@
-"""
-Scripts needed for the Nuke gizmo buttons
-"""
-
-import os
-import glob
-import re
-import json
-import nuke
-from helpers.bip_constants import (
-    DEFAULT_USER,
-)
-from constants import (
-    INITIAL_ID,
-    PADDING,
-    RENDER_PATTERN,
-    LOCAL_PATH,
-    STUDIO_PATH,
-    OS_USER,
-    USER,
-    SETTING_FILE,
-    READ_NODES,
-    RESET_NODES,
-    RESET_KNOBS,
-    USER_OVERRIDE,
-    SOURCE,
-)
-
-
-def reload_read_nodes(nodes=None):
-    """
-    executes the reload button in read node
-    :param nodes: string or list of strings: node name to reload
-    :return:
-    """
-    # QUESTION: How to have two types of param? do two but they are optional?
-    if nodes is None:
-        nodes = READ_NODES
-    if type(nodes) == str:
-        nuke.toNode(nodes).knob("reload").execute()
-    else:
-        for node in nodes:
-            nuke.toNode(node).knob("reload").execute()
-
-
-def swap_renders():
-    # Swap slider button
-    group = nuke.thisNode()
-    left_value = group["render_left"].value()
-    right_value = group["render_right"].value()
-
-    group["render_left"].setValue(right_value)
-    group["render_right"].setValue(left_value)
-
-
-def reset_slider_knobs(nodes=None, knobs=None):
-    """
-
-    :param nodes: list: Nodes that will need to be reset (inside group)
-    :param knobs: list: Knobs that will need to be reset
-    :return:
-    """
-    if nodes is None:
-        nodes = RESET_NODES
-    if knobs is None:
-        knobs = RESET_KNOBS
-
-    group = nuke.thisNode()
-
-    for node in nodes:
-        for knob in knobs:
-            nuke.toNode(node)[knob].setValue(0, 0)
-            nuke.toNode(node)[knob].setValue(0, 1)
-
-    group["render_mix"].setValue(1)
-
-
-# TODO: remove explore path and use the one from helpers in the muybridge gizmo
-def explore_path(path):
-    path = os.path.normpath(path)
-    print "Explore: " + path
-    cmd = 'explorer "%s"' % path
-    os.system(cmd)
-
-
-def create_path_from_ui():
-    # Useful Nuke variables
-    group = nuke.thisNode()
-
-    # UI variables
-    ui_user = group["user_text"].value()
-    user_override = group["user_override"].value()
-    source = group["path_source"].value()
-    local_path = group["local_user_path"].value()
-    studio_path = group["studio_user_path"].value()
-
-    user = USER
-    # select user (bip or override)
-    if user_override:
-        user = ui_user
-
-    # select path
-    if source == "Local":
-        path = local_path
-    else:
-        path = studio_path
-
-    # replace users
-    path = path.replace("%bip_user", user).replace("%os_user", OS_USER)
-
-    return path
-
-
-def get_latest_id(path):
-    """
-    This function check the render folder and returns the latest render ID
-    :param path: render destination folder
-    :return: ID to use as a string
-    """
-
-    # get the list of all the exrs on disk
-    all_renders = glob.glob(path + "/*.exr")
-
-    render_files = []
-    # make the Default pattern matchable
-    pattern = RENDER_PATTERN.replace("%02d", "[0-9][0-9].exr")
-
-    # only work with files properly formatted
-    for render in all_renders:
-        # Get only the render name
-        render_basename = os.path.basename(render)
-        # Check that the name matches,
-        # we ignore case here cause Modo is stupid and will override a file regardless of case.
-        if bool(re.match(pattern, render_basename, flags=re.I)):  # re.I == re.IGNORECASE
-            render_files.append(render)
-
-    # find the latest modified exr path or return default ID if there's no file
-    try:
-        render = max(render_files, key=os.path.getmtime)
-    except ValueError:
-        print "no renders yet, using " + str(INITIAL_ID).zfill(PADDING)
-        return str(INITIAL_ID).zfill(PADDING)
-
-    # keep only file name
-    render = os.path.basename(render)
-
-    # extract ID
-    render_id = os.path.splitext(render)[0].split("_")[1]
-
-    return render_id
-
-
-def update_render_to_latest(knob_name):
-    """
-    This function is run by the + buttons, it updates the knob to the latest render
-    :param knob_name: string: knob name
-    :return: None
-    """
-    group = nuke.thisNode()
-    render_path = group["render_path"].value()
-    render_id = get_latest_id(render_path)
-    group[knob_name].setValue(render_id)
-
-
-def update_settings():
-    """
-    This function is run by the update button, it updates the render path and json settings with the UI settings
-    :return: None
-    """
-    # Useful Nuke variables
-    group = nuke.thisNode()
-
-    # UI variables
-    ui_user = group["user_text"].value()
-    user_override = group["user_override"].value()
-    source = group["path_source"].value()
-    source_index = group["path_source"].getValue()
-    local_path = group["local_user_path"].value()
-    studio_path = group["studio_user_path"].value()
-    # render_path = group["render_path"].value()
-    render_left = group["render_left"].value()
-    render_right = group["render_right"].value()
-
-    read_node_left = "preview_read_left"
-    read_node_right = "preview_read_right"
-
-    # setting path
-    setting_file = SETTING_FILE
-
-    user = USER
-    # select user (bip or override)
-    if user_override:
-        user = ui_user
-
-    # select path and update Burn-in text
-    if source == "Local":
-        path = local_path
-        nuke.toNode("source_text")["message"].setValue("Local")
-    else:
-        path = studio_path
-        nuke.toNode("source_text")["message"].setValue("Studio")
-
-    # update user_override_text with username
-    nuke.toNode("user_override_text")["message"].setValue(" Sneaking on " + ui_user)
-    # disable node if no override
-    if not user_override:
-        nuke.toNode("user_override_text")["disable"].setValue(True)
-    else:
-        nuke.toNode("user_override_text")["disable"].setValue(False)
-
-    # replace users variables (%bip_user and %os_user)
-    path = path.replace("%bip_user", user).replace("%os_user", OS_USER)
-    render_file_left = path + "/preview_" + render_left + ".exr"
-    render_file_right = path + "/preview_" + render_right + ".exr"
-
-    nuke.toNode(read_node_left)["file"].setValue(render_file_left)
-    nuke.toNode(read_node_right)["file"].setValue(render_file_right)
-
-    # store path in group node
-    group["render_path"].setValue(path)
-
-    # and in config json file
-
-    settings = {"local_path": local_path,
-                "studio_path": studio_path,
-                "source": source_index,
-                "user_override": user_override,
-                "ui_user": ui_user,
-                "render_path": path,
-                }
-
-    with open(setting_file, "w") as f:
-        json.dump(settings, f)
-
-    # hide Update button (and turn it back to white)
-    group["update_path_button"].setLabel("Update")
-    group["update_path_button"].setVisible(False)
-
-    print "Guizmo and setting.json updated"
-
-
-def create_default_json(file_path=None):
-    """
-    This function checks if the setting files exists and creates it if it doesn't.
-    :param file_path: string: setting file path including file name and extension
-    :return: None
-    """
-    if file_path is None:
-        file_path = SETTING_FILE
-
-    # Create human and modo readable render_path WARNING: modo uses / not os ones
-    render_path = LOCAL_PATH.replace("%bip_user", USER).replace("%os_user", OS_USER)
-
-    # Store all de hard codes settings into a dictionary # QUESTION: should this be outside the function?
-    default_settings = {"local_path": LOCAL_PATH,
-                        "studio_path": STUDIO_PATH,
-                        "source": SOURCE,
-                        "user_override": USER_OVERRIDE,
-                        "ui_user": DEFAULT_USER,
-                        "render_patern": RENDER_PATTERN,
-                        "render_path": render_path,
-                        }
-
-    # check and create user Muybridge folder if it doesnt exist
-    if not os.path.isdir(os.path.dirname(file_path)):
-        os.makedirs(os.path.dirname(file_path))
-
-    # create jason file with default settings if it doesn't exist
-    if not os.path.isfile(file_path):
-        print "no settings file, creating default setting file"
-        with open(file_path, "w") as f:
-            json.dump(default_settings, f)
-
-
-def apply_settings_from_json(file_path=None):
-    """
-    This function reads the setting json file and applies its setting to the nuke guizmo
-    :return: None
-    """
-    if file_path is None:
-        file_path = SETTING_FILE
-
-    group = nuke.thisNode()
-
-    # get setting from jason file
-    with open(file_path, "r") as f:
-        user_settings = json.load(f)
-
-    # Apply settings to node
-    group["local_user_path"].setValue(user_settings["local_path"])
-    group["studio_user_path"].setValue(user_settings["studio_path"])
-    group["path_source"].setValue(int(user_settings["source"]))
-    group["user_override"].setValue(user_settings["user_override"])
-    group["user_text"].setValue(user_settings["ui_user"])
-    group["render_path"].setValue(user_settings["render_path"])
-
-
-def on_create():
-    """
-    This function is ran every time the guizmo is created (includes when opening a nuke file)
-    :return: None
-    """
-    # create default setting json file if needed
-    create_default_json()
-    # read setting from json and apply them to the node
-    apply_settings_from_json()
-
-    group = nuke.thisNode()
-
-    # set render left to latest if required
-    if group["update_to_latest_on_creation"].value():
-        update_render_to_latest("render_left")
-    # update node
-    update_settings()
-
-
-def knob_changed():
-    """
-    This function is ran every time the guizmo is changed (includes when it moved or is connected)
-    :return: None
-    """
-
-    # read nodes inside the group
-    read_left = READ_NODES[0]
-    read_right = READ_NODES[1]
-
-    # useful variables:
-    group = nuke.thisNode()
-
-    # stored parameter to check what changed
-    stored_left = group["stored_render_left"].value()
-    stored_right = group["stored_render_right"].value()
-
-    stored_source = group["stored_source"].value()
-    stored_user = group["stored_user"].value()
-    stored_user_override = group["stored_user_override"].value()
-
-    path = group["render_path"].value()
-
-    # user parameters
-    left = group['render_left'].value()
-    right = group['render_right'].value()
-    separator = "/"
-
-    path_source = group["path_source"].value()
-    user_override = group["user_override"].value()
-    user_text = group["user_text"].value()
-
-    # Change path in read nodes only if the value changed
-    if left != stored_left:
-        render_file_left = path + "/preview_" + left + ".exr"
-        group["stored_render_left"].setValue(left)
-        nuke.toNode(read_left)["file"].setValue(render_file_left)
-
-    if right != stored_right:
-        render_file_right = path + "/preview_" + right + ".exr"
-        group["stored_render_right"].setValue(right)
-        nuke.toNode(read_right)["file"].setValue(render_file_right)
-
-    # Guizmo UI update
-    # set group label to show what its reading
-    if group['render_compare'].value():
-        label = left + separator + right
-    else:
-        label = left
-
-    group['label'].setValue(label)
-
-    # disable user text input
-    if group["user_override"].value():
-        group["user_text"].setEnabled(True)
-    else:
-        group["user_text"].setEnabled(False)
-
-    # disable render right UI stuff
-
-    # all the nodes to hide:
-    to_hide = ["slider", "translate", "rotate",
-               "mix_separator", "render_mix", "reset_slider", "slider_show", "slider_size", "slider_color",
-               "slider_line", "path_setting_separator"]
-
-    if not group["render_compare"].value():
-        for node in to_hide:
-            group[node].setVisible(False)
-        group["swap_input_button"].setEnabled(False)
-        group["render_right"].setEnabled(False)
-        group["set_latest_right"].setEnabled(False)
-    else:
-        for node in to_hide:
-            group[node].setVisible(True)
-        group["swap_input_button"].setEnabled(True)
-        group["render_right"].setEnabled(True)
-        group["set_latest_right"].setEnabled(True)
-
-    # Change update button colour if user setting dont match stored one
-
-    if path_source != stored_source or user_text != stored_user or str(user_override) != stored_user_override:
-        group["update_path_button"].setLabel("<font color='red'>Update")
-        group["update_path_button"].setVisible(True)
-        group["update_path_button"].setEnabled(True)
-        group["stored_source"].setValue(path_source)
-        group["stored_user"].setValue(user_text)
-        group["stored_user_override"].setValue(str(user_override))