@dpantani/tdmcp 0.1.0

package/dist/knowledge/data/tutorials/write_a_shared_memory_chop.json

@@ -0,0 +1,261 @@
+{
+  "id": "write_a_shared_memory_chop",
+  "name": "Write a Shared Memory CHOP",
+  "displayName": "Write a Shared Memory CHOP",
+  "category": "TUTORIAL",
+  "subcategory": "CHOP Tutorial",
+  "type": "tutorial",
+  "description": "This article refers to how to write external applications to interface with Shared Mem Out CHOP and Shared Mem In CHOP.",
+  "summary": "This article refers to how to write external applications to interface with Shared Mem Out CHOP and Shared Mem In CHOP. In the TouchDesigner installation directory, under /touch/SharedMem/CHOP there is the header defined in CHOP_SharedMemHeader.h that needs to be filled in at the start of the shared memory buffer. The memory buffer should have this header, followed by the channel data and optionally the channel data. NOTE: The 'Shared Mem Type' parameter in the CHOP must be set to 'Local' for your app to be able interface with it",
+  "content": {
+    "sections": [
+      {
+        "title": "Introduction",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "This article refers to how to write external applications to interface with Shared Mem Out CHOP and Shared Mem In CHOP."
+          },
+          {
+            "type": "paragraph",
+            "text": "In the TouchDesigner installation directory, under /touch/SharedMem/CHOP there is the header defined in CHOP_SharedMemHeader.h that needs to be filled in at the start of the shared memory buffer. The memory buffer should have this header, followed by the channel data and optionally the channel data."
+          },
+          {
+            "type": "paragraph",
+            "text": "NOTE: The 'Shared Mem Type' parameter in the CHOP must be set to 'Local' for your app to be able interface with it"
+          }
+        ]
+      },
+      {
+        "title": "Creating a Shared Memory Buffer",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "Refer to the article Using Shared Memory in TouchDesigner to learn how to create a shared memory buffer. If you are the sender, you need to create a buffer who's size will accommodate both the header, the channel data and the channel names (if you are sending them). Get the size of the header simply with"
+          },
+          {
+            "type": "code",
+            "text": "sizeof(CHOP_SharedMemHeader)",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "The size of the channel data is"
+          },
+          {
+            "type": "code",
+            "text": "number of channels * channel length * 4",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "4 because that's the number of bytes in a float."
+          },
+          {
+            "type": "paragraph",
+            "text": "The size of the channel names is the length of each channel name + 1 extra byte per channel to accommodate the null character at the end of each channel name. For example if you have 2 channels named cha1 and cha2 the required size would be"
+          },
+          {
+            "type": "code",
+            "text": "4 + 4 + 2 = 10\n where the terms are: (length of cha1) + (length of cha2) + (number of channels, for the null characters)",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "Following the same example, if the channel length was 5 samples long, then you'd need to allocate a memory buffer that has the size in bytes of at least:"
+          },
+          {
+            "type": "code",
+            "text": "sizeof(CHOP_SharedMemHeader) + 10 + (2 * 5 * 4)",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "Once you have a pointer to the memory, you can do the next step."
+          }
+        ]
+      },
+      {
+        "title": "Writing/Reading the Header",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "You can get the header file used to describe the data that is sent through a Shared Mem CHOP in Touch/SharedMem/CHOP (Under the directory where Touch is installed). The file is called CHOP_SharedMemHeader.h."
+          },
+          {
+            "type": "paragraph",
+            "text": "The header is the first thing that appears in the shared memory. So you can cast the pointer you get from UT_SharedMem to CHOP_SharedMemHeader."
+          },
+          {
+            "type": "code",
+            "text": "CHOP_SharedMemHeader *header = (CHOP_SharedMemHeader*)shm->getMemory();",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "If you are the sender, fill in all of the fields in this header. Refer to the header for more details one each field you need to fill in."
+          },
+          {
+            "type": "paragraph",
+            "text": "If you are the sender, make sure you fill in all required fields in the header, otherwise the receiver won't know where the data is"
+          },
+          {
+            "type": "paragraph",
+            "text": "Most of the members of the header are self-explanatory. Typical usage would be like this"
+          },
+          {
+            "type": "code",
+            "text": "header->magicNumber = CHOP_SHM_MAGIC_NUMBER; // Must be set to this\n header->version = CHOP_SHM_VERSION; // Must be set to this\n header->size = sharedMemSize; // As calculated when you created the shared memory\n header->numChans = numOfChannelsToSend;\n header->length = lengthOfEachChannel; // Number of samples\n header->sampleRate = theSampleRate;\n header->namesSent = amISendingNames; // 1 if you are sending channel names, 0 otherwise\n header->channelDataOffset = sizeof(CHOP_SharedMemHeader);\n header->nameDataOffset = header->channelDataOffset + (header->numChans * header->length * 4);",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "If you are the receiver, use the the information from the header however you see fit."
+          }
+        ]
+      },
+      {
+        "title": "Reading/Writing the channel data",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "Get a pointer to where you should read/write the channel data by simply using the getChannelData() call in the header"
+          },
+          {
+            "type": "code",
+            "text": "float *data = header->getChannelData();",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "The channel data is tightly packed, one channel at a time. So the first channel's samples appear first, follow immediately by the second channel's samples."
+          },
+          {
+            "type": "paragraph",
+            "text": "A typical loop to read/write the channel data would look like this"
+          },
+          {
+            "type": "code",
+            "text": "float *data = header->getChannelData(); \n for (int i = 0; i < header->numChans; i++)\n {\n    // data points to the channel data of the i'th channel\n    for (int j = 0; j < header->length; j++)\n    {\n        // data[j] is the j'th sample in the current channel\n        float sample = data[j];\n        // do something with the data\n        // or if you are writing data to the shared mem, you'd assign something to data[j]\n    }\n    // Move the data pointer forward so that it now points to the data for\n    // the next channel\n    data += header->length;\n }",
+            "language": "text"
+          }
+        ]
+      },
+      {
+        "title": "Reading/Writing the channel names",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "If you are writing channel names, make sure you set the namesSent field of the header to 1, otherwise the names will be ignored. If you don't send names, then the channels will keep their previous names, or use incremental names starting at 'chan1' if they don't have a previous name."
+          },
+          {
+            "type": "paragraph",
+            "text": "If you are reading channel names, make sure the namesSent field of the header is 1, otherwise you will be reading garbabe data."
+          },
+          {
+            "type": "paragraph",
+            "text": "Get a pointer to where you should read/write the channel names by simply using the getNameData() call in the header"
+          },
+          {
+            "type": "code",
+            "text": "char *names = header->getNameData();",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "The channel names are tightly packed with the data containing a channel name, followed by a null character, followed immediately by the next channel name."
+          },
+          {
+            "type": "paragraph",
+            "text": "A typical loop to read the channel names would be:"
+          },
+          {
+            "type": "code",
+            "text": "char *names = header->getNameData(); \n for (int i = 0; i < header->numChans; i++)\n {\n    // names pointer to the name of the i'th channel, so you can do whatever you normally can with a string it\n    // such as\n    cout << names << endl;\n    \n    // Now move the pointer forward to the next channel name\n    // add the number of character in the name, plus the null character to the pointer\n    names += strlen(names) + 1;\n }",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "A typical loop to write the channel names would be:"
+          },
+          {
+            "type": "code",
+            "text": "// This example assumes you have an array of char*s called myNames that contain the channel names.\n char *names = header->getNameData(); \n for (int i = 0; i < header->numChans; i++)\n {\n    // names pointer to the name of the i'th channel, so copy the channel name to it, make sure you include the\n    // null character at the end of the string (the + 1 in the size of the memcpy)\n    memcpy(names, myNames[i], strlen(myNames[i]) + 1);\n    \n    // Now move the pointer forward to the next channel name\n    // add the number of character in the name, plus the null character to the pointer\n    names += strlen(myNames[i]) + 1;\n }",
+            "language": "text"
+          }
+        ]
+      }
+    ],
+    "tableOfContents": [
+      {
+        "number": "1",
+        "text": "Creating a Shared Memory Buffer",
+        "href": "#Creating_a_Shared_Memory_Buffer"
+      },
+      {
+        "number": "2",
+        "text": "Writing/Reading the Header",
+        "href": "#Writing/Reading_the_Header"
+      },
+      {
+        "number": "3",
+        "text": "Reading/Writing the channel data",
+        "href": "#Reading/Writing_the_channel_data"
+      },
+      {
+        "number": "4",
+        "text": "Reading/Writing the channel names",
+        "href": "#Reading/Writing_the_channel_names"
+      }
+    ],
+    "relatedLinks": [
+      {
+        "text": "Shared Mem Out CHOP",
+        "href": "Shared_Mem_Out_CHOP.htm"
+      },
+      {
+        "text": "Shared Mem In CHOP",
+        "href": "Shared_Mem_In_CHOP.htm"
+      },
+      {
+        "text": "Using Shared Memory in TouchDesigner",
+        "href": "Using_Shared_Memory_in_TouchDesigner.htm"
+      }
+    ],
+    "images": []
+  },
+  "keywords": [
+    "write",
+    "shared",
+    "memory",
+    "chop",
+    "introduction",
+    "creating",
+    "buffer",
+    "writing/reading",
+    "header",
+    "reading/writing",
+    "channel",
+    "data",
+    "names",
+    "dat",
+    "parameter",
+    "sample",
+    "mat"
+  ],
+  "tags": [
+    "Tutorial",
+    "TouchDesigner",
+    "Write a Shared Memory CHOP"
+  ],
+  "searchWeight": 2,
+  "lastUpdated": "2025-08-08T03:32:33.824Z",
+  "sourceFile": "C:\\Program Files\\Derivative\\TouchDesigner\\Samples\\Learn\\OfflineHelp\\https.docs.derivative.ca\\Write_a_Shared_Memory_CHOP.htm",
+  "isValid": true,
+  "validationErrors": []
+}

package/dist/knowledge/data/tutorials/write_a_shared_memory_top.json

@@ -0,0 +1,193 @@
+{
+  "id": "write_a_shared_memory_top",
+  "name": "Write a Shared Memory TOP",
+  "displayName": "Write a Shared Memory TOP",
+  "category": "TUTORIAL",
+  "subcategory": "TOP Tutorial",
+  "type": "tutorial",
+  "description": "In the TouchDesigner installation directory, under Samples/SharedMem/TOP there is the header defined in TOP_SharedMemHeader.h that needs to be filled in at the start of the shared memory buffer. The memory buffer should have this header, followed by the image data.",
+  "summary": "In the TouchDesigner installation directory, under Samples/SharedMem/TOP there is the header defined in TOP_SharedMemHeader.h that needs to be filled in at the start of the shared memory buffer. The memory buffer should have this header, followed by the image data. NOTE: The 'Shared Mem Type' parameter in the TOP must be set to 'Local' for your app to be able interface with it. Refer to the article Using Shared Memory in TouchDesigner to learn how to create a shared memory buffer. If you are the sender, you need to create a buffer whose size will accommodate both the header, and the image data. Get the size of the header simply with",
+  "content": {
+    "sections": [
+      {
+        "title": "Introduction",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "In the TouchDesigner installation directory, under Samples/SharedMem/TOP there is the header defined in TOP_SharedMemHeader.h that needs to be filled in at the start of the shared memory buffer. The memory buffer should have this header, followed by the image data."
+          },
+          {
+            "type": "paragraph",
+            "text": "NOTE: The 'Shared Mem Type' parameter in the TOP must be set to 'Local' for your app to be able interface with it."
+          }
+        ]
+      },
+      {
+        "title": "Creating a Shared Memory Buffer",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "Refer to the article Using Shared Memory in TouchDesigner to learn how to create a shared memory buffer. If you are the sender, you need to create a buffer whose size will accommodate both the header, and the image data. Get the size of the header simply with"
+          },
+          {
+            "type": "code",
+            "text": "sizeof(TOP_SharedMemHeader)",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "The size of the image data depends on the number of channels, the resolution and the dataType. In general it's"
+          },
+          {
+            "type": "code",
+            "text": "width * height * number of channels * number_of_bytes_per_channel",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "Where number_of_bytes_per_channel is 1 for dataType GL_UNSIGNED_BYTE and 4 for GL_FLOAT."
+          },
+          {
+            "type": "paragraph",
+            "text": "Once you have a pointer to the memory, you can do the next step."
+          }
+        ]
+      },
+      {
+        "title": "Writing/Reading the Header",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "You can get the header file used to describe the data that is sent through a Shared Mem TOP in touch/SharedMem/TOP (Under the directory where TouchDesigner is installed). The file is called TOP_SharedMemHeader.h."
+          },
+          {
+            "type": "paragraph",
+            "text": "The header is the first thing that appears in the shared memory. So you can cast the pointer you get from UT_SharedMem to TOP_SharedMemHeader."
+          },
+          {
+            "type": "code",
+            "text": "TOP_SharedMemHeader *header = (TOP_SharedMemHeader*)shm->getMemory();",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "If you are the sender, fill in all of the fields in this header. Refer to the header for more details one each field you need to fill in."
+          },
+          {
+            "type": "paragraph",
+            "text": "If you are the sender, make sure you do this, otherwise the receiver won't know where the image is."
+          },
+          {
+            "type": "code",
+            "text": "header->dataOffset = sizeof(TOP_SharedMemHeader);",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "Most of the members of the header are self-explanatory, except for dataFormat, dataType and pixelFormat. The valid values for these are listed at the top of TOP_SharedMemHeader.h. The values are OpenGL constants but I'll provide their actual values (in hexadecimal) in case you aren't using OpenGL at all in your app."
+          },
+          {
+            "type": "paragraph",
+            "text": "dataFormat: This is the format of your image in memory. For example if you don't have an alpha channel and your image data's pixel format is RGB, you specify GL_RGB."
+          },
+          {
+            "type": "paragraph",
+            "text": "dataType: This is the data type of your image data. If it's stored an unsigned char's use GL_UNSIGNED_BYTE (8-bits per channel), if it's stored as floats use GL_FLOAT (32-bits per channel)."
+          },
+          {
+            "type": "paragraph",
+            "text": "pixelFormat: This is the format of the texture you want to be created in the Shared Mem In TOP. The pixelFormat doesn't need to match the dataType. For example you can create a GL_RGBA16F_ARB (16 bit float) texture from 8-bits unsigned char data, or vice versa, if you want. Don't confuse the RGBA here with a dataFormat as above, the RGBA doesn't imply that's the channel order, it just implies that's the channels present, they could be ordered BGRA if you want."
+          },
+          {
+            "type": "paragraph",
+            "text": "If you are the receiver, use the the information from the header however you see fit."
+          }
+        ]
+      },
+      {
+        "title": "Reading/Writing the Image",
+        "level": 2,
+        "content": [
+          {
+            "type": "paragraph",
+            "text": "Get a pointer to where you should read/write the image by simply using the getImage() call in the header:"
+          },
+          {
+            "type": "code",
+            "text": "unsigned char *image = (unsigned char*)header->getImage(); // For 8-bit",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "or"
+          },
+          {
+            "type": "code",
+            "text": "float *image = (float*)header->getImage(); // For floating point data",
+            "language": "text"
+          },
+          {
+            "type": "paragraph",
+            "text": "Now read/write the image data depending on the format."
+          }
+        ]
+      }
+    ],
+    "tableOfContents": [
+      {
+        "number": "1",
+        "text": "Creating a Shared Memory Buffer",
+        "href": "#Creating_a_Shared_Memory_Buffer"
+      },
+      {
+        "number": "2",
+        "text": "Writing/Reading the Header",
+        "href": "#Writing/Reading_the_Header"
+      },
+      {
+        "number": "3",
+        "text": "Reading/Writing the Image",
+        "href": "#Reading/Writing_the_Image"
+      }
+    ],
+    "relatedLinks": [
+      {
+        "text": "Using Shared Memory in TouchDesigner",
+        "href": "Using_Shared_Memory_in_TouchDesigner.htm"
+      }
+    ],
+    "images": []
+  },
+  "keywords": [
+    "write",
+    "shared",
+    "memory",
+    "introduction",
+    "creating",
+    "buffer",
+    "writing/reading",
+    "header",
+    "reading/writing",
+    "image",
+    "top",
+    "dat",
+    "sample",
+    "parameter",
+    "channel",
+    "mat",
+    "texture"
+  ],
+  "tags": [
+    "Tutorial",
+    "TouchDesigner",
+    "Write a Shared Memory TOP"
+  ],
+  "searchWeight": 2,
+  "lastUpdated": "2025-08-08T03:32:33.852Z",
+  "sourceFile": "C:\\Program Files\\Derivative\\TouchDesigner\\Samples\\Learn\\OfflineHelp\\https.docs.derivative.ca\\Write_a_Shared_Memory_TOP.htm",
+  "isValid": true,
+  "validationErrors": []
+}

package/dist/recipes/audio_spectrum_bars.json

@@ -0,0 +1,26 @@
+{
+  "id": "audio_spectrum_bars",
+  "name": "Audio Spectrum Bars",
+  "description": "Classic spectrum analyzer: live audio is analyzed into a frequency spectrum and drawn as colored bars in a GLSL TOP.",
+  "tags": ["audio-reactive", "spectrum", "bars", "music"],
+  "difficulty": "beginner",
+  "td_version_min": "2022",
+  "nodes": [
+    { "name": "audioin", "type": "audiodeviceinCHOP", "comment": "Live audio input" },
+    { "name": "spectrum", "type": "audiospectrumCHOP", "comment": "FFT spectrum" },
+    { "name": "audio_tex", "type": "choptoTOP", "comment": "Spectrum as a 1-row texture" },
+    { "name": "bars", "type": "glslTOP", "comment": "Draws the bars from the spectrum texture" },
+    { "name": "out1", "type": "nullTOP" }
+  ],
+  "connections": [
+    { "from": "audioin", "to": "spectrum" },
+    { "from": "spectrum", "to": "audio_tex" },
+    { "from": "audio_tex", "to": "bars" },
+    { "from": "bars", "to": "out1" }
+  ],
+  "parameters": [],
+  "glsl_code": {
+    "bars": "out vec4 fragColor;\nvoid main(){\n    vec2 uv = vUV.st;\n    float amp = texture(sTD2DInputs[0], vec2(uv.x, 0.5)).r;\n    float bar = step(uv.y, clamp(amp, 0.0, 1.0));\n    vec3 col = mix(vec3(0.02,0.0,0.08), vec3(0.1,0.9,1.0), uv.x) * bar;\n    fragColor = TDOutputSwizzle(vec4(col, 1.0));\n}\n"
+  },
+  "preview_description": "A row of glowing cyan-to-magenta bars rising and falling with the music."
+}

package/dist/recipes/data_sonification.json

@@ -0,0 +1,37 @@
+{
+  "id": "data_sonification",
+  "name": "Data Sonification",
+  "description": "Drives both audio and a visual from a data table: values are read into CHOPs, smoothed, and mapped to an oscillator and a color ramp.",
+  "tags": ["data", "sonification", "audio", "visualization"],
+  "difficulty": "intermediate",
+  "td_version_min": "2022",
+  "nodes": [
+    { "name": "data", "type": "tableDAT", "comment": "Source data (rows of numbers)" },
+    { "name": "datto", "type": "dattoCHOP", "comment": "Data table → channels" },
+    { "name": "smooth", "type": "filterCHOP", "parameters": { "width": 0.2 } },
+    { "name": "osc", "type": "audiooscillatorCHOP", "comment": "Maps a channel to pitch" },
+    { "name": "audioout", "type": "audiodeviceoutCHOP" },
+    { "name": "viz", "type": "choptoTOP", "comment": "Channels as a texture" },
+    { "name": "out1", "type": "nullTOP" }
+  ],
+  "connections": [
+    { "from": "data", "to": "datto" },
+    { "from": "datto", "to": "smooth" },
+    { "from": "smooth", "to": "osc" },
+    { "from": "osc", "to": "audioout" },
+    { "from": "smooth", "to": "viz" },
+    { "from": "viz", "to": "out1" }
+  ],
+  "parameters": [
+    {
+      "name": "smoothing",
+      "node": "smooth",
+      "param": "width",
+      "value": 0.2,
+      "min": 0,
+      "max": 1,
+      "label": "Smoothing"
+    }
+  ],
+  "preview_description": "A shifting band of colors tracking the data, accompanied by an evolving tone."
+}

package/dist/recipes/feedback_tunnel.json

@@ -0,0 +1,73 @@
+{
+  "id": "feedback_tunnel",
+  "name": "Feedback Tunnel",
+  "description": "A hypnotic tunnel created by feeding a transformed, blurred frame back into itself over a noise seed.",
+  "tags": ["feedback", "generative", "tunnel", "abstract", "noise"],
+  "difficulty": "beginner",
+  "td_version_min": "2022",
+  "nodes": [
+    {
+      "name": "noise1",
+      "type": "noiseTOP",
+      "parameters": { "period": 3, "monochrome": 1 },
+      "comment": "Seed texture that feeds the loop"
+    },
+    { "name": "feedback1", "type": "feedbackTOP", "comment": "Holds the previous frame" },
+    {
+      "name": "comp1",
+      "type": "compositeTOP",
+      "comment": "Combines the seed with the fed-back frame (default Over)"
+    },
+    {
+      "name": "transform1",
+      "type": "transformTOP",
+      "parameters": { "scalex": 1.03, "scaley": 1.03, "rotate": 1.5 },
+      "comment": "Zoom + rotate each frame to create the tunnel motion"
+    },
+    { "name": "blur1", "type": "blurTOP", "parameters": { "size": 2 } },
+    {
+      "name": "level1",
+      "type": "levelTOP",
+      "parameters": { "gain": 0.96 },
+      "comment": "Decay / feedback gain"
+    },
+    { "name": "out1", "type": "nullTOP", "comment": "Output of the system" }
+  ],
+  "connections": [
+    { "from": "noise1", "to": "feedback1" },
+    { "from": "noise1", "to": "comp1", "to_input": 0 },
+    { "from": "feedback1", "to": "comp1", "to_input": 1 },
+    { "from": "comp1", "to": "transform1" },
+    { "from": "transform1", "to": "blur1" },
+    { "from": "blur1", "to": "level1" },
+    { "from": "level1", "to": "out1" }
+  ],
+  "parameters": [
+    {
+      "name": "feedback_target",
+      "node": "feedback1",
+      "param": "top",
+      "value": "level1",
+      "description": "feedbackTOP samples the loop output (level1). Value resolves to the created node path."
+    },
+    {
+      "name": "feedback_gain",
+      "node": "level1",
+      "param": "gain",
+      "value": 0.96,
+      "min": 0,
+      "max": 1,
+      "label": "Feedback Gain"
+    },
+    {
+      "name": "zoom",
+      "node": "transform1",
+      "param": "scalex",
+      "value": 1.03,
+      "min": 1,
+      "max": 1.2,
+      "label": "Tunnel Zoom"
+    }
+  ],
+  "preview_description": "An endless rotating tunnel of evolving colored noise that folds into its own center."
+}

package/dist/recipes/kinect_silhouette.json

@@ -0,0 +1,45 @@
+{
+  "id": "kinect_silhouette",
+  "name": "Kinect Silhouette",
+  "description": "Uses a Kinect Azure depth feed to isolate a body silhouette and drive a glowing outline. Requires Kinect Azure hardware.",
+  "tags": ["kinect", "depth", "interactive", "installation"],
+  "difficulty": "advanced",
+  "td_version_min": "2022",
+  "nodes": [
+    {
+      "name": "kinect",
+      "type": "kinectazureTOP",
+      "comment": "Depth / player index (requires hardware)"
+    },
+    {
+      "name": "threshold",
+      "type": "thresholdTOP",
+      "parameters": { "threshold": 0.5 },
+      "comment": "Isolate the body from the background"
+    },
+    { "name": "edge", "type": "edgeTOP", "comment": "Silhouette outline" },
+    { "name": "glow", "type": "blurTOP", "parameters": { "size": 6 } },
+    { "name": "comp1", "type": "compositeTOP", "comment": "Combine outline + glow" },
+    { "name": "out1", "type": "nullTOP" }
+  ],
+  "connections": [
+    { "from": "kinect", "to": "threshold" },
+    { "from": "threshold", "to": "edge" },
+    { "from": "edge", "to": "comp1", "to_input": 0 },
+    { "from": "edge", "to": "glow" },
+    { "from": "glow", "to": "comp1", "to_input": 1 },
+    { "from": "comp1", "to": "out1" }
+  ],
+  "parameters": [
+    {
+      "name": "depth_threshold",
+      "node": "threshold",
+      "param": "threshold",
+      "value": 0.5,
+      "min": 0,
+      "max": 1,
+      "label": "Depth Threshold"
+    }
+  ],
+  "preview_description": "A glowing neon outline of a person moving in front of the sensor against a black background."
+}