diff --git a/OPmenu.xml b/OPmenu.xml
index 0b4b8af..e54349b 100644
--- a/OPmenu.xml
+++ b/OPmenu.xml
@@ -2,7 +2,7 @@
 
 <!--
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -30,10 +30,9 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
             <scriptItem id="opmenu.tdk_generate_code">
                 <label>Generate Code...</label>
                 <scriptCode>
-import houdini_tdk
-reload(houdini_tdk)
+import houdini_tdk as tdk
 
-houdini_tdk.generateCode(**kwargs)
+tdk.showGenerateCode(**kwargs)
                 </scriptCode>
             </scriptItem>
 
@@ -49,19 +48,18 @@ houdini_tdk.showNodeUserData(cached=kwargs['shiftclick'], **kwargs)
 
             <separatorItem/>
 
-            <scriptItem id="opmenu.tdk_make_hda_from_template">
-                <label>Make HDA from Template...</label>
+            <scriptItem id="opmenu.tdk_make_hda_by_template">
+                <label>Make HDA by Template...</label>
                 <context>
                     <expression>
                         node = kwargs['node']
-                        return node.type().name() == 'tdk::template'
+                        return node.type().name().startswith('tdk::template')
                     </expression>
                 </context>
                 <scriptCode>
-import houdini_tdk
-reload(houdini_tdk)
+import houdini_tdk as tdk
 
-houdini_tdk.showMakeHDAFromTemplateDialog(**kwargs)
+tdk.showMakeHDAByTemplateDialog(**kwargs)
                 </scriptCode>
             </scriptItem>
 
@@ -74,17 +72,16 @@ houdini_tdk.showMakeHDAFromTemplateDialog(**kwargs)
                     </expression>
                 </context>
                 <scriptCode>
-import os
-import webbrowser
+from houdini_tdk.utils import openFileLocation
 
 node = kwargs['node']
 path = node.type().definition().libraryFilePath()
-webbrowser.open('file:///' + os.path.dirname(path))
+openFileLocation(path)
                 </scriptCode>
             </scriptItem>
 
-            <scriptItem id="opmenu.tdk_increment_hda_version">
-                <label>Increment HDA Version...</label>
+            <scriptItem id="opmenu.tdk_new_hda_version">
+                <label>New HDA Version...</label>
                 <context>
                     <expression>
                         node = kwargs['node']
@@ -92,10 +89,9 @@ webbrowser.open('file:///' + os.path.dirname(path))
                     </expression>
                 </context>
                 <scriptCode>
-import houdini_tdk
-reload(houdini_tdk)
+import houdini_tdk as tdk
 
-houdini_tdk.showNewVersionDialog(**kwargs)
+tdk.showNewVersionDialog(**kwargs)
                 </scriptCode>
             </scriptItem>
 
diff --git a/README.md b/README.md
index 6aeaab4..1ebbd18 100644
--- a/README.md
+++ b/README.md
@@ -2,11 +2,17 @@
 
 ## Tools
 
+#### HDA Doctor *Beta*
+
+Tool that allows you to test your HDA with a set of inspections that check for compliance with high standards of HDA development.
+
+![HDA Doctor](/images/hda_doctor.png)
+
 #### Templates
 
-Template HDAs that allows you to quickly create your own HDAs based on them.
+Template HDAs that allows you to quickly create new HDAs based on them.
 
-![Make HDA from Template](/images/make_hda_from_template.png)
+![Make HDA by Template](/images/make_hda_by_template.gif)
 
 #### Find Icon
 
@@ -19,12 +25,13 @@ Allows you to quickly find an icon for your tool.
 Applies `.asCode()` to selected nodes. Then copies the resulting code to the clipboard or shows in code editor.
 
 ![Generate Code](/images/generate_code.png)
+![Generate Code Settings](/images/generate_code_settings.png)
 
-#### Increment HDA Version
+#### New HDA Version
 
-Increments the HDA version of the selected node. You can select the version type (major, minor, build, etc.).
+Increments an HDA version of the selected node. You can select the version type (major, minor, build, etc.).
 
-![Increment HDA Version](/images/increment_hda_version.png)
+![New HDA Version](/images/new_hda_version.png)
 
 #### Show Node User Data
 
@@ -32,17 +39,17 @@ Shows user data and cached user data of the selected node.
 
 ![Show Node User Data](/images/show_node_user_data.png)
 
-## Installation (todo)
+## Installation
 
-- [16.0+] Package Manager (Recommended)
-- [17.5+] Packages (template json file included)
+- [16.0+] [Package Manager](https://github.com/Houdini-Packages/Houdini-Package-Manager) *Recommended*
+- [17.5+] [Packages](https://www.sidefx.com/docs/houdini/ref/plugins.html) (template json file included)
 - Environment file
 
 ## License
 
 ```
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
diff --git a/images/find_icon.png b/images/find_icon.png
index 82964c2..b1c6363 100644
Binary files a/images/find_icon.png and b/images/find_icon.png differ
diff --git a/images/generate_code.png b/images/generate_code.png
index 81f7417..c144191 100644
Binary files a/images/generate_code.png and b/images/generate_code.png differ
diff --git a/images/generate_code_settings.png b/images/generate_code_settings.png
new file mode 100644
index 0000000..b9e694c
Binary files /dev/null and b/images/generate_code_settings.png differ
diff --git a/images/hda_doctor.png b/images/hda_doctor.png
new file mode 100644
index 0000000..220f5e1
Binary files /dev/null and b/images/hda_doctor.png differ
diff --git a/images/increment_hda_version.png b/images/increment_hda_version.png
deleted file mode 100644
index c591f0e..0000000
Binary files a/images/increment_hda_version.png and /dev/null differ
diff --git a/images/make_hda_by_template.gif b/images/make_hda_by_template.gif
new file mode 100644
index 0000000..4d2bc52
Binary files /dev/null and b/images/make_hda_by_template.gif differ
diff --git a/images/make_hda_from_template.png b/images/make_hda_from_template.png
deleted file mode 100644
index f03105f..0000000
Binary files a/images/make_hda_from_template.png and /dev/null differ
diff --git a/images/new_hda_version.png b/images/new_hda_version.png
new file mode 100644
index 0000000..c2e1efc
Binary files /dev/null and b/images/new_hda_version.png differ
diff --git a/images/show_node_user_data.png b/images/show_node_user_data.png
index e4fccca..933ceb5 100644
Binary files a/images/show_node_user_data.png and b/images/show_node_user_data.png differ
diff --git a/otls/tdk__template.hda b/otls/tdk__template.hda
index 3c6f9ac..62c7ad6 100644
Binary files a/otls/tdk__template.hda and b/otls/tdk__template.hda differ
diff --git a/python2.7libs/houdini_tdk/__init__.py b/python2.7libs/houdini_tdk/__init__.py
index 778248a..24912ed 100644
--- a/python2.7libs/houdini_tdk/__init__.py
+++ b/python2.7libs/houdini_tdk/__init__.py
@@ -1,6 +1,6 @@
 """
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -19,5 +19,6 @@
 from .find_icon import FindIconDialog, findIcon
 from .new_hda_version import NewVersionDialog, showNewVersionDialog
 from .show_node_user_data import UserDataWindow, showNodeUserData
-from .make_hda_from_template import MakeHDAFromTemplateDialog, showMakeHDAFromTemplateDialog
-from .generate_code import generateCode
+from .make_hda_by_template import MakeHDAByTemplateDialog, showMakeHDAByTemplateDialog
+from .generate_code import showGenerateCode
+from .hda_doctor import HDADoctorWindow
diff --git a/python2.7libs/houdini_tdk/find_icon.py b/python2.7libs/houdini_tdk/find_icon.py
index baf7450..92a41b5 100644
--- a/python2.7libs/houdini_tdk/find_icon.py
+++ b/python2.7libs/houdini_tdk/find_icon.py
@@ -1,6 +1,6 @@
 """
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -52,12 +52,14 @@ def icon(name):
 def fuzzyMatch(pattern, text):
     if pattern == text:
         return True, 999999
+
     try:
         pattern_start = text.index(pattern)
         pattern_length = len(pattern)
         return True, pattern_length * pattern_length + (1 - pattern_start / 500.0)
     except ValueError:
         pass
+
     weight = 0
     count = 0
     index = 0
@@ -71,44 +73,47 @@ def fuzzyMatch(pattern, text):
                 count = 0
         except IndexError:
             pass
+
     weight += count * count
     if index < len(pattern):
         return False, weight
+
     return True, weight + (1 - text.index(pattern[0]) / 500.0)
 
 
 class FuzzyFilterProxyModel(QSortFilterProxyModel):
     def __init__(self, parent=None):
         super(FuzzyFilterProxyModel, self).__init__(parent)
+
         self.setDynamicSortFilter(True)
         self.setFilterCaseSensitivity(Qt.CaseInsensitive)
         self.sort(0, Qt.DescendingOrder)
 
-        self.pattern = ''
+        self._pattern = ''
 
     def setFilterPattern(self, pattern):
-        self.pattern = pattern.lower()
+        self._pattern = pattern.lower()
         self.invalidate()
 
     def filterAcceptsRow(self, source_row, source_parent):
-        if not self.pattern:
+        if not self._pattern:
             return True
 
         source_model = self.sourceModel()
         text = source_model.data(source_model.index(source_row, 0, source_parent),
                                  Qt.UserRole)
-        matches, _ = fuzzyMatch(self.pattern, text.lower())
+        matches, _ = fuzzyMatch(self._pattern, text.lower())
         return matches
 
     def lessThan(self, source_left, source_right):
-        if not self.pattern:
+        if not self._pattern:
             return source_left.row() < source_right.row()
 
         text1 = source_left.data(Qt.DisplayRole)
-        _, weight1 = fuzzyMatch(self.pattern, text1.lower())
+        _, weight1 = fuzzyMatch(self._pattern, text1.lower())
 
         text2 = source_right.data(Qt.DisplayRole)
-        _, weight2 = fuzzyMatch(self.pattern, text2.lower())
+        _, weight2 = fuzzyMatch(self._pattern, text2.lower())
 
         return weight1 < weight2
 
@@ -127,52 +132,159 @@ def rowCount(self, parent):
     def data(self, index, role):
         icon_name = self.__data[index.row()]
         if role == Qt.DisplayRole:
-            label = icon_name.replace('.svg', '')
+            label = icon_name.replace('.svg', '')  # VOP_wood.svg -> VOP_wood
             if '_' in label:
-                label = ' '.join(label.split('_')[1:]).title()
+                label = ' '.join(label.split('_')[1:]).title()  # VOP_wood -> Wood
             return label
         elif role == Qt.DecorationRole:
             return IconCache.icon(icon_name)
         elif role == Qt.UserRole or role == Qt.ToolTipRole:
             return icon_name
 
+    def indexByKey(self, key):
+        for index, name in enumerate(self.__data):
+            if name[:-4] == key:
+                return self.index(index, 0)
+
+        return QModelIndex()
+
 
 class IconListView(QListView):
+    # Signals
+    itemDoubleClicked = Signal(QModelIndex)
+
     def __init__(self):
         super(IconListView, self).__init__()
         self.setViewMode(QListView.IconMode)
+        self.setIconSize(QSize(48, 48))
+        self.setUniformItemSizes(True)
+
         self.setResizeMode(QListView.Adjust)
         self.setDragDropMode(QAbstractItemView.NoDragDrop)
         self.setSelectionMode(QAbstractItemView.ExtendedSelection)
+
         self.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
         self.verticalScrollBar().setSingleStep(30)
+
         self.setSpacing(15)
-        self.setIconSize(QSize(48, 48))
-        self.setUniformItemSizes(True)
+
+        # Item Double Clicked
+        self._item_double_clicked_signal_enabled = False
+        self.doubleClicked.connect(self.__emitItemDoubleClicked)
 
         # Menu
+        self._menu = None
+        self._copy_name_action = None
+        self._copy_file_name_action = None
+        self._copy_image_action = None
+        self._save_image_action = None
+
+        self._createActions()
+
         self.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.customContextMenuRequested.connect(self.showContextMenu)
 
-        self.menu = QMenu(self)
-        self.menu.addAction('Copy', self.copySelectedIconName, QKeySequence.Copy)
+    def doubleClickedSignalEnabled(self):
+        return self._item_double_clicked_signal_enabled
 
-        self.customContextMenuRequested.connect(self.showMenu)
+    def enableDoubleClickedSignal(self, enable=True):
+        self._item_double_clicked_signal_enabled = enable
 
     def copySelectedIconName(self):
         names = []
         for index in self.selectedIndexes():
             names.append(index.data(Qt.ToolTipRole))
+
+        QApplication.clipboard().setText('\n'.join(name[:-4] for name in names))
+
+    def copySelectedIconFileName(self):
+        names = []
+        for index in self.selectedIndexes():
+            names.append(index.data(Qt.ToolTipRole))
+
         QApplication.clipboard().setText('\n'.join(names))
 
-    def showMenu(self, pos):
-        if self.selectedIndexes():
-            self.menu.exec_(self.mapToGlobal(pos))
+    def _selectedImage(self):
+        indexes = self.selectedIndexes()
+        if len(indexes) == 1:
+            name = indexes[0].data(Qt.UserRole)
+            return hou.qt.Icon(name, 48, 48).pixmap(48, 48)
 
-    def keyPressEvent(self, event):
-        if event.matches(QKeySequence.Copy):
-            self.copySelectedIconName()
+    def copySelectedIcon(self):
+        image = self._selectedImage()
+        if image:
+            clipboard = QApplication.clipboard()
+            clipboard.setPixmap(image)
+
+    def saveSelectedIcon(self):
+        indexes = self.selectedIndexes()
+
+        if len(indexes) != 1:
+            return
+
+        name = indexes[0].data(Qt.DisplayRole)
+        path, _ = QFileDialog.getSaveFileName(self, 'Save image',
+                                              name, filter='PNG (*.png)',
+                                              initialFilter=name)
+
+        image = self._selectedImage()
+        if path and image:
+            image.save(path)
+
+    def _createActions(self):
+        # Copy Name
+        self._copy_name_action = QAction('Copy Name', self)
+        self._copy_name_action.triggered.connect(self.copySelectedIconName)
+        self._copy_name_action.setShortcut(QKeySequence.Copy)
+        self.addAction(self._copy_name_action)
+
+        # Copy File Name
+        self._copy_file_name_action = QAction('Copy File Name', self)
+        self._copy_file_name_action.triggered.connect(self.copySelectedIconFileName)
+
+        # Copy Image
+        self._copy_image_action = QAction('Copy Image...', self)
+        self._copy_image_action.triggered.connect(self.copySelectedIcon)
+
+        # Save Image
+        self._save_image_action = QAction('Save Image...', self)
+        self._save_image_action.triggered.connect(self.saveSelectedIcon)
+
+    def _createContextMenu(self):
+        self._menu = hou.qt.Menu()
+
+        self._menu.addAction(self._copy_name_action)
+        self._menu.addAction(self._copy_file_name_action)
+
+        self._menu.addSeparator()
+
+        self._menu.addAction(self._copy_image_action)
+        self._menu.addAction(self._save_image_action)
+
+    def _updateContextMenu(self):
+        selected_indices = self.selectedIndexes()
+        if len(selected_indices) == 1:
+            self._copy_image_action.setEnabled(True)
+            self._save_image_action.setEnabled(True)
         else:
-            super(IconListView, self).keyPressEvent(event)
+            self._copy_image_action.setEnabled(False)
+            self._save_image_action.setEnabled(False)
+
+    def showContextMenu(self, local_pos):
+        if not self._menu:
+            self._createContextMenu()
+
+        self._updateContextMenu()
+
+        return self._menu.exec_(self.mapToGlobal(local_pos))
+
+    def __emitItemDoubleClicked(self):
+        if not self._item_double_clicked_signal_enabled:
+            return
+
+        index = self.currentIndex()
+        if index.isValid():
+            self.itemDoubleClicked.emit(index)
 
 
 class FindIconDialog(QDialog):
@@ -180,7 +292,7 @@ def __init__(self, parent=None):
         super(FindIconDialog, self).__init__(parent, Qt.Window)
 
         self.setWindowTitle('TDK: Find Icon')
-        self.setWindowIcon(hou.qt.Icon('MISC_m', 16, 16))
+        self.setWindowIcon(hou.qt.Icon('MISC_m', 32, 32))
         self.resize(820, 500)
 
         # Layout
@@ -201,6 +313,7 @@ def __init__(self, parent=None):
 
         self.icon_list_view = IconListView()
         self.icon_list_view.setModel(self.filter_proxy_model)
+        self.icon_list_view.itemDoubleClicked.connect(self.accept)
         main_layout.addWidget(self.icon_list_view)
 
         # Buttons
@@ -210,13 +323,15 @@ def __init__(self, parent=None):
         spacer = QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Ignored)
         buttons_layout.addSpacerItem(spacer)
 
-        ok_button = QPushButton('OK')
-        ok_button.clicked.connect(self.accept)
-        buttons_layout.addWidget(ok_button)
+        self.ok_button = QPushButton('OK')
+        self.ok_button.setVisible(False)
+        self.ok_button.clicked.connect(self.accept)
+        buttons_layout.addWidget(self.ok_button)
 
-        cancel_button = QPushButton('Cancel')
-        cancel_button.clicked.connect(self.reject)
-        buttons_layout.addWidget(cancel_button)
+        self.cancel_button = QPushButton('Cancel')
+        self.cancel_button.setVisible(False)
+        self.cancel_button.clicked.connect(self.reject)
+        buttons_layout.addWidget(self.cancel_button)
 
     def keyPressEvent(self, event):
         if event.matches(QKeySequence.Find) or event.key() == Qt.Key_F3:
@@ -225,11 +340,26 @@ def keyPressEvent(self, event):
         else:
             super(FindIconDialog, self).keyPressEvent(event)
 
+    def enableDialogMode(self):
+        self.icon_list_view.setSelectionMode(QAbstractItemView.SingleSelection)
+        self.icon_list_view.enableDoubleClickedSignal()
+        self.ok_button.setVisible(True)
+        self.cancel_button.setVisible(True)
+
     @classmethod
-    def getIconName(cls, parent=hou.qt.mainWindow(), title='Find Icon'):
+    def getIconName(cls, parent=hou.qt.mainWindow(), title='Find Icon', name=None):
         window = FindIconDialog(parent)
         window.setWindowTitle('TDK: ' + title)
-        window.icon_list_view.setSelectionMode(QAbstractItemView.SingleSelection)
+        window.enableDialogMode()
+
+        if name:
+            model = window.icon_list_view.model()
+            for row in range(model.rowCount()):
+                index = model.index(row, 0)
+                if index.data(Qt.UserRole) == name + '.svg':
+                    window.icon_list_view.setCurrentIndex(index)
+                    break
+
         if window.exec_() and window.icon_list_view.currentIndex().isValid():
             return window.icon_list_view.currentIndex().data(Qt.UserRole)
 
diff --git a/python2.7libs/houdini_tdk/generate_code.py b/python2.7libs/houdini_tdk/generate_code.py
index 63f8917..d19e291 100644
--- a/python2.7libs/houdini_tdk/generate_code.py
+++ b/python2.7libs/houdini_tdk/generate_code.py
@@ -1,6 +1,8 @@
+# coding: utf-8
+
 """
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -16,33 +18,215 @@
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
+from __future__ import print_function
+
 import os
 import tempfile
 
+import os
+
+try:
+    from PyQt5.QtWidgets import *
+    from PyQt5.QtGui import *
+    from PyQt5.QtCore import *
+
+    Signal = pyqtSignal
+except ImportError:
+    from PySide2.QtWidgets import *
+    from PySide2.QtGui import *
+    from PySide2.QtCore import *
+
 import hou
 
+from notification import notify
 
-def generateCode(**kwargs):
-    if 'node' in kwargs:
-        nodes = kwargs['node'],
+
+def _openCode(code, node, in_houdini):
+    path = tempfile.mktemp('.py')
+    with open(path, 'w') as file:
+        file.write(code)
+
+    if in_houdini:
+        hou.ui.openFileEditor(node.path(), path)
+        notify('Code was generated and opened in internal editor')
     else:
-        nodes = hou.selectedNodes()
+        os.startfile(path)
+        notify('Code was generated and opened in external editor')
+
+
+def _copyCode(code):
+    hou.ui.copyTextToClipboard(code)
+    notify('Code was generated and copied')
+
+
+class ActionType:
+    Internal = 1
+    External = 2
+    Copy = 4
+
+    @staticmethod
+    def byKWARGS(**kwargs):
+        return kwargs['ctrlclick'] * ActionType.Internal + \
+               kwargs['shiftclick'] * ActionType.External \
+               + kwargs['altclick'] * ActionType.Copy
+
+
+def generateCode(action_type, node=None, options=None):
+    nodes = (node,) if node else hou.selectedNodes()
+
     if not nodes:
-        raise hou.Error('No node selected')
-    code = ''.join(node.asCode(brief=True) for node in nodes)
-    if kwargs['ctrlclick'] or kwargs['shiftclick']:
-        path = tempfile.mktemp('.py')
-        with open(path, 'w') as file:
-            file.write(code)
-        if len(nodes) == 1:
-            title = nodes[0].path()
-        else:
-            title = os.path.dirname(nodes[0].path())
-        if kwargs['ctrlclick']:
-            hou.ui.openFileEditor(title, path)
-        else:
-            os.startfile(path)
+        notify('No node selected', hou.severityType.Error)
+        return
+
+    if not options:
+        options = {'brief': True}
+
+    code = ''.join(node.asCode(**options) for node in nodes)
+
+    if action_type & (ActionType.Internal | ActionType.External):
+        _openCode(code, nodes[0], action_type & ActionType.Internal)
+    else:
+        _copyCode(code)
+
+
+class GenerateCodeSettings(QDialog):
+    def __init__(self, node, parent=None):
+        super(GenerateCodeSettings, self).__init__(parent)
+
+        # Data
+        self._node = node
+
+        # UI
+        self.setWindowTitle('Generate Code: Settings')
+        self.setWindowIcon(hou.qt.Icon('MISC_python', 32, 32))
+        self.resize(400, 200)
+
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(4, 4, 4, 4)
+        main_layout.setSpacing(4)
+
+        self.brief_toggle = QCheckBox('Brief')
+        self.brief_toggle.setToolTip('Do not set values if they are the parameter’s default. '
+                                     'Applies to the contents of the node if either recurse '
+                                     'or save_box_contents is True.')
+        self.brief_toggle.setChecked(True)
+        main_layout.addWidget(self.brief_toggle)
+
+        self.recurse_toggle = QCheckBox('Recurse')
+        self.recurse_toggle.setToolTip('Recursively apply to the entire operator hierarchy.')
+        self.recurse_toggle.setChecked(False)
+        main_layout.addWidget(self.recurse_toggle)
+
+        self.save_box_contents_toggle = QCheckBox('Save box contents')
+        self.save_box_contents_toggle.setToolTip('Script the contents of the node.')
+        self.save_box_contents_toggle.setChecked(False)
+        main_layout.addWidget(self.save_box_contents_toggle)
+
+        self.save_channels_only_toggle = QCheckBox('Save channels only')
+        self.save_channels_only_toggle.setToolTip('Only output channels. '
+                                                  'Applies to the contents of the node '
+                                                  'if either recurse or save_box_contents is True.')
+        self.save_channels_only_toggle.setChecked(True)
+        main_layout.addWidget(self.save_channels_only_toggle)
+
+        self.save_creation_commands_toggle = QCheckBox('Save creation commands')
+        self.save_creation_commands_toggle.setToolTip('Generate a creation script for the node. '
+                                                      'If set to False, the generated script assumes '
+                                                      'that the network box already exists. When set '
+                                                      'to True, the script will begin by creating the '
+                                                      'network box.')
+        self.save_creation_commands_toggle.setChecked(True)
+        main_layout.addWidget(self.save_creation_commands_toggle)
+
+        self.save_keys_in_frames_toggle = QCheckBox('Save keys in frames')
+        self.save_keys_in_frames_toggle.setToolTip('Output channel and key times in samples (frames) '
+                                                   'instead of seconds. Applies to the contents of the '
+                                                   'node if either recurse or save_box_contents is True.')
+        self.save_keys_in_frames_toggle.setChecked(False)
+        main_layout.addWidget(self.save_keys_in_frames_toggle)
+
+        self.save_outgoing_wires_toggle = QCheckBox('Save outgoing wires')
+        self.save_outgoing_wires_toggle.setChecked(False)
+        main_layout.addWidget(self.save_outgoing_wires_toggle)
+
+        self.save_parm_values_only_toggle = QCheckBox('Save parm values only')
+        self.save_parm_values_only_toggle.setToolTip('Evaluate parameters, saving their values '
+                                                     'instead of the expressions. Applies to the contents '
+                                                     'of the node if either recurse or save_box_contents '
+                                                     'is True.')
+        self.save_parm_values_only_toggle.setChecked(False)
+        main_layout.addWidget(self.save_parm_values_only_toggle)
+
+        self.save_spare_parms_toggle = QCheckBox('Save spare parms')
+        self.save_spare_parms_toggle.setToolTip('Save spare parameters as well. When save_creation_commands '
+                                                'is True, commands for creating spare parameters will also '
+                                                'be output. Applies to the contents of the node if either '
+                                                'recurse or save_box_contents is True.')
+        self.save_spare_parms_toggle.setChecked(True)
+        main_layout.addWidget(self.save_spare_parms_toggle)
+
+        self.function_name_field = QLineEdit()
+        self.function_name_field.setPlaceholderText('Function name')
+        self.function_name_field.setToolTip('If a function_name is specified, the output will be wrapped '
+                                            'in a Python function.')
+        main_layout.addWidget(self.function_name_field)
+
+        main_layout.addSpacerItem(QSpacerItem(0, 0, QSizePolicy.Ignored, QSizePolicy.Expanding))
+
+        action_layout = QHBoxLayout()
+        action_layout.setContentsMargins(0, 0, 0, 0)
+        action_layout.setSpacing(4)
+        main_layout.addLayout(action_layout)
+
+        action_layout.addSpacerItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Ignored))
+
+        generate_label = QLabel('Generate and ')
+        action_layout.addWidget(generate_label)
+
+        self.show_button = QPushButton('Show')
+        self.show_button.setToolTip('Open in internal Houdini editor')
+        self.show_button.clicked.connect(self.onShowClicked)
+        action_layout.addWidget(self.show_button)
+
+        self.open_button = QPushButton('Open')
+        self.show_button.setToolTip('Open in external editor')
+        self.open_button.clicked.connect(self.onOpenClicked)
+        action_layout.addWidget(self.open_button)
+
+        self.copy_button = QPushButton('Copy')
+        self.copy_button.setToolTip('Copy to the system clipboard')
+        self.copy_button.clicked.connect(self.onCopyClicked)
+        action_layout.addWidget(self.copy_button)
+
+    def options(self):
+        return {
+            'brief': self.brief_toggle.isChecked(),
+            'recurse': self.recurse_toggle.isChecked(),
+            'save_channels_only': self.save_channels_only_toggle.isChecked(),
+            'save_creation_commands': self.save_creation_commands_toggle.isChecked(),
+            'save_keys_in_frames': self.save_keys_in_frames_toggle.isChecked(),
+            'save_outgoing_wires': self.save_outgoing_wires_toggle.isChecked(),
+            'save_parm_values_only': self.save_parm_values_only_toggle.isChecked(),
+            'save_spare_parms': self.save_spare_parms_toggle.isChecked(),
+            'function_name': self.function_name_field.text()  # Todo: validate
+        }
+
+    def onShowClicked(self):
+        generateCode(ActionType.Internal, self._node, self.options())
+        self.accept()
+
+    def onOpenClicked(self):
+        generateCode(ActionType.External, self._node, self.options())
+        self.accept()
+
+    def onCopyClicked(self):
+        generateCode(ActionType.Copy, self._node, self.options())
+        self.accept()
+
+
+def showGenerateCode(**kwargs):
+    if kwargs['altclick']:
+        window = GenerateCodeSettings(kwargs.get('node'), hou.qt.mainWindow())
+        window.show()
     else:
-        hou.ui.copyTextToClipboard(code)
-        hou.ui.setStatusMessage('Code was generated and copied',
-                                hou.severityType.ImportantMessage)
+        generateCode(ActionType.byKWARGS(**kwargs), kwargs.get('node'))
diff --git a/python2.7libs/houdini_tdk/hda_doctor.py b/python2.7libs/houdini_tdk/hda_doctor.py
new file mode 100644
index 0000000..f61e026
--- /dev/null
+++ b/python2.7libs/houdini_tdk/hda_doctor.py
@@ -0,0 +1,745 @@
+"""
+Tool Development Kit for SideFX Houdini
+Copyright (C) 2021  Ivan Titov
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+"""
+
+from __future__ import print_function
+
+import getpass
+
+try:
+    from PyQt5.QtWidgets import *
+    from PyQt5.QtGui import *
+    from PyQt5.QtCore import *
+
+    Signal = pyqtSignal
+except ImportError:
+    from PySide2.QtWidgets import *
+    from PySide2.QtGui import *
+    from PySide2.QtCore import *
+
+import hou
+
+WARNING_ICON = hou.qt.Icon('STATUS_warning', 16, 16)
+WEAK_WARNING_ICON = QIcon(WARNING_ICON.pixmap(QSize(16, 16), QIcon.Disabled, QIcon.On))
+ERROR_ICON = hou.qt.Icon('STATUS_error', 16, 16)
+
+DEFINITION_ICON = hou.qt.Icon('MISC_digital_asset', 16, 16)
+PARAMETERS_ICON = hou.qt.Icon('PANETYPES_parameters', 16, 16)
+NETWORK_ICON = hou.qt.Icon('PANETYPES_network', 16, 16)
+
+
+class Scope:
+    Any = 0b1111
+    DefinitionName = 1
+    Definition = 2
+    Parameters = 4
+    Network = 8
+
+
+class SeverityType:
+    Any = 0b111
+    WeakWarning = 1
+    Warning = 2
+    Error = 4
+
+
+class FixVariant:
+    def __init__(self, text, description):
+        self.text = text
+        self.description = description
+
+
+class Inspection(object):
+    _inspections = []
+
+    @staticmethod
+    def addInspection(inspection):
+        Inspection._inspections.append(inspection)
+
+    @staticmethod
+    def allInspections():
+        return tuple(Inspection._inspections)
+
+    @staticmethod
+    def inspections(scope=Scope.Any, severity=SeverityType.Any):
+        for inspection in Inspection._inspections:
+            if inspection.scope() & scope and inspection.severity() & severity:
+                yield inspection
+
+    @classmethod
+    def name(cls):
+        raise NotImplementedError
+
+    @classmethod
+    def description(cls):
+        raise NotImplementedError
+
+    @classmethod
+    def scope(cls):
+        raise NotImplementedError
+
+    @classmethod
+    def severity(cls):
+        raise NotImplementedError
+
+    @classmethod
+    def inspect(cls, definition):
+        raise NotImplementedError
+
+    @classmethod
+    def canBeFixedAutomatically(cls):
+        return False
+
+    @classmethod
+    def canBeFixed(cls):
+        return cls.canBeFixedAutomatically()
+
+    @classmethod
+    def fixVariants(cls, definition):
+        raise NotImplementedError
+
+    @classmethod
+    def fix(cls, definition, variant=0, user_value=None):
+        raise NotImplementedError
+
+
+def registerInspection(cls):
+    Inspection.addInspection(cls)
+    return cls
+
+
+class HDANameInspection(Inspection):
+    @classmethod
+    def scope(cls):
+        return Scope.DefinitionName
+
+    @classmethod
+    def inspect(cls, namespace, name, version):
+        raise NotImplementedError
+
+    @classmethod
+    def fixVariants(cls, namespace, name, version):
+        raise NotImplementedError
+
+    @classmethod
+    def fix(cls, namespace, name, version, variant=0, user_value=None):
+        raise NotImplementedError
+
+
+class ParmInspection(Inspection):
+    @classmethod
+    def scope(cls):
+        return Scope.Parameters
+
+    @classmethod
+    def inspect(cls, parm):
+        raise NotImplementedError
+
+    @classmethod
+    def fixVariants(cls, parm):
+        raise NotImplementedError
+
+    @classmethod
+    def fix(cls, parm, variant=0, user_value=None):
+        raise NotImplementedError
+
+
+@registerInspection
+class DefNamespaceMissing(HDANameInspection):
+    @classmethod
+    def name(cls):
+        return 'Missing HDA namespace'
+
+    @classmethod
+    def description(cls):
+        return 'This inspection detects missing HDA namespace.'
+
+    @classmethod
+    def severity(cls):
+        return SeverityType.Warning
+
+    @classmethod
+    def inspect(cls, namespace, name, version):
+        return not namespace.strip()
+
+    @classmethod
+    def canBeFixed(cls):
+        return True
+
+    @staticmethod
+    def _namespaceFromUserName():
+        return getpass.getuser().replace(' ', '_').lower()
+
+    @classmethod
+    def fixVariants(cls, namespace, name, version):
+        return [
+            FixVariant(cls._namespaceFromUserName(), 'User name from OS.'),
+            None
+        ]
+
+    @classmethod
+    def fix(cls, namespace, name, version, variant=0, user_value=None):
+        if variant == 0:
+            namespace = cls._namespaceFromUserName()
+        elif variant == 1 and user_value and isinstance(user_value, str):
+            namespace = user_value
+        else:
+            raise ValueError
+
+        fixed_name = '::'.join([namespace, name, version])
+        return fixed_name
+
+
+@registerInspection
+class DefNamespaceWrongCase(HDANameInspection):
+    @classmethod
+    def name(cls):
+        return 'Wrong HDA namespace case'
+
+    @classmethod
+    def description(cls):
+        return 'This inspection detects wrong HDA namespace case.'
+
+    @classmethod
+    def severity(cls):
+        return SeverityType.Warning
+
+    @classmethod
+    def inspect(cls, namespace, name, version):
+        if not namespace:
+            return
+
+        for char in namespace:
+            if char.isalpha() and char.isupper():
+                return True
+
+        return False
+
+    @classmethod
+    def canBeFixedAutomatically(cls):
+        return True
+
+    @classmethod
+    def fixVariants(cls, namespace, name, version):
+        return [
+            FixVariant(namespace.lower(), 'Case lowered.')
+        ]
+
+    @classmethod
+    def fix(cls, namespace, name, version, variant=0, user_value=None):
+        if variant == 0:
+            namespace = cls._userName()
+        elif variant == 1 and user_value and isinstance(user_value, str):
+            namespace = user_value
+        else:
+            raise ValueError  # Todo: reflect current inspection in message
+
+        fixed_name = '::'.join([namespace, name, version])
+        return fixed_name
+
+
+@registerInspection
+class DefNameWrongCase(HDANameInspection):
+    @classmethod
+    def name(cls):
+        return 'Wrong HDA name case'
+
+    @classmethod
+    def description(cls):
+        return 'This inspection detects wrong HDA name case.'
+
+    @classmethod
+    def severity(cls):
+        return SeverityType.Warning
+
+    @classmethod
+    def inspect(cls, namespace, name, version):
+        if not name:
+            return
+
+        for char in name:
+            if char.isalpha() and char.isupper():
+                return True
+
+        return False
+
+    @classmethod
+    def canBeFixedAutomatically(cls):
+        return True
+
+    @classmethod
+    def fixVariants(cls, namespace, name, version):
+        return [
+            FixVariant(name.lower(), 'Case lowered.')
+        ]
+
+    @classmethod
+    def fix(cls, namespace, name, version, variant=0, user_value=None):
+        return '::'.join([namespace, name.lower(), version])
+
+
+@registerInspection
+class DefVersionMissing(HDANameInspection):
+    @classmethod
+    def name(cls):
+        return 'Missing HDA version'
+
+    @classmethod
+    def description(cls):
+        return 'This inspection detects missing HDA version.'
+
+    @classmethod
+    def severity(cls):
+        return SeverityType.WeakWarning
+
+    @classmethod
+    def inspect(cls, namespace, name, version):
+        return not version.strip()
+
+    @classmethod
+    def canBeFixedAutomatically(cls):
+        return True
+
+    @classmethod
+    def fixVariants(cls, definition):
+        return [
+            FixVariant('Set 1.0', 'Default first version.'),
+            None
+        ]
+
+    @classmethod
+    def fix(cls, namespace, name, version, variant=0, user_value=None):
+        if variant == 0:
+            version = '1.0'
+        elif variant == 1 and user_value:
+            version = user_value
+        else:
+            raise ValueError
+
+        return '::'.join([namespace, name, version])
+
+
+@registerInspection
+class DefVersionWrongCase(HDANameInspection):
+    @classmethod
+    def name(cls):
+        return 'Wrong HDA version case'
+
+    @classmethod
+    def description(cls):
+        return 'Version has characters with wrong case.'
+
+    @classmethod
+    def severity(cls):
+        return SeverityType.Warning
+
+    @classmethod
+    def inspect(cls, namespace, name, version):
+        if not version:
+            return
+
+        for char in version:
+            if char.isalpha() and char.isupper():
+                return True
+
+        return False
+
+    @classmethod
+    def canBeFixedAutomatically(cls):
+        return True
+
+    @classmethod
+    def fixVariants(cls, namespace, name, version):
+        return [
+            FixVariant(version.lower(), 'Case lowered.'),
+            None
+        ]
+
+    @classmethod
+    def fix(cls, namespace, name, version, variant=0, user_value=None):
+        return '::'.join([namespace, name, version.lower()])
+
+
+@registerInspection
+class DefLabelMissing(Inspection):
+    @classmethod
+    def name(cls):
+        return 'Missing HDA label'
+
+    @classmethod
+    def description(cls):
+        return 'This inspection detects missing HDA label.'
+
+    @classmethod
+    def scope(cls):
+        return Scope.Definition
+
+    @classmethod
+    def severity(cls):
+        return SeverityType.Warning
+
+    @classmethod
+    def inspect(cls, definition):
+        return not definition.description().strip()
+
+    @classmethod
+    def canBeFixedAutomatically(cls):
+        return True
+
+    @staticmethod
+    def _newLabelFromHDAName():
+        node_type = definition.nodeType()
+        _, _, name, _ = node_type.nameComponents()
+        return name.replace('_', ' ').title()
+
+    @classmethod
+    def fixVariants(cls, definition):
+        return [
+            FixVariant(cls._newLabelFromHDAName(), 'Label from HDA name.'),
+            None
+        ]
+
+    @classmethod
+    def fix(cls, definition, variant=0, value=None):
+        if variant == 0:
+            definition.setDescription(cls._newLabelFromHDAName())
+        elif variant == 1 and value:  # Todo: Simplify
+            definition.setDescription(value)
+        else:
+            raise ValueError
+
+
+@registerInspection
+class DefIconMissing(Inspection):
+    @classmethod
+    def name(cls):
+        return 'Missing HDA icon'
+
+    @classmethod
+    def description(cls):
+        return 'This inspection detects missing HDA icon.'
+
+    @classmethod
+    def scope(cls):
+        return Scope.Definition
+
+    @classmethod
+    def severity(cls):
+        return SeverityType.WeakWarning
+
+    @classmethod
+    def inspect(cls, definition):
+        return not bool(definition.icon().strip())
+
+    @classmethod
+    def canBeFixed(cls):
+        return True
+
+    @classmethod
+    def fixVariants(cls, definition):
+        return [
+            None
+        ]
+
+    @classmethod
+    def fix(cls, definition, variant=0, user_value=None):
+        if user_value:
+            definition.setIcon(user_value)
+        else:
+            raise ValueError
+
+
+class InspectionsModel(QAbstractItemModel):
+    def __init__(self, parent=None):
+        super(InspectionsModel, self).__init__(parent)
+
+        self._data = ()
+        self.updateData()
+
+    def updateData(self):
+        self.beginResetModel()
+        self._data = Inspection.allInspections()
+        self.endResetModel()
+
+    def parent(self, index):
+        return QModelIndex()
+
+    def columnCount(self, parent):
+        return 2
+
+    def headerData(self, section, orientation, role):
+        if orientation != Qt.Horizontal:
+            return
+
+        if role == Qt.DisplayRole:
+            return ('Name', 'Description')[section]
+        elif role == Qt.TextAlignmentRole:
+            return Qt.AlignCenter
+
+    def rowCount(self, parent):
+        if not parent.isValid():
+            return len(self._data)
+        else:
+            return 0
+
+    def index(self, row, column, parent):
+        if not self.hasIndex(row, column, parent):
+            return QModelIndex()
+
+        if not parent.isValid():
+            inspection = self._data[row]
+            return self.createIndex(row, column, inspection)
+        else:
+            return QModelIndex()
+
+    def flags(self, index):
+        return Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable | Qt.ItemNeverHasChildren
+
+    def data(self, index, role):
+        if not index.isValid():
+            return
+
+        inspection = self._data[index.row()]
+
+        if index.column() == 0:
+            if role == Qt.DisplayRole:
+                return inspection.name()
+            elif role == Qt.CheckStateRole:
+                return Qt.Checked
+            elif role == Qt.DecorationRole:
+                return {
+                    SeverityType.WeakWarning: WEAK_WARNING_ICON,
+                    SeverityType.Warning: WARNING_ICON,
+                    SeverityType.Error: ERROR_ICON
+                }[inspection.severity()]
+        elif index.column() == 1:
+            if role == Qt.DisplayRole:
+                return inspection.description()
+
+
+class InspectionsView(QTreeView):
+    def __init__(self):
+        super(InspectionsView, self).__init__()
+
+        header = self.header()
+        header.setSectionsMovable(False)
+        header.setSectionResizeMode(QHeaderView.ResizeToContents)
+
+        self.setUniformRowHeights(True)
+
+        self.setRootIsDecorated(False)
+
+
+class AnalysesModel(QAbstractItemModel):
+    def __init__(self, parent=None):
+        super(AnalysesModel, self).__init__(parent)
+
+        self._data = ([], {}, {})
+
+    def updateData(self, node):
+        self.beginResetModel()
+
+        self._data = [], {}, {}
+        parts, parms, nodes = self._data
+
+        node_type = node.type()
+        definition = node_type.definition()
+        if not definition:
+            self.endResetModel()
+            return
+        _, namespace, name, version = node_type.nameComponents()
+
+        for inspection in Inspection.inspections(Scope.DefinitionName):
+            if inspection.inspect(namespace, name, version):
+                parts.append(inspection)
+
+        for inspection in Inspection.inspections(Scope.Definition):
+            if inspection.inspect(definition):
+                parts.append(inspection)
+
+        for inspection in Inspection.inspections(Scope.Parameters):
+            for parm in node.parms():
+                if inspection.inspect(parm):
+                    if inspection in parms:
+                        parms[inspection].append(parm)
+                    else:
+                        parms[inspection] = []
+
+        # for inspection in Inspection.inspections(Scope.Network):
+        #     pass
+
+        self.endResetModel()
+
+    def hasChildren(self, parent):
+        if not parent.isValid():
+            return True
+
+        if isinstance(parent.internalPointer(), (list, dict)):
+            return True
+
+        return False
+
+    def parent(self, index):
+        if not index.isValid():  # Root
+            return QModelIndex()
+
+        if isinstance(index.internalPointer(), (list, dict)):
+            return QModelIndex()
+        else:
+            data = index.internalPointer()
+            if data in self._data[0]:
+                return self.createIndex(0, 0, self._data[0])
+            elif data in self._data[1]:
+                return self.createIndex(1, 0, self._data[1])
+            elif data in self._data[2]:
+                return self.createIndex(2, 0, self._data[2])
+            else:
+                return QModelIndex()
+
+    def columnCount(self, parent):
+        return 1
+
+    def rowCount(self, parent):
+        if not parent.isValid():  # Level 1
+            return 3
+
+        if not parent.parent().isValid():  # Level 2
+            row = parent.row()
+            if 0 <= row <= 2:
+                return len(self._data[row])
+            else:
+                return 0
+
+        return 0
+
+    def index(self, row, column, parent):
+        if not self.hasIndex(row, column, parent):
+            return QModelIndex()
+
+        if not parent.isValid():  # Level 1
+            return self.createIndex(row, column, self._data[row])
+        else:  # Level 2
+            data = parent.internalPointer()
+            if parent.row() == 0:
+                return self.createIndex(row, column, self._data[parent.row()][row])
+            elif parent.row() == 1:
+                return self.createIndex(row, column,
+                                        self._data[parent.row()][tuple(self._data[parent.row()].keys())[row]])
+            elif isinstance(data, list):
+                return self.createIndex(row, column, data[row])
+            else:
+                return self.createIndex(row, column, data.keys()[row])
+
+    def flags(self, index):
+        if isinstance(index.internalPointer(), Inspection):
+            return Qt.ItemIsEnabled | Qt.ItemIsSelectable  # | Qt.ItemIsUserCheckable
+        else:
+            return Qt.ItemIsEnabled | Qt.ItemIsSelectable
+
+    def data(self, index, role):
+        if not index.isValid():  # Root
+            return
+
+        column = index.column()
+        row = index.row()
+        data = index.internalPointer()
+
+        if column == 0:
+            if isinstance(data, (list, dict)):
+                if role == Qt.DisplayRole:
+                    return ('Definition', 'Parameters', 'Network')[row]
+                elif role == Qt.ToolTipRole:
+                    return (
+                        'HDA definition-related inspections.',
+                        'Parameters-related inspections.',
+                        'Nodes-related inspections.'
+                    )[row]
+                elif role == Qt.DecorationRole:
+                    return (DEFINITION_ICON, PARAMETERS_ICON, NETWORK_ICON)[row]
+            else:
+                if role == Qt.DisplayRole:
+                    return data.name()
+                elif role == Qt.ToolTipRole:
+                    return data.description()
+                elif role == Qt.DecorationRole:
+                    return {
+                        SeverityType.WeakWarning: WEAK_WARNING_ICON,
+                        SeverityType.Warning: WARNING_ICON,
+                        SeverityType.Error: ERROR_ICON
+                    }[data.severity()]
+                elif role == Qt.CheckStateRole:
+                    return Qt.Checked
+
+
+class AnalysesView(QTreeView):
+    def __init__(self):
+        super(AnalysesView, self).__init__()
+
+        header = self.header()
+        header.setSectionsMovable(False)
+        header.setSectionResizeMode(QHeaderView.ResizeToContents)
+        header.hide()
+
+        self.setUniformRowHeights(True)
+
+        self.setRootIsDecorated(False)
+
+
+class HDADoctorWindow(QWidget):
+    def __init__(self, parent=None):
+        super(HDADoctorWindow, self).__init__(parent, Qt.Window)
+
+        self.setWindowTitle('HDA Doctor Beta')
+        self.setWindowIcon(hou.qt.Icon('SOP_polydoctor', 32, 32))
+        self.resize(600, 600)
+
+        # Layout
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(4, 4, 4, 4)
+        main_layout.setSpacing(4)
+
+        node_layout = QHBoxLayout()
+        node_layout.setContentsMargins(0, 0, 0, 0)
+        node_layout.setSpacing(4)
+        main_layout.addLayout(node_layout)
+
+        # Node Field
+        node_field = hou.qt.InputField(hou.qt.InputField.StringType, 1, 'Node')
+        node_layout.addWidget(node_field)
+
+        choose_node_button = hou.qt.NodeChooserButton()
+        choose_node_button.nodeSelected.connect(lambda node: node_field.setValue(node.path()))
+        node_layout.addWidget(choose_node_button)
+
+        # Tabs
+        tab_widget = QTabWidget()
+        main_layout.addWidget(tab_widget)
+
+        self.analyses_view = AnalysesView()
+        self.analyses_model = AnalysesModel()
+        choose_node_button.nodeSelected.connect(self.updateData)
+        self.analyses_view.setModel(self.analyses_model)
+        tab_widget.addTab(self.analyses_view, hou.qt.Icon('VOP_usdprimvarreader', 16, 16), 'Analyses')
+
+        inspections_view = InspectionsView()
+        model = InspectionsModel()
+        inspections_view.setModel(model)
+        tab_widget.addTab(inspections_view, hou.qt.Icon('STATUS_warning', 16, 16), 'Inspections')
+
+    def updateData(self, node):
+        self.analyses_model.updateData(node)
+        self.analyses_view.expandAll()
diff --git a/python2.7libs/houdini_tdk/make_hda_from_template.py b/python2.7libs/houdini_tdk/make_hda_by_template.py
similarity index 78%
rename from python2.7libs/houdini_tdk/make_hda_from_template.py
rename to python2.7libs/houdini_tdk/make_hda_by_template.py
index 4337d01..7ad5555 100644
--- a/python2.7libs/houdini_tdk/make_hda_from_template.py
+++ b/python2.7libs/houdini_tdk/make_hda_by_template.py
@@ -1,6 +1,6 @@
 """
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -34,10 +34,12 @@
 import hou
 
 from .find_icon import FindIconDialog
+from .notification import notify
 
 
 def makeNewHDAFromTemplateNode(template_node, label, name=None, namespace=None, icon=None,
-                               sections=None, version='1.0', location='$HOUDINI_USER_PREF_DIR/otls'):
+                               sections=None, version='1.0', location='$HOUDINI_USER_PREF_DIR/otls',
+                               inherit_subnetwork=True):
     template_node_type = template_node.type()
     if template_node_type.name() != 'tdk::template':
         raise TypeError
@@ -71,6 +73,9 @@ def makeNewHDAFromTemplateNode(template_node, label, name=None, namespace=None,
 
     new_def = hou.hda.definitionsInFile(new_hda_file_path)[0]
 
+    if inherit_subnetwork:
+        new_def.updateFromNode(template_node)
+
     new_def.setDescription(label)
 
     if icon:
@@ -111,20 +116,20 @@ def text(self):
         return self.edit.text()
 
     def _pickIcon(self):
-        icon = FindIconDialog.getIconName(self, 'Pick Icon')
+        icon = FindIconDialog.getIconName(self, 'Pick Icon', self.edit.text())
         if icon:
             self.edit.setText(icon.replace('.svg', ''))
 
 
 class LocationField(QWidget):
-    def __init__(self, contents=''):
+    def __init__(self, content=''):
         super(LocationField, self).__init__()
 
         layout = QHBoxLayout(self)
         layout.setContentsMargins(0, 0, 0, 0)
         layout.setSpacing(4)
 
-        self.edit = QLineEdit(contents)
+        self.edit = QLineEdit(content)
         layout.addWidget(self.edit)
 
         self.pick_location_button = QPushButton()
@@ -147,15 +152,15 @@ def _pickLocation(self):
             self.edit.setText(path)
 
 
-class MakeHDAFromTemplateDialog(QDialog):
+class MakeHDAByTemplateDialog(QDialog):
     def __init__(self, node, parent=None):
-        super(MakeHDAFromTemplateDialog, self).__init__(parent)
+        super(MakeHDAByTemplateDialog, self).__init__(parent)
 
         # Data
         self.node = node
 
-        self.setWindowTitle('TDK: HDA from Template')
-        self.setWindowIcon(hou.qt.Icon('NODEFLAGS_template', 16, 16))
+        self.setWindowTitle('TDK: HDA by Template')
+        self.setWindowIcon(hou.qt.Icon('NODEFLAGS_template', 32, 32))
         self.resize(400, 250)
 
         main_layout = QVBoxLayout(self)
@@ -192,14 +197,23 @@ def __init__(self, node, parent=None):
         self.version_field = QLineEdit('1.0')
         form_layout.addRow('Version', self.version_field)
 
+        self.inherit_subnetwork_toggle = QCheckBox('Inherit subnetwork')
+        self.inherit_subnetwork_toggle.setChecked(True)
+        form_layout.addWidget(self.inherit_subnetwork_toggle)
+
         self.install_toggle = QCheckBox('Install new HDA')
         self.install_toggle.setChecked(True)
         form_layout.addWidget(self.install_toggle)
 
-        self.replace_node = QCheckBox('Replace template node')
-        self.replace_node.setChecked(True)
-        form_layout.addWidget(self.replace_node)
-        self.install_toggle.toggled.connect(self.replace_node.setEnabled)
+        self.replace_node_toggle = QCheckBox('Replace template node')
+        self.replace_node_toggle.setChecked(True)
+        self.install_toggle.toggled.connect(self.replace_node_toggle.setEnabled)
+        form_layout.addWidget(self.replace_node_toggle)
+
+        self.open_type_properties_toggle = QCheckBox('Open type properties')
+        self.open_type_properties_toggle.setChecked(True)
+        self.install_toggle.toggled.connect(self.open_type_properties_toggle.setEnabled)
+        form_layout.addWidget(self.open_type_properties_toggle)
 
         buttons_layout = QHBoxLayout()
         main_layout.addLayout(buttons_layout)
@@ -265,25 +279,34 @@ def _onOk(self):
                                                     self.icon_field.text(),
                                                     self.sections.text(),
                                                     self.version_field.text(),
-                                                    self.location_field.path())
+                                                    self.location_field.path(),
+                                                    self.inherit_subnetwork_toggle.isChecked())
             if self.install_toggle.isChecked():
                 hou.hda.installFile(definition.libraryFilePath())
-                if self.replace_node.isChecked():
-                    self.node.changeNodeType(definition.nodeTypeName(),
-                                             keep_network_contents=False)
+                if self.replace_node_toggle.isChecked():
+                    self.node = self.node.changeNodeType(definition.nodeTypeName(),
+                                                         keep_network_contents=False)
+                if self.open_type_properties_toggle.isChecked():
+                    if self.replace_node_toggle.isChecked():
+                        hou.ui.openTypePropertiesDialog(self.node)
+                    else:
+                        hou.ui.openTypePropertiesDialog(definition.nodeType())
         self.accept()
 
 
-def showMakeHDAFromTemplateDialog(**kwargs):
+def showMakeHDAByTemplateDialog(**kwargs):
     if 'node' in kwargs:
         nodes = kwargs['node'],
     else:
         nodes = hou.selectedNodes()
     if not nodes:
-        raise hou.Error('No node selected')
+        notify('No node selected', hou.severityType.Error)
+        return
     elif len(nodes) > 1:
-        raise hou.Error('Too much nodes selected')
-    elif nodes[0].type().name() != 'tdk::template':
-        raise hou.Error('Node is not TDK Template')
-    window = MakeHDAFromTemplateDialog(nodes[0], hou.qt.mainWindow())
+        notify('Too much nodes selected', hou.severityType.Error)
+        return
+    elif not nodes[0].type().name().startswith('tdk::template'):
+        notify('Node is not TDK Template', hou.severityType.Error)
+        return
+    window = MakeHDAByTemplateDialog(nodes[0], hou.qt.mainWindow())
     window.show()
diff --git a/python2.7libs/houdini_tdk/network_statistics.py b/python2.7libs/houdini_tdk/network_statistics.py
new file mode 100644
index 0000000..045c2c3
--- /dev/null
+++ b/python2.7libs/houdini_tdk/network_statistics.py
@@ -0,0 +1,307 @@
+"""
+Tool Development Kit for SideFX Houdini
+Copyright (C) 2021  Ivan Titov
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+"""
+
+import os
+
+try:
+    from PyQt5.QtWidgets import *
+    from PyQt5.QtGui import *
+    from PyQt5.QtCore import *
+
+    Signal = pyqtSignal
+except ImportError:
+    from PySide2.QtWidgets import *
+    from PySide2.QtGui import *
+    from PySide2.QtCore import *
+
+import hou
+
+
+def parmHasExpression(parm):
+    try:
+        parm.expression()
+        return True
+    except hou.OperationFailed:
+        return False
+
+
+def parmHasCode(parm):
+    pass
+
+
+class StatItem:
+    def __init__(self, text=None, value=None, child_items=()):
+        self.text = text
+        self.value = str(value) if value is not None else None
+        self._index = None
+        self.parent = None
+        self._child_items = child_items or ()
+        for index, item in enumerate(self._child_items):
+            item.index = index
+            item.parent = self
+
+    def __getitem__(self, item):
+        return self._child_items[item]
+
+    def __len__(self):
+        return len(self._child_items)
+
+
+def gatherNetworkStats(root_node):
+    data = {
+        'nodes': {
+            'total': 0,
+            'subnetworks': 0,
+            'inside_locked': 0,
+            'max_depth': 0
+        },
+        'parms': {
+            'animated': 0,
+            'links_to': {
+                'parms': 0,
+                'nodes': 0,
+                'folders': 0,
+                'files': 0,
+                'web': 0
+            }
+        },
+        'code': {
+            'python': {
+                'total': 0,
+                'lines': 0,
+                'empty': 0,
+                'comments': 0
+            },
+            'hscript': {
+                'total': 0,
+                'lines': 0,
+                'empty': 0,
+                'comments': 0
+            },
+            'vex': {
+                'total': 0,
+                'lines': 0,
+                'empty': 0,
+                'comments': 0
+            },
+            'opencl': {
+                'total': 0,
+                'lines': 0,
+                'empty': 0,
+                'comments': 0
+            }
+        }
+    }
+
+    current_update_mode = hou.updateModeSetting()
+    hou.setUpdateMode(hou.updateMode.Manual)
+
+    for node in root_node.allSubChildren():
+        data['nodes']['total'] += 1
+
+        if node.isNetwork():
+            data['nodes']['subnetworks'] += 1
+
+        if not node.isEditable():
+            data['nodes']['inside_locked'] += 1
+
+        depth = node.path().count('/') - 1
+        max_depth = data['nodes']['max_depth']
+        data['nodes']['max_depth'] = max(depth, max_depth)
+
+        for parm in node.parms():
+            if parm.getReferencedParm() != parm:
+                data['parms']['links_to']['parms'] += 1
+
+            parm_template = parm.parmTemplate()
+            if isinstance(parm_template, hou.StringParmTemplate):
+                string_type = parm_template.stringType()
+                path = parm.evalAsString()
+                if string_type == hou.stringParmType.NodeReference:
+                    try:
+                        if parm.evalAsNode() is not None:
+                            data['parms']['links_to']['nodes'] += 1
+                    except hou.TypeError:
+                        pass
+                elif string_type == hou.stringParmType.NodeReferenceList:
+                    data['parms']['links_to']['nodes'] += len(parm.evalAsNodes())
+                elif string_type == hou.stringParmType.FileReference:
+                    if os.path.exists(path):
+                        if os.path.isdir(path):
+                            data['parms']['links_to']['folders'] += 1
+                        else:  # os.path.isfile(path)
+                            data['parms']['links_to']['files'] += 1
+                elif path.startswith('http'):
+                    data['parms']['links_to']['web'] += 1
+
+                if parmHasExpression(parm):
+                    lang = {
+                        hou.exprLanguage.Python: 'python',
+                        hou.exprLanguage.Hscript: 'hscript'
+                    }[parm.expressionLanguage()]
+                    expr = parm.expression()
+                    data['code'][lang]['total'] += 1
+                    data['code'][lang]['lines'] += expr.count('\n')
+                    data['code'][lang]['empty'] += expr.count('\n\n')
+                    for line in expr.split('\n'):
+                        line = line.lstrip()
+                        if lang == 'python' and line.startswith('#'):
+                            data['code'][lang]['comments'] += 1
+                        elif line.startswith('//'):
+                            data['code'][lang]['comments'] += 1
+
+            if len(parm.keyframes()) > 1:
+                data['parms']['animated'] += 1
+
+    hou.setUpdateMode(current_update_mode)
+
+    return data
+
+
+class NetworkStatsModel(QAbstractItemModel):
+    def __init__(self, parent=None):
+        super(NetworkStatsModel, self).__init__(parent)
+
+        self._data = StatItem()
+
+    def updateData(self, node):
+        self.beginResetModel()
+        data = gatherNetworkStats(node)
+        self._data = StatItem(None, None,
+                              [
+                                  StatItem('Nodes', None,
+                                           [
+                                               StatItem('Total', data['nodes']['total']),
+                                               StatItem('Subnetworks', data['nodes']['subnetworks']),
+                                               StatItem('Inside Locked', data['nodes']['inside_locked']),
+                                               StatItem('Maximum Depth', data['nodes']['max_depth'])
+                                           ]),
+                                  StatItem('Parameters', None,
+                                           [
+                                               StatItem('Animated', data['parms']['animated']),
+                                               StatItem('Links to', None,
+                                                        [
+                                                            StatItem('parameters', data['parms']['links_to']['parms']),
+                                                            StatItem('nodes', data['parms']['links_to']['nodes']),
+                                                            StatItem('folders', data['parms']['links_to']['folders']),
+                                                            StatItem('files', data['parms']['links_to']['files']),
+                                                            StatItem('web', data['parms']['links_to']['web'])
+                                                        ])
+                                           ])
+                                  # Todo: code stats section
+                              ])
+        self.endResetModel()
+
+    def hasChildren(self, parent):
+        if not parent.isValid():
+            return True
+
+        return bool(parent.internalPointer())
+
+    def parent(self, index):
+        if not index.isValid():
+            return QModelIndex()
+
+        item = index.internalPointer()
+        if item.text is None:
+            return QModelIndex()
+
+        return self.createIndex(item.index, 0, item.parent)
+
+    def columnCount(self, parent):
+        return 2
+
+    def rowCount(self, parent):
+        if not parent.isValid():
+            return len(self._data)
+
+        item = parent.internalPointer()
+        return len(item)
+
+    def index(self, row, column, parent):
+        if not self.hasIndex(row, column, parent):
+            return QModelIndex()
+
+        if not parent.isValid():
+            item = self._data[row]
+        else:
+            item = parent.internalPointer()[row]
+
+        return self.createIndex(row, column, item)
+
+    def flags(self, index):
+        return Qt.ItemIsEnabled | Qt.ItemIsSelectable
+
+    def data(self, index, role):
+        if not index.isValid():
+            return
+
+        column = index.column()
+        item = index.internalPointer()
+
+        if column == 0:
+            if role == Qt.DisplayRole:
+                return item.text
+        elif column == 1:
+            if role == Qt.DisplayRole:
+                return item.value
+        # Todo: column 3 - percentage
+
+
+class NetworkStatsView(QTreeView):
+    def __init__(self):
+        super(NetworkStatsView, self).__init__()
+
+        self.setWindowTitle('TDK: Network Statistics')
+
+        header = self.header()
+        header.setSectionsMovable(False)
+        header.setSectionResizeMode(QHeaderView.ResizeToContents)
+        header.hide()
+
+        self.setUniformRowHeights(True)
+
+        self.setRootIsDecorated(False)
+        self.setStyleSheet('QTreeView::branch {border-image: none; image: none;}')
+        self.setItemsExpandable(False)
+
+        model = NetworkStatsModel(self)
+        self.setModel(model)
+
+
+class NetworkStatsWindow(QDialog):
+    def __init__(self, parent=hou.qt.mainWindow()):
+        super(NetworkStatsWindow, self).__init__(parent)
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(4, 4, 4, 4)
+        layout.setSpacing(4)
+
+        self._stats_view = NetworkStatsView()
+        layout.addWidget(self._stats_view)
+
+    def updateData(self, node):
+        self._stats_view.model().updateData(node)
+        self._stats_view.expandAll()
+
+
+def showStatsForNode(node, **kwargs):
+    hou.session.window = NetworkStatsWindow()
+    hou.session.window.setWindowTitle('TDK: Network Statistics: ' + node.path())
+    hou.session.window.updateData(node)
+    hou.session.window.show()
diff --git a/python2.7libs/houdini_tdk/new_hda_version.py b/python2.7libs/houdini_tdk/new_hda_version.py
index e494f14..5f88d3a 100644
--- a/python2.7libs/houdini_tdk/new_hda_version.py
+++ b/python2.7libs/houdini_tdk/new_hda_version.py
@@ -1,6 +1,6 @@
 """
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -33,6 +33,9 @@
 
 import hou
 
+from notification import notify
+from slider import Slider
+
 
 def versionByTypeName(name):
     split_count = name.count('::')
@@ -73,21 +76,24 @@ def nextVersionTypeName(name, component):
     return new_type_name
 
 
-def incrementHDAVersion(node, component):
+def incrementHDAVersion(node, component, use_original_file):
     node_type = node.type()
-    name = node_type.name()
+    type_name = node_type.name()
 
-    new_type_name = nextVersionTypeName(name, component)
+    new_type_name = nextVersionTypeName(type_name, component)
 
     definition = node_type.definition()
-    file = definition.libraryFilePath()
-    ext = os.path.splitext(file)[-1]
-    new_file_name = new_type_name.replace(':', '_').replace('.', '_') + ext
-    new_file = os.path.join(os.path.dirname(file), new_file_name).replace('\\', '/')
-    definition.copyToHDAFile(new_file, new_type_name)
+    file_path = definition.libraryFilePath()
+    if use_original_file:
+        new_file_path = file_path
+    else:
+        ext = os.path.splitext(file_path)[-1]
+        new_file_name = new_type_name.replace(':', '_').replace('.', '_') + ext
+        new_file_path = os.path.join(os.path.dirname(file_path), new_file_name).replace('\\', '/')
+    definition.copyToHDAFile(new_file_path, new_type_name)
 
-    hou.hda.installFile(new_file)
-    new_definition = hou.hda.definitionsInFile(new_file)[0]
+    hou.hda.installFile(new_file_path)
+    new_definition = hou.hda.definitionsInFile(new_file_path)[0]  # Todo: fix potential bug
 
     new_definition.updateFromNode(node)
 
@@ -99,7 +105,7 @@ def __init__(self, node, parent=None):
         super(NewVersionDialog, self).__init__(parent, Qt.Window)
 
         self.setWindowTitle('TDK: New HDA Version')
-        self.setWindowIcon(hou.qt.Icon('BUTTONS_list_add', 16, 16))
+        self.setWindowIcon(hou.qt.Icon('BUTTONS_list_add', 32, 32))
 
         # Data
         self.node = node
@@ -124,7 +130,7 @@ def __init__(self, node, parent=None):
         form_layout.addRow('Source Name', src_name_label)
 
         # Component
-        self.comp_slider = QSlider(Qt.Horizontal)
+        self.comp_slider = Slider(Qt.Horizontal)
         self.comp_slider.setMaximum(max(3, self.src_version.count('.')))
         self.comp_slider.valueChanged.connect(self._updateDestFields)
         form_layout.addRow('Component', self.comp_slider)
@@ -133,6 +139,10 @@ def __init__(self, node, parent=None):
         self.dst_name_label = QLabel()
         form_layout.addRow('Dest Name', self.dst_name_label)
 
+        self.use_original_file_toggle = QCheckBox('Use original file')
+        self.use_original_file_toggle.stateChanged.connect(self._updateDestFields)
+        form_layout.addWidget(self.use_original_file_toggle)
+
         self.dst_file_path = QLabel()
         form_layout.addRow('Dest File Path', self.dst_file_path)
 
@@ -148,15 +158,21 @@ def __init__(self, node, parent=None):
     def _updateDestFields(self):
         new_type_name = nextVersionTypeName(self.node.type().name(), self.comp_slider.value())
         self.dst_name_label.setText(new_type_name)
-        src_location = os.path.dirname(self.node.type().definition().libraryFilePath())
-        dst_file_path = os.path.join(src_location, new_type_name.replace(':', '_').replace('.', '_')).replace('\\', '/') + '.hda'
+
+        hda_file_path = self.node.type().definition().libraryFilePath()
+
+        if self.use_original_file_toggle.isChecked():
+            dst_file_path = hda_file_path
+        else:
+            src_location = os.path.dirname(hda_file_path)
+            dst_file_name = new_type_name.replace(':', '_').replace('.', '_') + '.hda'
+            dst_file_path = os.path.join(src_location, dst_file_name).replace('\\', '/')
         self.dst_file_path.setText(dst_file_path)
 
     def _increment(self):
-        incrementHDAVersion(self.node, self.comp_slider.value())
-        hou.ui.setStatusMessage('HDA version successfully incremented',
-                                hou.severityType.ImportantMessage)
-        self.close()
+        incrementHDAVersion(self.node, self.comp_slider.value(), self.use_original_file_toggle.isChecked())
+        notify('HDA version successfully incremented')
+        self.accept()
 
 
 def showNewVersionDialog(**kwargs):
@@ -164,9 +180,13 @@ def showNewVersionDialog(**kwargs):
         nodes = kwargs['node'],
     else:
         nodes = hou.selectedNodes()
+
     if not nodes:
-        raise hou.Error('No node selected')
+        notify('No node selected', hou.severityType.Error)
+        return
     elif len(nodes) > 1:
-        raise hou.Error('Too much nodes selected')
+        notify('Too much nodes selected', hou.severityType.Error)
+        return
+
     window = NewVersionDialog(nodes[0], hou.qt.mainWindow())
     window.show()
diff --git a/python2.7libs/houdini_tdk/notification.py b/python2.7libs/houdini_tdk/notification.py
new file mode 100644
index 0000000..45b5611
--- /dev/null
+++ b/python2.7libs/houdini_tdk/notification.py
@@ -0,0 +1,32 @@
+import hou
+
+from PySide2.QtCore import QTimer
+
+
+def _removeNotification(timer, target_message, target_severity):
+    """ Works in Houdini 18.0.472+ only. """
+    try:
+        current_message, _ = hou.ui.statusMessage()
+    except AttributeError:
+        return
+
+    if target_severity == hou.severityType.Error:
+        target_message = 'Error:       ' + target_message
+    elif target_severity == hou.severityType.Warning:
+        target_message = 'Warning:     ' + target_message
+    elif target_severity == hou.severityType.Fatal:
+        target_message = 'Fatal error: ' + target_message
+
+    if current_message == target_message:
+        hou.ui.setStatusMessage('')
+
+    timer.stop()
+
+
+def notify(message, severity_type=hou.severityType.ImportantMessage, duration=2.5):
+    hou.ui.setStatusMessage(message, severity_type)
+
+    if duration:
+        timer = QTimer()
+        timer.timeout.connect(lambda: _removeNotification(timer, message, severity_type))
+        timer.start(int(duration * 1000))
diff --git a/python2.7libs/houdini_tdk/show_node_user_data.py b/python2.7libs/houdini_tdk/show_node_user_data.py
index e4fe88c..c24891e 100644
--- a/python2.7libs/houdini_tdk/show_node_user_data.py
+++ b/python2.7libs/houdini_tdk/show_node_user_data.py
@@ -1,6 +1,6 @@
 """
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -16,6 +16,8 @@
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
+import json
+
 try:
     from PyQt5.QtWidgets import *
     from PyQt5.QtGui import *
@@ -29,37 +31,58 @@
 
 import hou
 
+from notification import notify
+
+
+class UserDataItem:
+    def __init__(self, key, data, cached):
+        self.key = key
+        self.data = data
+        self.cached = cached
+
 
 class UserDataModel(QAbstractListModel):
+    DEFAULT_ICON = hou.qt.Icon('DATATYPES_file', 16, 16)
+    CACHED_DATA_ICON = hou.qt.Icon('NETVIEW_time_dependent_badge', 16, 16)
+
     def __init__(self, parent=None):
         super(UserDataModel, self).__init__(parent)
 
         # Data
-        self.__data = {}
-        self.__keys = ()
+        self.__data = []
 
-    def updateDataFromNode(self, node, cached=False):
+    def updateDataFromNode(self, node):
         self.beginResetModel()
-        if node is None:
-            self.__data = {}
-            self.__keys = ()
-        else:
-            if cached:
-                self.__data = node.cachedUserDataDict()
-            else:
-                self.__data = node.userDataDict()
-            self.__keys = tuple(self.__data.keys())
+        self.__data = []
+        if node is not None:
+            for key, data in node.userDataDict().items():
+                self.__data.append(UserDataItem(key, data, False))
+
+            for key, data in node.cachedUserDataDict().items():
+                self.__data.append(UserDataItem(key, data, True))
         self.endResetModel()
 
+    def indexByKey(self, key):
+        for index, data in enumerate(self.__data):
+            if data.key == key:
+                return self.index(index, 0)
+
+        return QModelIndex()
+
     def rowCount(self, parent):
         return len(self.__data)
 
     def data(self, index, role):
-        key = self.__keys[index.row()]
+        item = self.__data[index.row()]
         if role == Qt.DisplayRole:
-            return key
+            return item.key
+        elif role == Qt.DecorationRole:
+            if item.cached:
+                return UserDataModel.CACHED_DATA_ICON
+            else:
+                return UserDataModel.DEFAULT_ICON
         elif role == Qt.UserRole:
-            return self.__data[key]
+            return item.data
 
 
 class UserDataListView(QListView):
@@ -73,59 +96,149 @@ class UserDataWindow(QWidget):
     def __init__(self, parent=None):
         super(UserDataWindow, self).__init__(parent, Qt.Window)
 
-        self.setWindowIcon(hou.qt.Icon('TOP_jsondata', 16, 16))
+        self.setWindowIcon(hou.qt.Icon('TOP_jsondata', 32, 32))
 
         # Layout
         main_layout = QVBoxLayout(self)
         main_layout.setContentsMargins(4, 4, 4, 4)
         main_layout.setSpacing(4)
 
-        layout = QHBoxLayout()
-        layout.setContentsMargins(0, 0, 0, 0)
-        layout.setSpacing(4)
-        main_layout.addLayout(layout)
+        splitter = QSplitter(Qt.Horizontal)
+        main_layout.addWidget(splitter)
 
         # Key List
         self.user_data_model = UserDataModel()
 
         self.user_data_list = UserDataListView()
-        self.user_data_list.setMaximumWidth(120)
         self.user_data_list.setModel(self.user_data_model)
+        self.user_data_list.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
         selection_model = self.user_data_list.selectionModel()
         selection_model.currentChanged.connect(self._readData)
-        layout.addWidget(self.user_data_list)
+        splitter.addWidget(self.user_data_list)
 
         # Data View
         self.user_data_view = QTextEdit()
-        layout.addWidget(self.user_data_view)
+        splitter.addWidget(self.user_data_view)
+
+        splitter.setStretchFactor(0, 1)
+        splitter.setStretchFactor(1, 3)
 
         # Data
-        self.node = None
+        self._current_key = None
+        self._node = None
 
         # Update
-        update_button = QPushButton('Update from Node')
-        update_button.clicked.connect(lambda: self.setCurrentNode(self.node))
-        main_layout.addWidget(update_button)
+        bottom_layout = QHBoxLayout()
+        bottom_layout.setContentsMargins(0, 0, 0, 0)
+        bottom_layout.setSpacing(4)
+        main_layout.addLayout(bottom_layout)
+
+        update_button = QPushButton()
+        update_button.setToolTip('Update from Node')
+        update_button.setFixedSize(24, 24)
+        update_button.setIcon(hou.qt.Icon('NETVIEW_reload', 16, 16))
+        update_button.clicked.connect(self.updateData)
+        bottom_layout.addWidget(update_button)
+
+        self.update_timer = QTimer(self)
+        self.update_timer.setInterval(500)
+        self.update_timer.timeout.connect(self.updateData)
+
+        self.auto_update_toggle = QCheckBox('Auto Update')
+        self.auto_update_toggle.setFixedWidth(100)
+        self.auto_update_toggle.setChecked(True)
+        self.auto_update_toggle.toggled.connect(self._switchTimer)
+        bottom_layout.addWidget(self.auto_update_toggle, 0)
+
+        bottom_layout.addSpacerItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Ignored))
+
+        self.prettify_json_button = QPushButton()
+        self.prettify_json_button.setToolTip('Prettify JSON')
+        self.prettify_json_button.setFixedSize(24, 24)
+        self.prettify_json_button.setIcon(hou.qt.Icon('TOP_jsondata', 16, 16))
+        self.prettify_json_button.clicked.connect(self._prettifyJSON)
+        bottom_layout.addWidget(self.prettify_json_button)
+
+    def _updatePrettifyJSONButtonVisibility(self):
+        text = self.user_data_view.toPlainText()
+        try:
+            data = json.loads(text)
+
+            if text == json.dumps(data, indent=4):
+                raise ValueError
+
+            self.prettify_json_button.setVisible(True)
+        except ValueError:
+            self.prettify_json_button.setVisible(False)
+
+    def _prettifyJSON(self):
+        text = self.user_data_view.toPlainText()
+        try:
+            data = json.loads(text)
+            text = json.dumps(data, indent=4)
+            self.user_data_view.setPlainText(text)
+        except ValueError:
+            return
 
     def _readData(self):
         selection_model = self.user_data_list.selectionModel()
-        value = selection_model.currentIndex().data(Qt.UserRole)
-        self.user_data_view.setText(str(value))
+        index = selection_model.currentIndex()
 
-    def setCurrentNode(self, node, cached=False):
-        self.node = node
-        self.user_data_model.updateDataFromNode(node, cached)
+        if not index.isValid():
+            return
+
+        self._current_key = index.data(Qt.DisplayRole)
+        value = index.data(Qt.UserRole)
+        self.user_data_view.setText(value)
+        self._updatePrettifyJSONButtonVisibility()
+
+    def _switchTimer(self):
+        if self.update_timer.isActive():
+            self.update_timer.stop()
+        else:
+            self.update_timer.start()
+
+    # def _removeCallbacks(self):
+    #     if self.node:
+    #         node.removeEventCallback((hou.nodeEventType.CustomDataChanged,), self.updateData)
+
+    def __del__(self):
+        # self._removeCallbacks()
+        self.update_timer.stop()
+
+    def updateData(self, auto=True):
+        if auto and not self.auto_update_toggle.isChecked():
+            return
+
+        if self._node:
+            self.user_data_model.updateDataFromNode(self._node)
+
+        new_index = self.user_data_model.indexByKey(self._current_key)
+        if new_index.isValid():
+            self.user_data_list.setCurrentIndex(new_index)
+
+    def setCurrentNode(self, node):
+        if self._node:
+            self._removeCallbacks()
+
+        self._node = node
+        # node.addEventCallback((hou.nodeEventType.CustomDataChanged,), self.updateData)
+        self.update_timer.start()
+        self.updateData(False)
         self.setWindowTitle('TDK: Node User Data: ' + node.path())
 
 
-def showNodeUserData(node=None, cached=False, **kwargs):
+def showNodeUserData(node=None, **kwargs):
     if node is None:
         nodes = hou.selectedNodes()
         if not nodes:
-            raise hou.Error('No node selected')
+            notify('No node selected', hou.severityType.Error)
+            return
         elif len(nodes) > 1:
-            raise hou.Error('Too much nodes selected')
+            notify('Too much nodes selected', hou.severityType.Error)
+            return
         node = nodes[0]
+
     window = UserDataWindow(hou.qt.mainWindow())
-    window.setCurrentNode(node, cached)
+    window.setCurrentNode(node)
     window.show()
diff --git a/python2.7libs/houdini_tdk/slider.py b/python2.7libs/houdini_tdk/slider.py
new file mode 100644
index 0000000..292be8c
--- /dev/null
+++ b/python2.7libs/houdini_tdk/slider.py
@@ -0,0 +1,76 @@
+"""
+Tool Development Kit for SideFX Houdini
+Copyright (C) 2021  Ivan Titov
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+"""
+
+try:
+    from PyQt5.QtWidgets import *
+    from PyQt5.QtGui import *
+    from PyQt5.QtCore import *
+
+    Signal = pyqtSignal
+except ImportError:
+    from PySide2.QtWidgets import *
+    from PySide2.QtGui import *
+    from PySide2.QtCore import *
+
+import hou
+
+
+def isRevertToDefaultEvent(event):
+    return event.modifiers() == Qt.ControlModifier and event.button() == Qt.MiddleButton
+
+
+class Slider(QSlider):
+    def __init__(self, orientation=Qt.Horizontal, parent=None):
+        super(Slider, self).__init__(orientation, parent)
+        self._default_value = 0
+        self._value_ladder_active = False
+
+    def revertToDefault(self):
+        self.setValue(self._default_value)
+
+    def setDefaultValue(self, value):
+        if reset and self.value() == self._default_value:
+            self.setValue(value)
+        self._default_value = value
+
+    def mousePressEvent(self, event):
+        if event.button() == Qt.MiddleButton:
+            hou.ui.openValueLadder(self.value(), self.setValue,
+                                   data_type=hou.valueLadderDataType.Int)
+            self._value_ladder_active = True
+        elif event.button() == Qt.LeftButton:
+            event = QMouseEvent(QEvent.MouseButtonPress, event.pos(),
+                                Qt.MiddleButton, Qt.MiddleButton, Qt.NoModifier)
+        super(Slider, self).mousePressEvent(event)
+
+    def mouseMoveEvent(self, event):
+        if self._value_ladder_active:
+            hou.ui.updateValueLadder(event.globalX(), event.globalY(),
+                                     bool(event.modifiers() & Qt.AltModifier),
+                                     bool(event.modifiers() & Qt.ShiftModifier))
+        else:
+            super(Slider, self).mouseMoveEvent(event)
+
+    def mouseReleaseEvent(self, event):
+        if self._value_ladder_active and event.button() == Qt.MiddleButton:
+            hou.ui.closeValueLadder()
+            self._value_ladder_active = False
+        elif isRevertToDefaultEvent(event):
+            self.revertToDefault()
+        else:
+            super(Slider, self).mouseReleaseEvent(event)
diff --git a/python2.7libs/houdini_tdk/utils.py b/python2.7libs/houdini_tdk/utils.py
new file mode 100644
index 0000000..2afe248
--- /dev/null
+++ b/python2.7libs/houdini_tdk/utils.py
@@ -0,0 +1,17 @@
+import os
+import subprocess
+import sys
+import webbrowser
+
+
+def openFileLocation(file_path):
+    if not os.path.exists(file_path):
+        raise FileNotFoundError
+
+    if not os.path.isfile(file_path):
+        raise IsADirectoryError
+
+    if sys.platform.startswith('win'):
+        subprocess.call('explorer /select,"{0}"'.format(file_path.replace('/', '\\')))
+    else:
+        webbrowser.open('file://' + os.path.dirname(file_path))
diff --git a/toolbar/houdini_tdk.shelf b/toolbar/houdini_tdk.shelf
index ed92c65..9191f61 100644
--- a/toolbar/houdini_tdk.shelf
+++ b/toolbar/houdini_tdk.shelf
@@ -7,17 +7,19 @@
 
   <toolshelf name="houdini_tdk" label="Tool Development Kit">
     <memberTool name="houdini_tdk::find_icon::1.0"/>
-    <memberTool name="houdini_tdk::generate_code::1.0"/>
+    <memberTool name="houdini_tdk::generate_code::1.1"/>
     <memberTool name="houdini_tdk::increment_hda_version::1.0"/>
     <memberTool name="houdini_tdk::show_node_user_data::1.0"/>
     <memberTool name="houdini_tdk::hda_from_template::1.0"/>
+    <memberTool name="show_hda_doc"/>
+    <memberTool name="Show Net Stats"/>
   </toolshelf>
 
   <tool name="houdini_tdk::find_icon::1.0" label="Find Icon" icon="MISC_m">
     <helpText><![CDATA["""Show Find Icon window"""]]></helpText>
     <script scriptType="python"><![CDATA["""
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -33,20 +35,17 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
-import houdini_tdk
-reload(houdini_tdk)
+import houdini_tdk as tdk
 
-houdini_tdk.findIcon(**kwargs)
+tdk.findIcon(**kwargs)
 ]]></script>
   </tool>
 
-  <tool name="houdini_tdk::generate_code::1.0" label="Generate Code" icon="MISC_python">
-    <helpText><![CDATA["""Generate Python code for selected nodes and copy to clipboard.
-Use Ctrl+Click to show generated code in Code Editor instead of coping.
-Use Shift+Click to show in your default Code Editor."""]]></helpText>
+  <tool name="houdini_tdk::increment_hda_version::1.0" label="Increment HDA Version" icon="BUTTONS_list_add">
+    <helpText><![CDATA["""Increment HDA version of the selected node"""]]></helpText>
     <script scriptType="python"><![CDATA["""
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -62,18 +61,18 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
-import houdini_tdk
-reload(houdini_tdk)
+import houdini_tdk as tdk
 
-houdini_tdk.generateCode(**kwargs)
+tdk.showNewVersionDialog(**kwargs)
 ]]></script>
   </tool>
 
-  <tool name="houdini_tdk::increment_hda_version::1.0" label="Increment HDA Version" icon="BUTTONS_list_add">
-    <helpText><![CDATA["""Increment HDA version of the selected node"""]]></helpText>
+  <tool name="houdini_tdk::show_node_user_data::1.0" label="Show Node User Data" icon="TOP_jsondata">
+    <helpText><![CDATA["""Use Shift+Click to show Cached User Data of the selected node"""
+]]></helpText>
     <script scriptType="python"><![CDATA["""
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -89,19 +88,16 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
-import houdini_tdk
-reload(houdini_tdk)
+import houdini_tdk as tdk
 
-houdini_tdk.showNewVersionDialog(**kwargs)
+tdk.showNodeUserData(cached=kwargs['shiftclick'])
 ]]></script>
   </tool>
 
-  <tool name="houdini_tdk::show_node_user_data::1.0" label="Show Node User Data" icon="TOP_jsondata">
-    <helpText><![CDATA["""Use Shift+Click to show Cached User Data of the selected node"""
-]]></helpText>
+  <tool name="houdini_tdk::hda_from_template::1.0" label="Make HDA from Template" icon="NODEFLAGS_template">
     <script scriptType="python"><![CDATA["""
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -117,17 +113,20 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
-import houdini_tdk
-reload(houdini_tdk)
+import houdini_tdk as tdk
 
-houdini_tdk.showNodeUserData(cached=kwargs['shiftclick'])
+tdk.showMakeHDAFromTemplateDialog(**kwargs)
 ]]></script>
   </tool>
 
-  <tool name="houdini_tdk::hda_from_template::1.0" label="Make HDA from Template" icon="NODEFLAGS_template">
+  <tool name="houdini_tdk::generate_code::1.1" label="Generate Code" icon="MISC_python">
+    <helpText><![CDATA["""Generate Python code for selected nodes and copy to clipboard.
+Use Ctrl+Click to show generated code in Code Editor instead of coping.
+Use Shift+Click to show in your default external Code Editor.
+Use Alt+Click to set up options."""]]></helpText>
     <script scriptType="python"><![CDATA["""
 Tool Development Kit for SideFX Houdini
-Copyright (C) 2020  Ivan Titov
+Copyright (C) 2021  Ivan Titov
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -143,10 +142,9 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
-import houdini_tdk
-reload(houdini_tdk)
+import houdini_tdk as tdk
 
-houdini_tdk.showMakeHDAFromTemplateDialog(**kwargs)
+tdk.showGenerateCode(**kwargs)
 ]]></script>
   </tool>
 </shelfDocument>