Working With Custom Shaders

Updated: 26 Jun 2026

This section explains how to use custom shaders to create your own effects. New for version 2026.2 is the ability to create you own Particle Affectors, Cloner Effectors and Deformers.

Custom Shader Effectors require the implementation of your own code to determine the behaviour of the Effector, and requires some knowledge of these systems to implement. Use of custom shaders is at your own risk. 10Bit does not provide support for custom shader code. If you experience an issue with a project/block you will need to demonstrate your issue without your custom shader in the nodegraph, to be able to receive support from the 10bit team. Support is only available for issues specifically related to the functionality of the Custom Shader Node, not for any custom code. External tools are available that can provide good assistance in writing these nodes when provided with the example script.

Overview #

These nodes let you create your own custom effects using shader code. This is great way of expanding the capabilities of various systems in Notch, and with careful design and implementation can lead to endless possibilities of innovative and efficient looks. Notch shaders are written in HLSL and use the D3DX Effect framework.

Custom Cloner Effectors allow for the manipulation of position, rotation, scale and colours of clones, as well as the killing of clones. For an overview of cloner systems and how to use clone effectors within them, see Cloners.
Custom Particle Affectors allow for the manipulation of velocity, colour, normals, scale (via the normal buffer’s w component) of particles via your own code. For an overview of particle systems and how to use affectors within them, see Particles.
Custom Shader Deformers allow for the manipulation of each individual vertex’s position, motion, normal direction, colour and motion. For an overview of deformers, see Deformers.
Custom Shader Post-FX allow for the manipulation of each individual pixel in a texture. For more info on Post-FX, see Post-FX.

These nodes are all processed once per frame. By writing HLSL code, you can perform operations on that data and use it to update (effect) attributes of clones. You can also define your own variables that can be controlled from the Property Editor or via Modifiers, just like other parameters in Notch.

FX Files and HLSL #

To use custom shaders in each of these nodes, you will need to write your own shader, which is imported and used just like any other resource in Notch.
Custom shaders are written in HLSL code, inside of .fx files, resources with a .fx suffix.
Notch shaders are written in HLSL and use the D3DX Effect framework.
External tools are available that can help you understand and adjust the example code that is provided by each node to start making your own effects.
The following sections of this page will explain how to set up and get started with shader files. For more information on the specifics of each individual node, check on the node’s individual page.

Set Up - Creating and Importing Shader Files #

The simplest method to get working quickly is to have the node generate its example script for you. To do this:

Select the node.
In the Property Editor, click “Create Shader File”.
Set a file path file name to generate your script.

Create_Shader

Once you have created a script that you want to re-use in new projects, you can import the .fx file by clicking and dragging it from your file system into the resource browser in Notch. Alternatively, you can click on the import resource button in the Resource Browser. Your shader files can then be assigned to the node inside of the Property Editor.

As soon as you have assigned a shader file to the node, you will see it’s effect as soon as your press play.

Set Up - Editing Your Shader Files #

To edit the shader file, you need to open it in an external editor. One way to quickly do this:

Right click on the .fx file resource in your resource browser and select “Open Containing Folder”.
Then from your file explorer, open the file in a text editor of your choice.

Open_Folder

As you will be writing shader code in this file, it is very helpful to work in a text editor that can interpret shader code syntactically.

As you will be editing your script outside of Notch, you will need to ensure that the resource is reloaded after you make changes to the .fx file. You can do this manually at any time by right clicking on the resource in the Resource Browser and hitting “Reload Resource”. You can also set this to happen automatically whenever the resource is updated by choosing “Reflect Resource Changes” from the same right mouse button menu. With this option, the shader file will be updated in Notch whenever it is saved over in Windows.

Reflect_Resource

Understanding the Example Scripts #

Once you have gotten set up with the example script you are ready to start reading and customising it. Depending on the node that you are creating a shader for, the specific workings of the code will change. However, essentially in each example:

Buffers are created to receive and hold information about the incoming data to the node at the time the node is processed. These incoming values are read once per frame.
Variables are created that will control the effect. These variables can be named as you choose, and can be controlled via the Property Editor or by using modifiers just like other properties in Notch.
Where appropriate, the falloff properties of the node are used to control the effect on a particle by particle basis.
The functionality of this affector is determined inside of a function.This code will run on multiple threads simultaneously.

To get started with writing code for each of these nodes, refer to the pages for each specific node….