diff --git a/docs/Connectors-Overview.md b/docs/Connectors-Overview.md
index 35320f44..7cca8802 100644
--- a/docs/Connectors-Overview.md
+++ b/docs/Connectors-Overview.md
@@ -8,3 +8,10 @@ Node input and node output are implementations of `Connector` with a `Header` th
+---
+
+### Creating Custom Connectors
+
+For a detailed walkthrough on customizing the appearance, templates, and behaviors of your connectors, check out the [Creating Custom Connectors](Custom-Connectors) guide.
+
+
diff --git a/docs/Custom-Connectors.md b/docs/Custom-Connectors.md
new file mode 100644
index 00000000..689b9bb9
--- /dev/null
+++ b/docs/Custom-Connectors.md
@@ -0,0 +1,111 @@
+# Creating Custom Connectors
+
+Connectors are the interactive endpoints of nodes where users can click-and-drag to make connections. Nodify provides `Connector` as the base class, along with standard implementations: `NodeInput` (inputs with left alignment and a custom header) and `NodeOutput` (outputs with right alignment).
+
+To customize how connectors look, how they behave, or how they are positioned, you can customize the templates of the built-in connectors or create custom style/control definitions.
+
+---
+
+## Minimal Example: Customizing Connector Templates
+
+You can easily change the shape of the connector point (such as rendering a square or a triangle instead of the default circle) by setting the `ConnectorTemplate` property.
+
+Here is a WPF `ControlTemplate` that renders a custom square connector:
+
+```xml
+
+
+
+```
+
+You can then apply this template directly to your `NodeInput` or `NodeOutput`:
+
+```xml
+
+```
+
+---
+
+## Customizing the Header Layout
+
+`NodeInput` and `NodeOutput` inherit from `HeaderedContentControl`, which means they have `Header` and `HeaderTemplate` properties. You can customize the `HeaderTemplate` to contain any interactive or static controls (e.g., adding input boxes or drop-down menus directly on the connector).
+
+```xml
+
+
+
+
+
+
+```
+
+Use it in your editor:
+
+```xml
+
+```
+
+---
+
+## Advanced: Designing Custom Connector Behavior & Style Triggers
+
+In complex applications, you might want connectors to dynamically change their shape, color, or visibility depending on the type of data they carry (e.g., integers, booleans, trigger signals) or whether they are currently connected.
+
+Using WPF `DataTrigger`s makes this simple:
+
+```xml
+
+```
+
+---
+
+## Performance & Interaction Notes
+
+1. **The `Anchor` Point**: The `Anchor` property is critical. It defines the point from which connections start or end. If you are using a custom `ControlTemplate` for the connector, ensure the outer layout of your node doesn't prevent the `Connector` from computing its relative location. The `Anchor` coordinates are automatically updated by the library when `IsConnected` is `True`.
+2. **`IsConnected` Setting**: Setting `IsConnected` to `True` enables updates for the connector's `Anchor` dependency property. Make sure your custom styles or bindings preserve this logic.
+3. **Hit Testing / Focus**: Connectors are highly interactive. If you put clickable elements (like textboxes) inside the `HeaderTemplate` of a connector, users can focus and interact with them, but dragging starting on those sub-controls might be intercepted depending on routing. Keep interactive elements clean and clearly distinct from the connector point itself.
diff --git a/docs/Custom-Nodes.md b/docs/Custom-Nodes.md
new file mode 100644
index 00000000..bdb45325
--- /dev/null
+++ b/docs/Custom-Nodes.md
@@ -0,0 +1,225 @@
+# Creating Custom Nodes
+
+In Nodify, nodes are the basic building blocks of a node graph. While Nodify provides built-in node controls such as `Node`, `GroupingNode`, `KnotNode`, and `StateNode`, you can easily create fully customized nodes to fit your application's unique user interface and experience.
+
+Because Nodify is built from the ground up for MVVM, the `NodifyEditor` wraps every element in its `ItemsSource` inside an `ItemContainer`. This means that **any WPF control** can serve as a node! You are not restricted to subclassing Nodify controls; you can style or layout custom nodes using standard WPF panels (like `Grid` or `StackPanel`) and populate them with standard WPF elements.
+
+---
+
+## Minimal Example: Simple Custom Node
+
+Let's build a simple custom node with:
+- A custom title/header.
+- An area for node settings or inputs (e.g. a `TextBox`).
+- A list of input and output connectors.
+
+### 1. The ViewModel representation
+
+First, we will define our `ConnectorViewModel` and `CustomNodeViewModel` classes. To support WPF binding, these models implement `INotifyPropertyChanged`.
+
+```csharp
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Windows;
+
+public class ConnectorViewModel : INotifyPropertyChanged
+{
+ private Point _anchor;
+ public Point Anchor
+ {
+ get => _anchor;
+ set
+ {
+ _anchor = value;
+ OnPropertyChanged(nameof(Anchor));
+ }
+ }
+
+ private bool _isConnected;
+ public bool IsConnected
+ {
+ get => _isConnected;
+ set
+ {
+ _isConnected = value;
+ OnPropertyChanged(nameof(IsConnected));
+ }
+ }
+
+ public string Title { get; set; } // Simplified for brevity; raise PropertyChanged if updating at runtime
+
+ public event PropertyChangedEventHandler PropertyChanged;
+ protected virtual void OnPropertyChanged(string propertyName)
+ => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+}
+
+public class CustomNodeViewModel : INotifyPropertyChanged
+{
+ private Point _location;
+ public Point Location
+ {
+ get => _location;
+ set
+ {
+ _location = value;
+ OnPropertyChanged(nameof(Location));
+ }
+ }
+
+ private string _nodeName;
+ public string NodeName
+ {
+ get => _nodeName;
+ set
+ {
+ _nodeName = value;
+ OnPropertyChanged(nameof(NodeName));
+ }
+ }
+
+ private string _customText;
+ public string CustomText
+ {
+ get => _customText;
+ set
+ {
+ _customText = value;
+ OnPropertyChanged(nameof(CustomText));
+ }
+ }
+
+ public ObservableCollection Inputs { get; } = new ObservableCollection();
+ public ObservableCollection Outputs { get; } = new ObservableCollection();
+
+ public event PropertyChangedEventHandler PropertyChanged;
+ protected virtual void OnPropertyChanged(string propertyName)
+ => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+}
+```
+
+### 2. The XAML View: Styling and Templating the Custom Node
+
+We bind the ViewModel to a View by defining a `DataTemplate` for our `CustomNodeViewModel`. This template can be placed in `NodifyEditor.ItemTemplate` or in a Resource Dictionary. We will lay out the header, internal controls, and lists of inputs and outputs inside standard WPF containers.
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+### 3. Registering/Adding the custom node
+
+To display this custom node in the editor, simply add an instance of your `CustomNodeViewModel` to the nodes collection in your `EditorViewModel`:
+
+```csharp
+public class EditorViewModel
+{
+ public ObservableCollection