diff --git a/plugins/builtin/source/content/data_processor_nodes.cpp b/plugins/builtin/source/content/data_processor_nodes.cpp
index a4a9aafdb..7710ee0eb 100644
--- a/plugins/builtin/source/content/data_processor_nodes.cpp
+++ b/plugins/builtin/source/content/data_processor_nodes.cpp
@@ -13,13 +13,14 @@
 #include <nlohmann/json.hpp>
 
 #include <imgui.h>
+#include <implot.h>
 #include <hex/ui/imgui_imhex_extensions.h>
 
 namespace hex::plugin::builtin {
 
     class NodeNullptr : public dp::Node {
     public:
-        NodeNullptr() : Node("hex.builtin.nodes.constants.nullptr.header", { dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.constants.nullptr.output") }) { }
+        NodeNullptr() : Node("hex.builtin.nodes.constants.nullptr.header", { dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "") }) { }
 
         void process() override {
             this->setBufferOnOutput(0, {});
@@ -28,7 +29,7 @@ namespace hex::plugin::builtin {
 
     class NodeBuffer : public dp::Node {
     public:
-        NodeBuffer() : Node("hex.builtin.nodes.constants.buffer.header", { dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.constants.buffer.output") }) { }
+        NodeBuffer() : Node("hex.builtin.nodes.constants.buffer.header", { dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "") }) { }
 
         void drawNode() override {
             constexpr int StepSize = 1, FastStepSize = 10;
@@ -64,7 +65,7 @@ namespace hex::plugin::builtin {
 
     class NodeString : public dp::Node {
     public:
-        NodeString() : Node("hex.builtin.nodes.constants.string.header", { dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.constants.string.output") }) {
+        NodeString() : Node("hex.builtin.nodes.constants.string.header", { dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "") }) {
             this->m_value.resize(0xFFF, 0x00);
         }
 
@@ -99,7 +100,7 @@ namespace hex::plugin::builtin {
 
     class NodeInteger : public dp::Node {
     public:
-        NodeInteger() : Node("hex.builtin.nodes.constants.int.header", { dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.constants.int.output") }) { }
+        NodeInteger() : Node("hex.builtin.nodes.constants.int.header", { dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "") }) { }
 
         void drawNode() override {
             ImGui::PushItemWidth(100);
@@ -130,7 +131,7 @@ namespace hex::plugin::builtin {
 
     class NodeFloat : public dp::Node {
     public:
-        NodeFloat() : Node("hex.builtin.nodes.constants.float.header", { dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Float, "hex.builtin.nodes.constants.float.output") }) { }
+        NodeFloat() : Node("hex.builtin.nodes.constants.float.header", { dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Float, "") }) { }
 
         void drawNode() override {
             ImGui::PushItemWidth(100);
@@ -229,7 +230,7 @@ namespace hex::plugin::builtin {
 
     class NodeDisplayInteger : public dp::Node {
     public:
-        NodeDisplayInteger() : Node("hex.builtin.nodes.display.int.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.display.int.input") }) { }
+        NodeDisplayInteger() : Node("hex.builtin.nodes.display.int.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input") }) { }
 
         void drawNode() override {
             ImGui::PushItemWidth(150);
@@ -253,7 +254,7 @@ namespace hex::plugin::builtin {
 
     class NodeDisplayFloat : public dp::Node {
     public:
-        NodeDisplayFloat() : Node("hex.builtin.nodes.display.float.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Float, "hex.builtin.nodes.display.float.input") }) { }
+        NodeDisplayFloat() : Node("hex.builtin.nodes.display.float.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Float, "hex.builtin.nodes.common.input") }) { }
 
         void drawNode() override {
             ImGui::PushItemWidth(150);
@@ -278,7 +279,7 @@ namespace hex::plugin::builtin {
 
     class NodeBitwiseNOT : public dp::Node {
     public:
-        NodeBitwiseNOT() : Node("hex.builtin.nodes.bitwise.not.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.bitwise.not.input"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.bitwise.not.output") }) { }
+        NodeBitwiseNOT() : Node("hex.builtin.nodes.bitwise.not.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto input = this->getBufferOnInput(0);
@@ -293,7 +294,7 @@ namespace hex::plugin::builtin {
 
     class NodeBitwiseAND : public dp::Node {
     public:
-        NodeBitwiseAND() : Node("hex.builtin.nodes.bitwise.and.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.bitwise.and.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.bitwise.and.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.bitwise.and.output") }) { }
+        NodeBitwiseAND() : Node("hex.builtin.nodes.bitwise.and.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getBufferOnInput(0);
@@ -310,7 +311,7 @@ namespace hex::plugin::builtin {
 
     class NodeBitwiseOR : public dp::Node {
     public:
-        NodeBitwiseOR() : Node("hex.builtin.nodes.bitwise.or.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.bitwise.or.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.bitwise.or.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.bitwise.or.output") }) { }
+        NodeBitwiseOR() : Node("hex.builtin.nodes.bitwise.or.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getBufferOnInput(0);
@@ -327,7 +328,7 @@ namespace hex::plugin::builtin {
 
     class NodeBitwiseXOR : public dp::Node {
     public:
-        NodeBitwiseXOR() : Node("hex.builtin.nodes.bitwise.xor.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.bitwise.xor.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.bitwise.xor.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.bitwise.xor.output") }) { }
+        NodeBitwiseXOR() : Node("hex.builtin.nodes.bitwise.xor.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getBufferOnInput(0);
@@ -384,7 +385,7 @@ namespace hex::plugin::builtin {
 
     class NodeCastIntegerToBuffer : public dp::Node {
     public:
-        NodeCastIntegerToBuffer() : Node("hex.builtin.nodes.casting.int_to_buffer.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.casting.int_to_buffer.input"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.casting.int_to_buffer.output") }) { }
+        NodeCastIntegerToBuffer() : Node("hex.builtin.nodes.casting.int_to_buffer.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto input = this->getIntegerOnInput(0);
@@ -398,7 +399,7 @@ namespace hex::plugin::builtin {
 
     class NodeCastBufferToInteger : public dp::Node {
     public:
-        NodeCastBufferToInteger() : Node("hex.builtin.nodes.casting.buffer_to_int.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.casting.buffer_to_int.input"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.casting.buffer_to_int.output") }) { }
+        NodeCastBufferToInteger() : Node("hex.builtin.nodes.casting.buffer_to_int.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto input = this->getBufferOnInput(0);
@@ -412,7 +413,7 @@ namespace hex::plugin::builtin {
 
     class NodeArithmeticAdd : public dp::Node {
     public:
-        NodeArithmeticAdd() : Node("hex.builtin.nodes.arithmetic.add.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.add.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.add.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.add.output") }) { }
+        NodeArithmeticAdd() : Node("hex.builtin.nodes.arithmetic.add.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getIntegerOnInput(0);
@@ -426,7 +427,7 @@ namespace hex::plugin::builtin {
 
     class NodeArithmeticSubtract : public dp::Node {
     public:
-        NodeArithmeticSubtract() : Node("hex.builtin.nodes.arithmetic.sub.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.sub.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.sub.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.sub.output") }) { }
+        NodeArithmeticSubtract() : Node("hex.builtin.nodes.arithmetic.sub.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getIntegerOnInput(0);
@@ -440,7 +441,7 @@ namespace hex::plugin::builtin {
 
     class NodeArithmeticMultiply : public dp::Node {
     public:
-        NodeArithmeticMultiply() : Node("hex.builtin.nodes.arithmetic.mul.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.mul.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.mul.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.mul.output") }) { }
+        NodeArithmeticMultiply() : Node("hex.builtin.nodes.arithmetic.mul.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getIntegerOnInput(0);
@@ -454,7 +455,7 @@ namespace hex::plugin::builtin {
 
     class NodeArithmeticDivide : public dp::Node {
     public:
-        NodeArithmeticDivide() : Node("hex.builtin.nodes.arithmetic.div.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.div.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.div.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.div.output") }) { }
+        NodeArithmeticDivide() : Node("hex.builtin.nodes.arithmetic.div.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getIntegerOnInput(0);
@@ -471,7 +472,7 @@ namespace hex::plugin::builtin {
 
     class NodeArithmeticModulus : public dp::Node {
     public:
-        NodeArithmeticModulus() : Node("hex.builtin.nodes.arithmetic.mod.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.mod.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.mod.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.arithmetic.mod.output") }) { }
+        NodeArithmeticModulus() : Node("hex.builtin.nodes.arithmetic.mod.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getIntegerOnInput(0);
@@ -488,7 +489,7 @@ namespace hex::plugin::builtin {
 
     class NodeBufferCombine : public dp::Node {
     public:
-        NodeBufferCombine() : Node("hex.builtin.nodes.buffer.combine.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.buffer.combine.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.buffer.combine.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.buffer.combine.output") }) { }
+        NodeBufferCombine() : Node("hex.builtin.nodes.buffer.combine.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input.a"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input.b"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getBufferOnInput(0);
@@ -503,7 +504,7 @@ namespace hex::plugin::builtin {
 
     class NodeBufferSlice : public dp::Node {
     public:
-        NodeBufferSlice() : Node("hex.builtin.nodes.buffer.slice.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.buffer.slice.input.buffer"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.buffer.slice.input.from"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.buffer.slice.input.to"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.buffer.slice.output") }) { }
+        NodeBufferSlice() : Node("hex.builtin.nodes.buffer.slice.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.buffer.slice.input.buffer"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.buffer.slice.input.from"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.buffer.slice.input.to"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto input = this->getBufferOnInput(0);
@@ -523,7 +524,7 @@ namespace hex::plugin::builtin {
 
     class NodeBufferRepeat : public dp::Node {
     public:
-        NodeBufferRepeat() : Node("hex.builtin.nodes.buffer.repeat.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.buffer.repeat.input.buffer"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.buffer.repeat.input.count"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.buffer.combine.output") }) { }
+        NodeBufferRepeat() : Node("hex.builtin.nodes.buffer.repeat.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.buffer.repeat.input.buffer"), dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.buffer.repeat.input.count"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto buffer = this->getBufferOnInput(0);
@@ -541,11 +542,11 @@ namespace hex::plugin::builtin {
 
     class NodeIf : public dp::Node {
     public:
-        NodeIf() : Node("ex.builtin.nodes.control_flow.if.header",
+        NodeIf() : Node("hex.builtin.nodes.control_flow.if.header",
                        { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.if.condition"),
                            dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.control_flow.if.true"),
                            dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.control_flow.if.false"),
-                           dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.control_flow.if.output") }) { }
+                           dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto cond      = this->getIntegerOnInput(0);
@@ -562,9 +563,9 @@ namespace hex::plugin::builtin {
     class NodeEquals : public dp::Node {
     public:
         NodeEquals() : Node("hex.builtin.nodes.control_flow.equals.header",
-                           { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.equals.input.a"),
-                               dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.equals.input.b"),
-                               dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.equals.output") }) { }
+                           { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.a"),
+                               dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.b"),
+                               dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getIntegerOnInput(0);
@@ -577,8 +578,8 @@ namespace hex::plugin::builtin {
     class NodeNot : public dp::Node {
     public:
         NodeNot() : Node("hex.builtin.nodes.control_flow.not.header",
-                        { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.not.input"),
-                            dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.not.output") }) { }
+                        { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input"),
+                            dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto input = this->getIntegerOnInput(0);
@@ -590,9 +591,9 @@ namespace hex::plugin::builtin {
     class NodeGreaterThan : public dp::Node {
     public:
         NodeGreaterThan() : Node("hex.builtin.nodes.control_flow.gt.header",
-                                { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.gt.input.a"),
-                                    dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.gt.input.b"),
-                                    dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.gt.output") }) { }
+                                { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.a"),
+                                    dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.b"),
+                                    dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getIntegerOnInput(0);
@@ -605,9 +606,9 @@ namespace hex::plugin::builtin {
     class NodeLessThan : public dp::Node {
     public:
         NodeLessThan() : Node("hex.builtin.nodes.control_flow.lt.header",
-                             { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.lt.input.a"),
-                                 dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.lt.input.b"),
-                                 dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.lt.output") }) { }
+                             { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.a"),
+                                 dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.b"),
+                                 dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getIntegerOnInput(0);
@@ -620,9 +621,9 @@ namespace hex::plugin::builtin {
     class NodeBoolAND : public dp::Node {
     public:
         NodeBoolAND() : Node("hex.builtin.nodes.control_flow.and.header",
-                            { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.and.input.a"),
-                                dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.and.input.b"),
-                                dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.and.output") }) { }
+                            { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.a"),
+                                dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.b"),
+                                dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getIntegerOnInput(0);
@@ -635,9 +636,9 @@ namespace hex::plugin::builtin {
     class NodeBoolOR : public dp::Node {
     public:
         NodeBoolOR() : Node("hex.builtin.nodes.control_flow.or.header",
-                           { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.or.input.a"),
-                               dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.or.input.b"),
-                               dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.control_flow.or.output") }) { }
+                           { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.a"),
+                               dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.input.b"),
+                               dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Integer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto inputA = this->getIntegerOnInput(0);
@@ -653,8 +654,8 @@ namespace hex::plugin::builtin {
                                      { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.crypto.aes.key"),
                                          dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.crypto.aes.iv"),
                                          dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.crypto.aes.nonce"),
-                                         dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.crypto.aes.input"),
-                                         dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.crypto.aes.output") }) { }
+                                         dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input"),
+                                         dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.output") }) { }
 
         void drawNode() override {
             ImGui::PushItemWidth(100);
@@ -705,7 +706,7 @@ namespace hex::plugin::builtin {
 
     class NodeDecodingBase64 : public dp::Node {
     public:
-        NodeDecodingBase64() : Node("hex.builtin.nodes.decoding.base64.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.decoding.base64.input"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.decoding.base64.output") }) { }
+        NodeDecodingBase64() : Node("hex.builtin.nodes.decoding.base64.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto input = this->getBufferOnInput(0);
@@ -718,7 +719,7 @@ namespace hex::plugin::builtin {
 
     class NodeDecodingHex : public dp::Node {
     public:
-        NodeDecodingHex() : Node("hex.builtin.nodes.decoding.hex.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.decoding.hex.input"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.decoding.hex.output") }) { }
+        NodeDecodingHex() : Node("hex.builtin.nodes.decoding.hex.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input"), dp::Attribute(dp::Attribute::IOType::Out, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.output") }) { }
 
         void process() override {
             auto input = this->getBufferOnInput(0);
@@ -754,7 +755,7 @@ namespace hex::plugin::builtin {
 
     class NodeVisualizerDigram : public dp::Node {
     public:
-        NodeVisualizerDigram() : Node("hex.builtin.nodes.visualizer.digram.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.visualizer.digram.input") }) { }
+        NodeVisualizerDigram() : Node("hex.builtin.nodes.visualizer.digram.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input") }) { }
 
         void drawNode() override {
             const auto viewSize = scaled({ 200, 200 });
@@ -837,7 +838,7 @@ namespace hex::plugin::builtin {
 
     class NodeVisualizerImage : public dp::Node {
     public:
-        NodeVisualizerImage() : Node("hex.builtin.nodes.visualizer.image.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.visualizer.image.input") }) { }
+        NodeVisualizerImage() : Node("hex.builtin.nodes.visualizer.image.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input") }) { }
 
         void drawNode() override {
             ImGui::Image(this->m_texture, scaled(ImVec2(this->m_texture.aspectRatio() * 200, 200)));
@@ -856,6 +857,38 @@ namespace hex::plugin::builtin {
         ImGui::Texture m_texture;
     };
 
+    class NodeVisualizerByteDistribution : public dp::Node {
+    public:
+        NodeVisualizerByteDistribution() : Node("hex.builtin.nodes.visualizer.byte_distribution.header", { dp::Attribute(dp::Attribute::IOType::In, dp::Attribute::Type::Buffer, "hex.builtin.nodes.common.input") }) { }
+
+        void drawNode() override {
+            ImPlot::SetNextPlotLimits(0, 256, 0.5, float(*std::max_element(this->m_counts.begin(), this->m_counts.end())) * 1.1F, ImGuiCond_Always);
+            if (ImPlot::BeginPlot("##distribution", nullptr, nullptr, scaled(ImVec2(300, 200)), ImPlotFlags_NoLegend | ImPlotFlags_NoMenus | ImPlotFlags_NoBoxSelect, ImPlotAxisFlags_Lock, ImPlotAxisFlags_Lock | ImPlotAxisFlags_LogScale, ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoTickLabels, ImPlotAxisFlags_NoLabel | ImPlotAxisFlags_NoTickLabels)) {
+                constexpr static auto x = [] {
+                    std::array<ImU64, 256> result { 0 };
+                    std::iota(result.begin(), result.end(), 0);
+                    return result;
+                }();
+
+                ImPlot::PlotBars<ImU64>("##bytes", x.data(), this->m_counts.data(), x.size(), 0.67);
+
+                ImPlot::EndPlot();
+            }
+        }
+
+        void process() override {
+            auto buffer = this->getBufferOnInput(0);
+
+            this->m_counts.fill(0x00);
+            for (const auto &byte : buffer) {
+                m_counts[byte]++;
+            }
+        }
+
+    private:
+        std::array<ImU64, 256> m_counts = { 0 };
+    };
+
     void registerDataProcessorNodes() {
         ContentRegistry::DataProcessorNode::add<NodeInteger>("hex.builtin.nodes.constants", "hex.builtin.nodes.constants.int");
         ContentRegistry::DataProcessorNode::add<NodeFloat>("hex.builtin.nodes.constants", "hex.builtin.nodes.constants.float");
@@ -905,6 +938,7 @@ namespace hex::plugin::builtin {
 
         ContentRegistry::DataProcessorNode::add<NodeVisualizerDigram>("hex.builtin.nodes.visualizer", "hex.builtin.nodes.visualizer.digram");
         ContentRegistry::DataProcessorNode::add<NodeVisualizerImage>("hex.builtin.nodes.visualizer", "hex.builtin.nodes.visualizer.image");
+        ContentRegistry::DataProcessorNode::add<NodeVisualizerByteDistribution>("hex.builtin.nodes.visualizer", "hex.builtin.nodes.visualizer.byte_distribution");
     }
 
 }
\ No newline at end of file
diff --git a/plugins/builtin/source/lang/de_DE.cpp b/plugins/builtin/source/lang/de_DE.cpp
index c27070527..f50afd641 100644
--- a/plugins/builtin/source/lang/de_DE.cpp
+++ b/plugins/builtin/source/lang/de_DE.cpp
@@ -416,23 +416,23 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.inspector.guid", "GUID" },
                 { "hex.builtin.inspector.rgba8", "RGBA8 Farbe" },
 
+                { "hex.builtin.nodes.common.input", "Input" },
+                { "hex.builtin.nodes.common.input.a", "Input A" },
+                { "hex.builtin.nodes.common.input.b", "Input B" },
+                { "hex.builtin.nodes.common.output", "Output" },
+
                 { "hex.builtin.nodes.constants", "Konstanten" },
                     { "hex.builtin.nodes.constants.int", "Integral" },
                         { "hex.builtin.nodes.constants.int.header", "Integral" },
-                        { "hex.builtin.nodes.constants.int.output", "" },
                     { "hex.builtin.nodes.constants.float", "Kommazahl" },
                         { "hex.builtin.nodes.constants.float.header", "Kommazahl" },
-                        { "hex.builtin.nodes.constants.float.output", "" },
                     { "hex.builtin.nodes.constants.nullptr", "Nullptr" },
                         { "hex.builtin.nodes.constants.nullptr.header", "Nullptr" },
-                        { "hex.builtin.nodes.constants.nullptr.output", "" },
                     { "hex.builtin.nodes.constants.buffer", "Buffer" },
                         { "hex.builtin.nodes.constants.buffer.header", "Buffer" },
                         { "hex.builtin.nodes.constants.buffer.size", "Size" },
-                        { "hex.builtin.nodes.constants.buffer.output", "" },
                     { "hex.builtin.nodes.constants.string", "String" },
                         { "hex.builtin.nodes.constants.string.header", "String" },
-                        { "hex.builtin.nodes.constants.string.output", "" },
                     { "hex.builtin.nodes.constants.rgba8", "RGBA8 Farbe" },
                         { "hex.builtin.nodes.constants.rgba8.header", "RGBA8 Farbe" },
                         { "hex.builtin.nodes.constants.rgba8.output.r", "Rot" },
@@ -467,57 +467,33 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.nodes.casting", "Datenumwandlung" },
                     { "hex.builtin.nodes.casting.int_to_buffer", "Integral zu Buffer" },
                         { "hex.builtin.nodes.casting.int_to_buffer.header", "Integral zu Buffer" },
-                        { "hex.builtin.nodes.casting.int_to_buffer.input", "In" },
-                        { "hex.builtin.nodes.casting.int_to_buffer.output", "Out" },
                 { "hex.builtin.nodes.casting.buffer_to_int", "Buffer zu Integral" },
                         { "hex.builtin.nodes.casting.buffer_to_int.header", "Buffer zu Integral" },
-                        { "hex.builtin.nodes.casting.buffer_to_int.input", "In" },
-                        { "hex.builtin.nodes.casting.buffer_to_int.output", "Out" },
 
                 { "hex.builtin.nodes.arithmetic", "Arithmetisch" },
                     { "hex.builtin.nodes.arithmetic.add", "Addition" },
                         { "hex.builtin.nodes.arithmetic.add.header", "Plus" },
-                        { "hex.builtin.nodes.arithmetic.add.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.add.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.add.output", "Output" },
                     { "hex.builtin.nodes.arithmetic.sub", "Subtraktion" },
                         { "hex.builtin.nodes.arithmetic.sub.header", "Minus" },
-                        { "hex.builtin.nodes.arithmetic.sub.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.sub.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.sub.output", "Output" },
                     { "hex.builtin.nodes.arithmetic.mul", "Multiplikation" },
                         { "hex.builtin.nodes.arithmetic.mul.header", "Mal" },
-                        { "hex.builtin.nodes.arithmetic.mul.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.mul.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.mul.output", "Output" },
                     { "hex.builtin.nodes.arithmetic.div", "Division" },
                         { "hex.builtin.nodes.arithmetic.div.header", "Durch" },
-                        { "hex.builtin.nodes.arithmetic.div.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.div.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.div.output", "Output" },
                     { "hex.builtin.nodes.arithmetic.mod", "Modulus" },
                         { "hex.builtin.nodes.arithmetic.mod.header", "Modulo" },
-                        { "hex.builtin.nodes.arithmetic.mod.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.mod.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.mod.output", "Output" },
 
                 { "hex.builtin.nodes.buffer", "Buffer" },
                     { "hex.builtin.nodes.buffer.combine", "Kombinieren" },
                         { "hex.builtin.nodes.buffer.combine.header", "Buffer kombinieren" },
-                        { "hex.builtin.nodes.buffer.combine.input.a", "Input A" },
-                        { "hex.builtin.nodes.buffer.combine.input.b", "Input B" },
-                        { "hex.builtin.nodes.buffer.combine.output", "Output" },
                     { "hex.builtin.nodes.buffer.slice", "Zerschneiden" },
                         { "hex.builtin.nodes.buffer.slice.header", "Buffer zerschneiden" },
                         { "hex.builtin.nodes.buffer.slice.input.buffer", "Input" },
                         { "hex.builtin.nodes.buffer.slice.input.from", "Von" },
                         { "hex.builtin.nodes.buffer.slice.input.to", "Bis" },
-                        { "hex.builtin.nodes.buffer.slice.output", "Output" },
                     { "hex.builtin.nodes.buffer.repeat", "Wiederholen" },
                         { "hex.builtin.nodes.buffer.repeat.header", "Buffer wiederholen" },
                         { "hex.builtin.nodes.buffer.repeat.input.buffer", "Input" },
                         { "hex.builtin.nodes.buffer.repeat.input.count", "Anzahl" },
-                        { "hex.builtin.nodes.buffer.repeat.output", "Output" },
 
                 { "hex.builtin.nodes.control_flow", "Kontrollfluss" },
                     { "hex.builtin.nodes.control_flow.if", "If" },
@@ -525,67 +501,34 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.nodes.control_flow.if.condition", "Bedingung" },
                         { "hex.builtin.nodes.control_flow.if.true", "Wahr" },
                         { "hex.builtin.nodes.control_flow.if.false", "Falsch" },
-                        { "hex.builtin.nodes.control_flow.if.output", "Output" },
                     { "hex.builtin.nodes.control_flow.equals", "Gleich" },
                         { "hex.builtin.nodes.control_flow.equals.header", "Gleich" },
-                        { "hex.builtin.nodes.control_flow.equals.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.equals.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.equals.output", "Output" },
                     { "hex.builtin.nodes.control_flow.not", "Nicht" },
                         { "hex.builtin.nodes.control_flow.not.header", "Nicht" },
-                        { "hex.builtin.nodes.control_flow.not.input", "Input" },
-                        { "hex.builtin.nodes.control_flow.not.output", "Output" },
                     { "hex.builtin.nodes.control_flow.gt", "Grösser als" },
                         { "hex.builtin.nodes.control_flow.gt.header", "Grösser als" },
-                        { "hex.builtin.nodes.control_flow.gt.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.gt.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.gt.output", "Output" },
                     { "hex.builtin.nodes.control_flow.lt", "Kleiner als" },
                         { "hex.builtin.nodes.control_flow.lt.header", "Kleiner als" },
-                        { "hex.builtin.nodes.control_flow.lt.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.lt.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.lt.output", "Output" },
                     { "hex.builtin.nodes.control_flow.and", "UND" },
                         { "hex.builtin.nodes.control_flow.and.header", "Bool'sches UND" },
-                        { "hex.builtin.nodes.control_flow.and.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.and.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.and.output", "Output" },
                     { "hex.builtin.nodes.control_flow.or", "ODER" },
                         { "hex.builtin.nodes.control_flow.or.header", "Bool'sches ODER" },
-                        { "hex.builtin.nodes.control_flow.or.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.or.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.or.output", "Output" },
 
                 { "hex.builtin.nodes.bitwise", "Bitweise Operationen" },
                     { "hex.builtin.nodes.bitwise.and", "UND" },
                         { "hex.builtin.nodes.bitwise.and.header", "Bitweise UND" },
-                        { "hex.builtin.nodes.bitwise.and.input.a", "Input A" },
-                        { "hex.builtin.nodes.bitwise.and.input.b", "Input B" },
-                        { "hex.builtin.nodes.bitwise.and.output", "Output" },
                     { "hex.builtin.nodes.bitwise.or", "ODER" },
                         { "hex.builtin.nodes.bitwise.or.header", "Bitweise ODER" },
-                        { "hex.builtin.nodes.bitwise.or.input.a", "Input A" },
-                        { "hex.builtin.nodes.bitwise.or.input.b", "Input B" },
-                        { "hex.builtin.nodes.bitwise.or.output", "Output" },
                     { "hex.builtin.nodes.bitwise.xor", "Exklusiv ODER" },
                         { "hex.builtin.nodes.bitwise.xor.header", "Bitweise Exklusiv ODER" },
-                        { "hex.builtin.nodes.bitwise.xor.input.a", "Input A" },
-                        { "hex.builtin.nodes.bitwise.xor.input.b", "Input B" },
-                        { "hex.builtin.nodes.bitwise.xor.output", "Output" },
                     { "hex.builtin.nodes.bitwise.not", "Nicht" },
                         { "hex.builtin.nodes.bitwise.not.header", "Bitweise Nicht" },
-                        { "hex.builtin.nodes.bitwise.not.input", "Input" },
-                        { "hex.builtin.nodes.bitwise.not.output", "Output" },
 
                 { "hex.builtin.nodes.decoding", "Dekodieren" },
                     { "hex.builtin.nodes.decoding.base64", "Base64" },
                         { "hex.builtin.nodes.decoding.base64.header", "Base64 Dekodierer" },
-                        { "hex.builtin.nodes.decoding.base64.input", "In" },
-                        { "hex.builtin.nodes.decoding.base64.output", "Out" },
                     { "hex.builtin.nodes.decoding.hex", "Hexadezimal" },
                         { "hex.builtin.nodes.decoding.hex.header", "Hexadezimal Dekodierer" },
-                        { "hex.builtin.nodes.decoding.hex.input", "In" },
-                        { "hex.builtin.nodes.decoding.hex.output", "Out" },
 
                 { "hex.builtin.nodes.crypto", "Kryptographie" },
                     { "hex.builtin.nodes.crypto.aes", "AES Dekryptor" },
@@ -593,11 +536,16 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.nodes.crypto.aes.key", "Schlüssel" },
                         { "hex.builtin.nodes.crypto.aes.iv", "IV" },
                         { "hex.builtin.nodes.crypto.aes.nonce", "Nonce" },
-                        { "hex.builtin.nodes.crypto.aes.input", "Input" },
-                        { "hex.builtin.nodes.crypto.aes.output", "Output" },
                         { "hex.builtin.nodes.crypto.aes.mode", "Modus" },
                         { "hex.builtin.nodes.crypto.aes.key_length", "Schlüssellänge" },
 
+                { "hex.builtin.nodes.visualizer", "Visualisierung" },
+                    { "hex.builtin.nodes.visualizer.digram", "Digram" },
+                        { "hex.builtin.nodes.visualizer.digram.header", "Digram" },
+                    { "hex.builtin.nodes.visualizer.image", "Bild" },
+                        { "hex.builtin.nodes.visualizer.image.header", "Bild" },
+                    { "hex.builtin.nodes.visualizer.byte_distribution", "Byteverteilung" },
+                        { "hex.builtin.nodes.visualizer.byte_distribution.header", "Byteverteilung" },
 
 
                 { "hex.builtin.tools.demangler", "Itanium/MSVC demangler" },
diff --git a/plugins/builtin/source/lang/en_US.cpp b/plugins/builtin/source/lang/en_US.cpp
index e8598d418..ca472ba47 100644
--- a/plugins/builtin/source/lang/en_US.cpp
+++ b/plugins/builtin/source/lang/en_US.cpp
@@ -421,23 +421,23 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.inspector.guid", "GUID" },
                 { "hex.builtin.inspector.rgba8", "RGBA8 color" },
 
+                { "hex.builtin.nodes.common.input", "Input" },
+                { "hex.builtin.nodes.common.input.a", "Input A" },
+                { "hex.builtin.nodes.common.input.b", "Input B" },
+                { "hex.builtin.nodes.common.output", "Output" },
+
                 { "hex.builtin.nodes.constants", "Constants" },
                     { "hex.builtin.nodes.constants.int", "Integer" },
                         { "hex.builtin.nodes.constants.int.header", "Integer" },
-                        { "hex.builtin.nodes.constants.int.output", "" },
                     { "hex.builtin.nodes.constants.float", "Float" },
                         { "hex.builtin.nodes.constants.float.header", "Float" },
-                        { "hex.builtin.nodes.constants.float.output", "" },
                     { "hex.builtin.nodes.constants.nullptr", "Nullptr" },
                         { "hex.builtin.nodes.constants.nullptr.header", "Nullptr" },
-                        { "hex.builtin.nodes.constants.nullptr.output", "" },
                     { "hex.builtin.nodes.constants.buffer", "Buffer" },
                         { "hex.builtin.nodes.constants.buffer.header", "Buffer" },
                         { "hex.builtin.nodes.constants.buffer.size", "Size" },
-                        { "hex.builtin.nodes.constants.buffer.output", "" },
                     { "hex.builtin.nodes.constants.string", "String" },
                         { "hex.builtin.nodes.constants.string.header", "String" },
-                        { "hex.builtin.nodes.constants.string.output", "" },
                     { "hex.builtin.nodes.constants.rgba8", "RGBA8 color" },
                         { "hex.builtin.nodes.constants.rgba8.header", "RGBA8 color" },
                         { "hex.builtin.nodes.constants.rgba8.output.r", "Red" },
@@ -472,57 +472,31 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.nodes.casting", "Data conversion" },
                     { "hex.builtin.nodes.casting.int_to_buffer", "Integer to Buffer" },
                         { "hex.builtin.nodes.casting.int_to_buffer.header", "Integer to Buffer" },
-                        { "hex.builtin.nodes.casting.int_to_buffer.input", "In" },
-                        { "hex.builtin.nodes.casting.int_to_buffer.output", "Out" },
                 { "hex.builtin.nodes.casting.buffer_to_int", "Buffer to Integer" },
                         { "hex.builtin.nodes.casting.buffer_to_int.header", "Buffer to Integer" },
-                        { "hex.builtin.nodes.casting.buffer_to_int.input", "In" },
-                        { "hex.builtin.nodes.casting.buffer_to_int.output", "Out" },
 
                 { "hex.builtin.nodes.arithmetic", "Arithmetic" },
                     { "hex.builtin.nodes.arithmetic.add", "Addition" },
                         { "hex.builtin.nodes.arithmetic.add.header", "Add" },
-                        { "hex.builtin.nodes.arithmetic.add.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.add.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.add.output", "Output" },
                     { "hex.builtin.nodes.arithmetic.sub", "Subtraction" },
                         { "hex.builtin.nodes.arithmetic.sub.header", "Subtract" },
-                        { "hex.builtin.nodes.arithmetic.sub.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.sub.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.sub.output", "Output" },
                     { "hex.builtin.nodes.arithmetic.mul", "Multiplication" },
                         { "hex.builtin.nodes.arithmetic.mul.header", "Multiply" },
-                        { "hex.builtin.nodes.arithmetic.mul.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.mul.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.mul.output", "Output" },
                     { "hex.builtin.nodes.arithmetic.div", "Division" },
                         { "hex.builtin.nodes.arithmetic.div.header", "Divide" },
-                        { "hex.builtin.nodes.arithmetic.div.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.div.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.div.output", "Output" },
                     { "hex.builtin.nodes.arithmetic.mod", "Modulus" },
                         { "hex.builtin.nodes.arithmetic.mod.header", "Modulo" },
-                        { "hex.builtin.nodes.arithmetic.mod.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.mod.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.mod.output", "Output" },
 
                 { "hex.builtin.nodes.buffer", "Buffer" },
                     { "hex.builtin.nodes.buffer.combine", "Combine" },
                         { "hex.builtin.nodes.buffer.combine.header", "Combine buffers" },
-                        { "hex.builtin.nodes.buffer.combine.input.a", "Input A" },
-                        { "hex.builtin.nodes.buffer.combine.input.b", "Input B" },
-                        { "hex.builtin.nodes.buffer.combine.output", "Output" },
                     { "hex.builtin.nodes.buffer.slice", "Slice" },
                         { "hex.builtin.nodes.buffer.slice.header", "Slice buffer" },
-                        { "hex.builtin.nodes.buffer.slice.input.buffer", "Input" },
                         { "hex.builtin.nodes.buffer.slice.input.from", "From" },
                         { "hex.builtin.nodes.buffer.slice.input.to", "To" },
-                        { "hex.builtin.nodes.buffer.slice.output", "Output" },
                     { "hex.builtin.nodes.buffer.repeat", "Repeat" },
                         { "hex.builtin.nodes.buffer.repeat.header", "Repeat buffer" },
-                        { "hex.builtin.nodes.buffer.repeat.input.buffer", "Input" },
                         { "hex.builtin.nodes.buffer.repeat.input.count", "Count" },
-                        { "hex.builtin.nodes.buffer.repeat.output", "Output" },
 
                 { "hex.builtin.nodes.control_flow", "Control flow" },
                     { "hex.builtin.nodes.control_flow.if", "If" },
@@ -530,67 +504,34 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.nodes.control_flow.if.condition", "Condition" },
                         { "hex.builtin.nodes.control_flow.if.true", "True" },
                         { "hex.builtin.nodes.control_flow.if.false", "False" },
-                        { "hex.builtin.nodes.control_flow.if.output", "Output" },
                     { "hex.builtin.nodes.control_flow.equals", "Equals" },
                         { "hex.builtin.nodes.control_flow.equals.header", "Equals" },
-                        { "hex.builtin.nodes.control_flow.equals.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.equals.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.equals.output", "Output" },
                     { "hex.builtin.nodes.control_flow.not", "Not" },
                         { "hex.builtin.nodes.control_flow.not.header", "Not" },
-                        { "hex.builtin.nodes.control_flow.not.input", "Input" },
-                        { "hex.builtin.nodes.control_flow.not.output", "Output" },
                     { "hex.builtin.nodes.control_flow.gt", "Greater than" },
                         { "hex.builtin.nodes.control_flow.gt.header", "Greater than" },
-                        { "hex.builtin.nodes.control_flow.gt.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.gt.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.gt.output", "Output" },
                     { "hex.builtin.nodes.control_flow.lt", "Less than" },
                         { "hex.builtin.nodes.control_flow.lt.header", "Less than" },
-                        { "hex.builtin.nodes.control_flow.lt.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.lt.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.lt.output", "Output" },
                     { "hex.builtin.nodes.control_flow.and", "AND" },
                         { "hex.builtin.nodes.control_flow.and.header", "Boolean AND" },
-                        { "hex.builtin.nodes.control_flow.and.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.and.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.and.output", "Output" },
                     { "hex.builtin.nodes.control_flow.or", "OR" },
                         { "hex.builtin.nodes.control_flow.or.header", "Boolean OR" },
-                        { "hex.builtin.nodes.control_flow.or.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.or.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.or.output", "Output" },
 
                 { "hex.builtin.nodes.bitwise", "Bitwise operations" },
                     { "hex.builtin.nodes.bitwise.and", "AND" },
                         { "hex.builtin.nodes.bitwise.and.header", "Bitwise AND" },
-                        { "hex.builtin.nodes.bitwise.and.input.a", "Input A" },
-                        { "hex.builtin.nodes.bitwise.and.input.b", "Input B" },
-                        { "hex.builtin.nodes.bitwise.and.output", "Output" },
                     { "hex.builtin.nodes.bitwise.or", "OR" },
                         { "hex.builtin.nodes.bitwise.or.header", "Bitwise OR" },
-                        { "hex.builtin.nodes.bitwise.or.input.a", "Input A" },
-                        { "hex.builtin.nodes.bitwise.or.input.b", "Input B" },
-                        { "hex.builtin.nodes.bitwise.or.output", "Output" },
                     { "hex.builtin.nodes.bitwise.xor", "XOR" },
                         { "hex.builtin.nodes.bitwise.xor.header", "Bitwise XOR" },
-                        { "hex.builtin.nodes.bitwise.xor.input.a", "Input A" },
-                        { "hex.builtin.nodes.bitwise.xor.input.b", "Input B" },
-                        { "hex.builtin.nodes.bitwise.xor.output", "Output" },
                     { "hex.builtin.nodes.bitwise.not", "NOT" },
                         { "hex.builtin.nodes.bitwise.not.header", "Bitwise NOT" },
-                        { "hex.builtin.nodes.bitwise.not.input", "Input" },
-                        { "hex.builtin.nodes.bitwise.not.output", "Output" },
 
                 { "hex.builtin.nodes.decoding", "Decoding" },
                     { "hex.builtin.nodes.decoding.base64", "Base64" },
                         { "hex.builtin.nodes.decoding.base64.header", "Base64 decoder" },
-                        { "hex.builtin.nodes.decoding.base64.input", "In" },
-                        { "hex.builtin.nodes.decoding.base64.output", "Out" },
                     { "hex.builtin.nodes.decoding.hex", "Hexadecimal" },
                         { "hex.builtin.nodes.decoding.hex.header", "Hexadecimal decoder" },
-                        { "hex.builtin.nodes.decoding.hex.input", "In" },
-                        { "hex.builtin.nodes.decoding.hex.output", "Out" },
 
                 { "hex.builtin.nodes.crypto", "Cryptography" },
                     { "hex.builtin.nodes.crypto.aes", "AES Decryptor" },
@@ -598,18 +539,16 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.nodes.crypto.aes.key", "Key" },
                         { "hex.builtin.nodes.crypto.aes.iv", "IV" },
                         { "hex.builtin.nodes.crypto.aes.nonce", "Nonce" },
-                        { "hex.builtin.nodes.crypto.aes.input", "Input" },
-                        { "hex.builtin.nodes.crypto.aes.output", "Output" },
                         { "hex.builtin.nodes.crypto.aes.mode", "Mode" },
                         { "hex.builtin.nodes.crypto.aes.key_length", "Key length" },
 
                 { "hex.builtin.nodes.visualizer", "Visualizers" },
                     { "hex.builtin.nodes.visualizer.digram", "Digram" },
                         { "hex.builtin.nodes.visualizer.digram.header", "Digram Visualizer" },
-                        { "hex.builtin.nodes.visualizer.digram.input", "Input" },
                     { "hex.builtin.nodes.visualizer.image", "Image" },
                         { "hex.builtin.nodes.visualizer.image.header", "Image Visualizer" },
-                        { "hex.builtin.nodes.visualizer.image.input", "Input" },
+                    { "hex.builtin.nodes.visualizer.byte_distribution", "Byte Distribution" },
+                        { "hex.builtin.nodes.visualizer.byte_distribution.header", "Byte Distribution" },
 
 
                 { "hex.builtin.tools.demangler", "Itanium/MSVC demangler" },
diff --git a/plugins/builtin/source/lang/it_IT.cpp b/plugins/builtin/source/lang/it_IT.cpp
index a56fa3aa6..bd7981472 100644
--- a/plugins/builtin/source/lang/it_IT.cpp
+++ b/plugins/builtin/source/lang/it_IT.cpp
@@ -438,6 +438,11 @@ namespace hex::plugin::builtin {
                     { "hex.builtin.nodes.constants.comment", "Comment" },
                         { "hex.builtin.nodes.constants.comment.header", "Commento" },
 
+                { "hex.builtin.nodes.common.input", "Input" },
+                { "hex.builtin.nodes.common.input.a", "Input A" },
+                { "hex.builtin.nodes.common.input.b", "Input B" },
+                { "hex.builtin.nodes.common.output", "Output" },
+
                 { "hex.builtin.nodes.display", "Mostra" },
                     { "hex.builtin.nodes.display.int", "Intero" },
                         { "hex.builtin.nodes.display.int.header", "Mostra Intero" },
@@ -463,57 +468,33 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.nodes.casting", "Conversione Dati" },
                     { "hex.builtin.nodes.casting.int_to_buffer", "Da Intero a Buffer" },
                         { "hex.builtin.nodes.casting.int_to_buffer.header", "Da Intero a Buffer" },
-                        { "hex.builtin.nodes.casting.int_to_buffer.input", "Entrata" },
-                        { "hex.builtin.nodes.casting.int_to_buffer.output", "Uscita" },
                 { "hex.builtin.nodes.casting.buffer_to_int", "Da Buffer a Intero" },
                         { "hex.builtin.nodes.casting.buffer_to_int.header", "Da Buffer a Integer" },
-                        { "hex.builtin.nodes.casting.buffer_to_int.input", "Entrata" },
-                        { "hex.builtin.nodes.casting.buffer_to_int.output", "Uscita" },
 
                 { "hex.builtin.nodes.arithmetic", "Aritmetica" },
                     { "hex.builtin.nodes.arithmetic.add", "Addizione" },
                         { "hex.builtin.nodes.arithmetic.add.header", "Aggiungi" },
-                        { "hex.builtin.nodes.arithmetic.add.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.add.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.add.output", "Output" },
                     { "hex.builtin.nodes.arithmetic.sub", "Sottrazione" },
                         { "hex.builtin.nodes.arithmetic.sub.header", "Sottrai" },
-                        { "hex.builtin.nodes.arithmetic.sub.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.sub.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.sub.output", "Output" },
                         { "hex.builtin.nodes.arithmetic.mul", "Moltiplicazione" },
                         { "hex.builtin.nodes.arithmetic.mul.header", "Moltiplica" },
-                        { "hex.builtin.nodes.arithmetic.mul.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.mul.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.mul.output", "Output" },
                     { "hex.builtin.nodes.arithmetic.div", "Divisione" },
                         { "hex.builtin.nodes.arithmetic.div.header", "Dividi" },
-                        { "hex.builtin.nodes.arithmetic.div.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.div.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.div.output", "Output" },
                     { "hex.builtin.nodes.arithmetic.mod", "Modulo" },
                         { "hex.builtin.nodes.arithmetic.mod.header", "Modulo" },
-                        { "hex.builtin.nodes.arithmetic.mod.input.a", "Input A" },
-                        { "hex.builtin.nodes.arithmetic.mod.input.b", "Input B" },
-                        { "hex.builtin.nodes.arithmetic.mod.output", "Output" },
 
                 { "hex.builtin.nodes.buffer", "Buffer" },
                     { "hex.builtin.nodes.buffer.combine", "Combina" },
                         { "hex.builtin.nodes.buffer.combine.header", "Combina buffer" },
-                        { "hex.builtin.nodes.buffer.combine.input.a", "Input A" },
-                        { "hex.builtin.nodes.buffer.combine.input.b", "Input B" },
-                        { "hex.builtin.nodes.buffer.combine.output", "Output" },
                     { "hex.builtin.nodes.buffer.slice", "Affetta" },
                         { "hex.builtin.nodes.buffer.slice.header", "Affetta buffer" },
                         { "hex.builtin.nodes.buffer.slice.input.buffer", "Input" },
                         { "hex.builtin.nodes.buffer.slice.input.from", "Inizio" },
                         { "hex.builtin.nodes.buffer.slice.input.to", "Fine" },
-                        { "hex.builtin.nodes.buffer.slice.output", "Output" },
                     { "hex.builtin.nodes.buffer.repeat", "Ripeti" },
                         { "hex.builtin.nodes.buffer.repeat.header", "Ripeti buffer" },
                             { "hex.builtin.nodes.buffer.repeat.input.buffer", "Input" },
                             { "hex.builtin.nodes.buffer.repeat.input.count", "Conta" },
-                            { "hex.builtin.nodes.buffer.repeat.output", "Output" },
 
                 { "hex.builtin.nodes.control_flow", "Controlla Flusso" },
                     { "hex.builtin.nodes.control_flow.if", "Se" },
@@ -521,67 +502,34 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.nodes.control_flow.if.condition", "Condizione" },
                         { "hex.builtin.nodes.control_flow.if.true", "Vero" },
                         { "hex.builtin.nodes.control_flow.if.false", "Falso" },
-                        { "hex.builtin.nodes.control_flow.if.output", "Output" },
                     { "hex.builtin.nodes.control_flow.equals", "Uguale a" },
                         { "hex.builtin.nodes.control_flow.equals.header", "Uguale a" },
-                        { "hex.builtin.nodes.control_flow.equals.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.equals.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.equals.output", "Output" },
                     { "hex.builtin.nodes.control_flow.not", "Non" },
                         { "hex.builtin.nodes.control_flow.not.header", "Non" },
-                        { "hex.builtin.nodes.control_flow.not.input", "Input" },
-                        { "hex.builtin.nodes.control_flow.not.output", "Output" },
                     { "hex.builtin.nodes.control_flow.gt", "Maggiore di" },
                         { "hex.builtin.nodes.control_flow.gt.header", "Maggiore di" },
-                        { "hex.builtin.nodes.control_flow.gt.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.gt.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.gt.output", "Output" },
                     { "hex.builtin.nodes.control_flow.lt", "Minore di" },
                         { "hex.builtin.nodes.control_flow.lt.header", "Minore di" },
-                        { "hex.builtin.nodes.control_flow.lt.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.lt.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.lt.output", "Output" },
                     { "hex.builtin.nodes.control_flow.and", "E" },
                         { "hex.builtin.nodes.control_flow.and.header", "Boolean E" },
-                        { "hex.builtin.nodes.control_flow.and.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.and.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.and.output", "Output" },
                     { "hex.builtin.nodes.control_flow.or", "O" },
                         { "hex.builtin.nodes.control_flow.or.header", "Boolean O" },
-                        { "hex.builtin.nodes.control_flow.or.input.a", "Input A" },
-                        { "hex.builtin.nodes.control_flow.or.input.b", "Input B" },
-                        { "hex.builtin.nodes.control_flow.or.output", "Output" },
 
                 { "hex.builtin.nodes.bitwise", "Operazioni di Bitwise" },
                     { "hex.builtin.nodes.bitwise.and", "E" },
                         { "hex.builtin.nodes.bitwise.and.header", "Bitwise E" },
-                        { "hex.builtin.nodes.bitwise.and.input.a", "Input A" },
-                        { "hex.builtin.nodes.bitwise.and.input.b", "Input B" },
-                        { "hex.builtin.nodes.bitwise.and.output", "Output" },
                     { "hex.builtin.nodes.bitwise.or", "O" },
                         { "hex.builtin.nodes.bitwise.or.header", "Bitwise O" },
-                        { "hex.builtin.nodes.bitwise.or.input.a", "Input A" },
-                        { "hex.builtin.nodes.bitwise.or.input.b", "Input B" },
-                        { "hex.builtin.nodes.bitwise.or.output", "Output" },
                     { "hex.builtin.nodes.bitwise.xor", "XOR" },
                         { "hex.builtin.nodes.bitwise.xor.header", "Bitwise XOR" },
-                        { "hex.builtin.nodes.bitwise.xor.input.a", "Input A" },
-                        { "hex.builtin.nodes.bitwise.xor.input.b", "Input B" },
-                        { "hex.builtin.nodes.bitwise.xor.output", "Output" },
                     { "hex.builtin.nodes.bitwise.not", "NON" },
                         { "hex.builtin.nodes.bitwise.not.header", "Bitwise NON" },
-                        { "hex.builtin.nodes.bitwise.not.input", "Input" },
-                        { "hex.builtin.nodes.bitwise.not.output", "Output" },
 
                 { "hex.builtin.nodes.decoding", "Decodifica" },
                     { "hex.builtin.nodes.decoding.base64", "Base64" },
                         { "hex.builtin.nodes.decoding.base64.header", "Decodificatore Base64" },
-                        { "hex.builtin.nodes.decoding.base64.input", "In" },
-                        { "hex.builtin.nodes.decoding.base64.output", "Out" },
                     { "hex.builtin.nodes.decoding.hex", "Esadecimale" },
                         { "hex.builtin.nodes.decoding.hex.header", "Decodificatore Esadecimale" },
-                        { "hex.builtin.nodes.decoding.hex.input", "In" },
-                        { "hex.builtin.nodes.decoding.hex.output", "Out" },
 
                 { "hex.builtin.nodes.crypto", "Cryptografia" },
                     { "hex.builtin.nodes.crypto.aes", "Decriptatore AES" },
@@ -589,11 +537,16 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.nodes.crypto.aes.key", "Chiave" },
                         { "hex.builtin.nodes.crypto.aes.iv", "IV" },
                         { "hex.builtin.nodes.crypto.aes.nonce", "Nonce" },
-                        { "hex.builtin.nodes.crypto.aes.input", "Input" },
-                        { "hex.builtin.nodes.crypto.aes.output", "Output" },
                         { "hex.builtin.nodes.crypto.aes.mode", "Modalità" },
                         { "hex.builtin.nodes.crypto.aes.key_length", "Lunghezza Chiave" },
 
+                //{ "hex.builtin.nodes.visualizer", "Visualizers" },
+                    //{ "hex.builtin.nodes.visualizer.digram", "Digram" },
+                        //{ "hex.builtin.nodes.visualizer.digram.header", "Digram Visualizer" },
+                    //{ "hex.builtin.nodes.visualizer.image", "Image" },
+                        //{ "hex.builtin.nodes.visualizer.image.header", "Image Visualizer" },
+                    //{ "hex.builtin.nodes.visualizer.byte_distribution", "Byte Distribution" },
+                        //{ "hex.builtin.nodes.visualizer.byte_distribution.header", "Byte Distribution" },
 
 
                 { "hex.builtin.tools.demangler", "Itanium/MSVC demangler" },
diff --git a/plugins/builtin/source/lang/zh_CN.cpp b/plugins/builtin/source/lang/zh_CN.cpp
index 9e8f2c34c..0248647ad 100644
--- a/plugins/builtin/source/lang/zh_CN.cpp
+++ b/plugins/builtin/source/lang/zh_CN.cpp
@@ -414,23 +414,23 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.inspector.guid", "GUID" },
                 { "hex.builtin.inspector.rgba8", "RGBA8颜色" },
 
+                { "hex.builtin.nodes.common.input", "输入" },
+                { "hex.builtin.nodes.common.input.a", "输入A" },
+                { "hex.builtin.nodes.common.input.b", "输入B" },
+                { "hex.builtin.nodes.common.output", "输出" },
+
                 { "hex.builtin.nodes.constants", "常量" },
                     { "hex.builtin.nodes.constants.int", "整数" },
                         { "hex.builtin.nodes.constants.int.header", "整数" },
-                        { "hex.builtin.nodes.constants.int.output", "" },
                     { "hex.builtin.nodes.constants.float", "浮点数" },
                         { "hex.builtin.nodes.constants.float.header", "浮点数" },
-                        { "hex.builtin.nodes.constants.float.output", "" },
                     { "hex.builtin.nodes.constants.nullptr", "空指针" },
                         { "hex.builtin.nodes.constants.nullptr.header", "空指针" },
-                        { "hex.builtin.nodes.constants.nullptr.output", "" },
                     { "hex.builtin.nodes.constants.buffer", "缓冲区" },
                         { "hex.builtin.nodes.constants.buffer.header", "缓冲区" },
                         { "hex.builtin.nodes.constants.buffer.size", "大小" },
-                        { "hex.builtin.nodes.constants.buffer.output", "" },
                     { "hex.builtin.nodes.constants.string", "字符串" },
                         { "hex.builtin.nodes.constants.string.header", "字符串" },
-                        { "hex.builtin.nodes.constants.string.output", "" },
                     { "hex.builtin.nodes.constants.rgba8", "RGBA8颜色" },
                         { "hex.builtin.nodes.constants.rgba8.header", "RGBA8颜色" },
                         { "hex.builtin.nodes.constants.rgba8.output.r", "红" },
@@ -443,10 +443,8 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.nodes.display", "显示" },
                     { "hex.builtin.nodes.display.int", "整数" },
                         { "hex.builtin.nodes.display.int.header", "整数显示" },
-                        { "hex.builtin.nodes.display.int.input", "值" },
                     { "hex.builtin.nodes.display.float", "浮点数" },
                         { "hex.builtin.nodes.display.float.header", "浮点数显示" },
-                        { "hex.builtin.nodes.display.float.input", "值" },
 
                 { "hex.builtin.nodes.data_access", "数据访问" },
                     { "hex.builtin.nodes.data_access.read", "读取" },
@@ -465,57 +463,33 @@ namespace hex::plugin::builtin {
                 { "hex.builtin.nodes.casting", "数据转换" },
                     { "hex.builtin.nodes.casting.int_to_buffer", "整数到缓冲区" },
                         { "hex.builtin.nodes.casting.int_to_buffer.header", "整数到缓冲区" },
-                        { "hex.builtin.nodes.casting.int_to_buffer.input", "输入" },
-                        { "hex.builtin.nodes.casting.int_to_buffer.output", "输出" },
                 { "hex.builtin.nodes.casting.buffer_to_int", "缓冲区到整数" },
                         { "hex.builtin.nodes.casting.buffer_to_int.header", "缓冲区到整数" },
-                        { "hex.builtin.nodes.casting.buffer_to_int.input", "输入" },
-                        { "hex.builtin.nodes.casting.buffer_to_int.output", "输出" },
 
                 { "hex.builtin.nodes.arithmetic", "运算" },
                     { "hex.builtin.nodes.arithmetic.add", "加法" },
                         { "hex.builtin.nodes.arithmetic.add.header", "加法" },
-                        { "hex.builtin.nodes.arithmetic.add.input.a", "输入A" },
-                        { "hex.builtin.nodes.arithmetic.add.input.b", "输入B" },
-                        { "hex.builtin.nodes.arithmetic.add.output", "输出" },
                     { "hex.builtin.nodes.arithmetic.sub", "减法" },
                         { "hex.builtin.nodes.arithmetic.sub.header", "减法" },
-                        { "hex.builtin.nodes.arithmetic.sub.input.a", "输入A" },
-                        { "hex.builtin.nodes.arithmetic.sub.input.b", "输入B" },
-                        { "hex.builtin.nodes.arithmetic.sub.output", "输出" },
                     { "hex.builtin.nodes.arithmetic.mul", "乘法" },
                         { "hex.builtin.nodes.arithmetic.mul.header", "乘法" },
-                        { "hex.builtin.nodes.arithmetic.mul.input.a", "输入A" },
-                        { "hex.builtin.nodes.arithmetic.mul.input.b", "输入B" },
-                        { "hex.builtin.nodes.arithmetic.mul.output", "输出" },
                     { "hex.builtin.nodes.arithmetic.div", "除法" },
                         { "hex.builtin.nodes.arithmetic.div.header", "除法" },
-                        { "hex.builtin.nodes.arithmetic.div.input.a", "输入A" },
-                        { "hex.builtin.nodes.arithmetic.div.input.b", "输入B" },
-                        { "hex.builtin.nodes.arithmetic.div.output", "输出" },
                     { "hex.builtin.nodes.arithmetic.mod", "模数" },
                         { "hex.builtin.nodes.arithmetic.mod.header", "模数" },
-                        { "hex.builtin.nodes.arithmetic.mod.input.a", "输入A" },
-                        { "hex.builtin.nodes.arithmetic.mod.input.b", "输入B" },
-                        { "hex.builtin.nodes.arithmetic.mod.output", "输出" },
 
                 { "hex.builtin.nodes.buffer", "缓冲区" },
                     { "hex.builtin.nodes.buffer.combine", "组合" },
                         { "hex.builtin.nodes.buffer.combine.header", "缓冲区组合" },
-                        { "hex.builtin.nodes.buffer.combine.input.a", "输入A" },
-                        { "hex.builtin.nodes.buffer.combine.input.b", "输入B" },
-                        { "hex.builtin.nodes.buffer.combine.output", "输出" },
                     { "hex.builtin.nodes.buffer.slice", "切片" },
                         { "hex.builtin.nodes.buffer.slice.header", "缓冲区切片" },
                         { "hex.builtin.nodes.buffer.slice.input.buffer", "输入" },
                         { "hex.builtin.nodes.buffer.slice.input.from", "从" },
                         { "hex.builtin.nodes.buffer.slice.input.to", "到" },
-                        { "hex.builtin.nodes.buffer.slice.output", "输出" },
                     { "hex.builtin.nodes.buffer.repeat", "重复" },
                         { "hex.builtin.nodes.buffer.repeat.header", "缓冲区重复" },
                         { "hex.builtin.nodes.buffer.repeat.input.buffer", "输入" },
                         { "hex.builtin.nodes.buffer.repeat.input.count", "次数" },
-                        { "hex.builtin.nodes.buffer.repeat.output", "输出" },
 
                 { "hex.builtin.nodes.control_flow", "控制流" },
                     { "hex.builtin.nodes.control_flow.if", "如果" },
@@ -523,67 +497,34 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.nodes.control_flow.if.condition", "条件" },
                         { "hex.builtin.nodes.control_flow.if.true", "True" },
                         { "hex.builtin.nodes.control_flow.if.false", "False" },
-                        { "hex.builtin.nodes.control_flow.if.output", "输出" },
                     { "hex.builtin.nodes.control_flow.equals", "等于" },
                         { "hex.builtin.nodes.control_flow.equals.header", "等于" },
-                        { "hex.builtin.nodes.control_flow.equals.input.a", "输入A" },
-                        { "hex.builtin.nodes.control_flow.equals.input.b", "输入B" },
-                        { "hex.builtin.nodes.control_flow.equals.output", "输出" },
                     { "hex.builtin.nodes.control_flow.not", "取反" },
                         { "hex.builtin.nodes.control_flow.not.header", "取反" },
-                        { "hex.builtin.nodes.control_flow.not.input", "输入" },
-                        { "hex.builtin.nodes.control_flow.not.output", "输出" },
                     { "hex.builtin.nodes.control_flow.gt", "大于" },
                         { "hex.builtin.nodes.control_flow.gt.header", "大于" },
-                        { "hex.builtin.nodes.control_flow.gt.input.a", "输入A" },
-                        { "hex.builtin.nodes.control_flow.gt.input.b", "输入B" },
-                        { "hex.builtin.nodes.control_flow.gt.output", "输出" },
                     { "hex.builtin.nodes.control_flow.lt", "小于" },
                         { "hex.builtin.nodes.control_flow.lt.header", "小于" },
-                        { "hex.builtin.nodes.control_flow.lt.input.a", "输入A" },
-                        { "hex.builtin.nodes.control_flow.lt.input.b", "输入B" },
-                        { "hex.builtin.nodes.control_flow.lt.output", "输出" },
                     { "hex.builtin.nodes.control_flow.and", "与" },
                         { "hex.builtin.nodes.control_flow.and.header", "逻辑与" },
-                        { "hex.builtin.nodes.control_flow.and.input.a", "输入A" },
-                        { "hex.builtin.nodes.control_flow.and.input.b", "输入B" },
-                        { "hex.builtin.nodes.control_flow.and.output", "输出" },
                     { "hex.builtin.nodes.control_flow.or", "或" },
                         { "hex.builtin.nodes.control_flow.or.header", "逻辑或" },
-                        { "hex.builtin.nodes.control_flow.or.input.a", "输入A" },
-                        { "hex.builtin.nodes.control_flow.or.input.b", "输入B" },
-                        { "hex.builtin.nodes.control_flow.or.output", "输出" },
 
                 { "hex.builtin.nodes.bitwise", "按位操作" },
                     { "hex.builtin.nodes.bitwise.and", "与" },
                         { "hex.builtin.nodes.bitwise.and.header", "位与" },
-                        { "hex.builtin.nodes.bitwise.and.input.a", "输入A" },
-                        { "hex.builtin.nodes.bitwise.and.input.b", "输入B" },
-                        { "hex.builtin.nodes.bitwise.and.output", "输出" },
                     { "hex.builtin.nodes.bitwise.or", "或" },
                         { "hex.builtin.nodes.bitwise.or.header", "位或" },
-                        { "hex.builtin.nodes.bitwise.or.input.a", "输入A" },
-                        { "hex.builtin.nodes.bitwise.or.input.b", "输入B" },
-                        { "hex.builtin.nodes.bitwise.or.output", "输出" },
                     { "hex.builtin.nodes.bitwise.xor", "异或" },
                         { "hex.builtin.nodes.bitwise.xor.header", "按位异或" },
-                        { "hex.builtin.nodes.bitwise.xor.input.a", "输入A" },
-                        { "hex.builtin.nodes.bitwise.xor.input.b", "输入B" },
-                        { "hex.builtin.nodes.bitwise.xor.output", "输出" },
                     { "hex.builtin.nodes.bitwise.not", "取反" },
                         { "hex.builtin.nodes.bitwise.not.header", "按位取反" },
-                        { "hex.builtin.nodes.bitwise.not.input", "输入" },
-                        { "hex.builtin.nodes.bitwise.not.output", "输出" },
 
                 { "hex.builtin.nodes.decoding", "编码" },
                     { "hex.builtin.nodes.decoding.base64", "Base64" },
                         { "hex.builtin.nodes.decoding.base64.header", "Base64解码" },
-                        { "hex.builtin.nodes.decoding.base64.input", "输入" },
-                        { "hex.builtin.nodes.decoding.base64.output", "输出" },
                     { "hex.builtin.nodes.decoding.hex", "十六进制" },
                         { "hex.builtin.nodes.decoding.hex.header", "十六进制解码" },
-                        { "hex.builtin.nodes.decoding.hex.input", "输入" },
-                        { "hex.builtin.nodes.decoding.hex.output", "输出" },
 
                 { "hex.builtin.nodes.crypto", "加密" },
                     { "hex.builtin.nodes.crypto.aes", "AES解密" },
@@ -591,11 +532,16 @@ namespace hex::plugin::builtin {
                         { "hex.builtin.nodes.crypto.aes.key", "密钥" },
                         { "hex.builtin.nodes.crypto.aes.iv", "IV" },
                         { "hex.builtin.nodes.crypto.aes.nonce", "Nonce" },
-                        { "hex.builtin.nodes.crypto.aes.input", "输入" },
-                        { "hex.builtin.nodes.crypto.aes.output", "输出" },
                         { "hex.builtin.nodes.crypto.aes.mode", "模式" },
                         { "hex.builtin.nodes.crypto.aes.key_length", "密钥长度" },
 
+                //{ "hex.builtin.nodes.visualizer", "Visualizers" },
+                    //{ "hex.builtin.nodes.visualizer.digram", "Digram" },
+                        //{ "hex.builtin.nodes.visualizer.digram.header", "Digram Visualizer" },
+                    //{ "hex.builtin.nodes.visualizer.image", "Image" },
+                        //{ "hex.builtin.nodes.visualizer.image.header", "Image Visualizer" },
+                    //{ "hex.builtin.nodes.visualizer.byte_distribution", "Byte Distribution" },
+                        //{ "hex.builtin.nodes.visualizer.byte_distribution.header", "Byte Distribution" },
 
 
                 { "hex.builtin.tools.demangler", "Itanium/MSVC名还原" },