Render Node Licenses

Updated: 26 Aug 2026

Introduction #

A Render Node license allows you to render your Notch projects on additional machines — a spare workstation, an on-premise render farm, or cloud instances — without tying up the VFX or RFX license you are designing on.

A Render Node license runs the two standalone rendering applications shipped with Notch Builder:

• NotchRenderNodeCLI.exe — command line rendering, for scripting and integration with render managers such as Deadline.
• NotchRenderNode.exe — a GUI application with the Notch Render Queue.

It does not license Notch Builder itself. You still need a VFX or RFX license to author and save the .dfx projects you send to your Render Nodes.

What it’s for #

• Rendering at scale and speed. Split renders across several machines for tight deadlines.
• Project-based billing. Buy exactly what your project needs and on-charge to the customer if applicable.
• Unblocking your VFX/RFX license. Offloading it to a Render Node keeps your costs down and VFX/RFX licenses freed up.
• Large canvases. Tiled rendering lets you render very large canvases with lower VRAM requirements.
• Direct-to-NotchLC output. There is no separate transcode step when rendering direct NotchLC.
• Batch deliverables. Render multiple resolutions, cuts and versions from one project.

What it isn’t #

Render Node licenses do not include render distribution or orchestration across machines — use Deadline or an equivalent render manager for that.

Floating licenses #

Render Node licenses are true floating licenses, delivered on a CodeMeter network dongle and served over your network by a Network License Server.

A license is only reserved while a render process is actually running, and is returned to the pool as soon as that process exits. This means the number of licenses you need matches the number of concurrent renders — and it makes Render Nodes safe to use on disposable cloud compute such as AWS Spot instances, which can be terminated at short notice.

Getting licenses #

Render Node licenses are available in two forms — a 12 Month license and an X Months license for project-based work — and a Render Node license is included with every annual RFX subscription. Current pricing for both is on the Notch pricing page.

Render Node licenses are sold only on a CodeMeter network dongle. If you do not already have a spare dongle you can add one to your order at checkout, at additional cost.

Because a physical dongle has to be shipped to you, Render Nodes are not well suited to same-day, on-demand needs. Plan your purchase ahead of the project. If you already own a CodeMeter dongle, licenses can be added to it and no new hardware is required.

12 month licenses #

12 month licenses are, by far, the most cost-effective option if you render regularly. You can choose the number of concurrent licenses at time of purchase. 12 month licenses don’t renew and will require a new purchase at the end of their term.

Volume discounts are available for 12 month licenses (only) and applied automatically at checkout. Volume discounts only apply to a single purchase and volumes cannot be applied to later purchases.

X months license (project based) #

The X Months licenses lets you buy exactly the rendering capacity a project needs. At checkout you choose how many months and how many machines you want, and the cost is multiplied through.

• Useful if you are on-billing costs to a client
• There is no recurring charge — the license simply expires at the end of the period you bought.
• Volume discounts do not apply to X months purchases.

Included with an annual RFX license #

Every annual RFX subscription includes one Render Node license, free of charge.

• It’s preferable to host the Render Node license on a separate dongle. However you can host the license on your existing RFX dongle and share the license with other machines over the network.
• Bundled Render Node licenses hold approximately the same dates as your RFX Annual subscription.
• It is issued as part of the regular RFX license renewal process.

Annual VFX licenses do not include a bundled Render Node. Note that VFX licenses can already be used on two authorised PCs simultaneously to allow a user to simultaneously render on a second machine — see Software Based Licenses.

Installing your license #

Render Node licenses are applied to a CodeMeter dongle in exactly the same way as any other Notch dongle license — follow the activation link in your order confirmation email, as described in Licensing & Installation.

Render Node licenses can be used locally with the Codemeter dongle inserted on the rendering machine, or by sharing the Render Node license over the network.

Full setup instructions for network license sharing — server requirements, enabling Network Server in CodeMeter WebAdmin, opening TCP port 22350 on the firewall, and pointing render machines at the server — are on the Network License Server page.

Using your license #

On your rendering machines:

1. Install the latest Notch Builder on each render machine — it bundles the CodeMeter runtimes needed to find the server.
2. Run NotchRenderNode.exe or NotchRenderNodeCLI.exe. Local licenses are automatically used, or the license server is discovered automatically (via UDP broadcast or set the server IP address directly).

Once a render machine can see the license server or local license, no further licensing steps are required — the Render Node applications check a license out when a render starts and releases it when the process ends.

• For command line rendering, including the full list of arguments, codecs, AOVs and tiled rendering options, see NotchRenderNodeCLI.
• For the GUI application and the Render Queue, see Using The Render Node.

Specific Use Cases #

Cloud rendering (e.g. EC2 Spot Instances) #

The floating licensing model makes cloud rendering practical: a license is only held for the duration of a render process, so ephemeral instances that are terminated return their license to the pool rather than stranding it. That makes Render Nodes usable on cheap, interruptible compute such as AWS EC2 Spot instances.

To share licenses with cloud machines you need a VPN or mesh network between the license server and the render EC2 instances — for example using Tailscale, WireGuard, or an existing site-to-cloud VPN.

Using Tailscale as the example:

1. Install Tailscale on the machine hosting the CodeMeter dongle (your license server) and on each cloud render instance, and join them all to the same tailnet.

2. Note the license server’s Tailscale IP address (a 100.x.x.x address). This is stable, unlike an EC2 instance’s public IP.

3. Make sure TCP port 22350 is reachable over the tailnet — check both the Windows firewall on the server and any Tailscale ACLs you have configured.

4. On each render instance, explicitly set the license server address rather than relying on UDP broadcast discovery. Using the registry method from the Network License Server page:

   REG ADD "HKLM\SOFTWARE\WIBU-SYSTEMS\CodeMeter\Server\CurrentVersion\ServerSearchList\Server1" /v Address /t REG_SZ /d "100.x.x.x" /f
   net stop "CodeMeter Runtime Server"
   net start "CodeMeter Runtime Server"
   

5. Bake Tailscale, the Notch install and the registry entry into your instance image (AMI) so that newly spun-up nodes are licensed the moment they boot.

Do not open port 22350 to the public internet. Keep license traffic inside the VPN or tailnet, and keep your cloud security group rules closed to everything else.

Using with Deadline #

Notch does not ship a multi-machine distribution system of its own, so job queuing and distribution across your farm is handled by a render manager. Deadline is the most commonly used option alongside Notch.

There are a couple of community Deadline plugins that have been written, or you can use an LLM to help you craft your own.

The pattern is straightforward: Deadline splits the frame range into tasks, and each Deadline Worker invokes NotchRenderNodeCLI.exe with the frame range for its task, passing -startframe and -endframe. Each running instance of the CLI checks out one Render Node license for the duration of that task and releases it when the task finishes.

Points to get right:

• Batch your frames. Send batches of frames to each task rather than one frame per task. We recommend ~10 or more frames per task — larger Notch projects can take a while to load, and a one-frame-per-task setup pays that load cost over and over.
• Size the pool to your licenses. Limit the job’s concurrent tasks (or the Worker count in the pool/group you use for Notch) to the number of Render Node licenses you own. Tasks that start when no license is free will fail to acquire one.
• Log to stdout. Add -stdout 1 so Deadline captures the render log from the headless Worker, and -logfile if you also want a log file on disk.
• Install the CodeMeter runtime on every Worker and confirm each one can reach the license server on TCP 22350 — see Installing your license above.
• Use UNC paths for -document and -out so every Worker resolves the same project and output location, and quote any path containing spaces.
• Tiled renders of large canvases can also be distributed — see the -tiled, -tilesize and -overscan options on the NotchRenderNodeCLI page. Tiles render independently and are blended in post using the overscan.

FAQs #