Chilkat for LabVIEW

use the Chilkat .NET assembly from LabVIEW's built-in .NET nodes

LabVIEW for Windows, 32-bit or 64-bit · LabVIEW 2013 or later · uses the Chilkat .NET assembly for the .NET Framework 4.8 (requires .NET Framework 4.8 on the machine)

There is no separate LabVIEW package to install. LabVIEW for Windows can call .NET Framework assemblies directly through its .NET nodes, so the standard Chilkat .NET assembly (ChilkatDotNet48.dll) gives you the complete Chilkat API inside LabVIEW: HTTP/REST, JSON, email, FTP, SFTP/SSH, Zip, PDF, digital signatures, encryption, and everything else. You create a Chilkat object with a Constructor Node, call its methods with an Invoke Node, and get or set its properties with a Property Node. When you click an Invoke or Property Node, LabVIEW lists every method or property of that Chilkat class, so the whole API is available from the dropdown.

First: match LabVIEW's bitness

Download

Download the 64-bit build for 64-bit LabVIEW and the 32-bit build for 32-bit LabVIEW. These are the full-version downloads, and they are fully functional for a 30-day evaluation. Other .NET Framework versions and the NuGet packages are on the Chilkat .NET download page. For LabVIEW, the 4.8 build above is the one to use.

Walkthrough: unlock Chilkat and fetch a URL

This walkthrough builds a VI that does the same thing as these few lines of C#:

Chilkat.Global glob = new Chilkat.Global();
bool success = glob.UnlockBundle("Anything for 30-day trial");
if (!success) { /* show glob.LastErrorText */ }

Chilkat.Http http = new Chilkat.Http();
string s = http.QuickGetStr("https://www.chilkatsoft.com/helloworld.txt");
if (!http.LastMethodSuccess) { /* show http.LastErrorText */ }

Every Chilkat operation in LabVIEW follows the same pattern: construct an object, call methods and properties on its reference, then close the reference.

1. Create a project and put the DLL beside it. Choose File » Create Project » Blank Project and save the .lvproj in a new folder. Copy ChilkatDotNet48.dll into that folder (a subfolder also works). When a VI belongs to a project, LabVIEW looks for .NET assemblies in the project's folder and its subfolders. In the Project Explorer, right-click My Computer and choose New » VI, then open its block diagram (Ctrl+E).
2. Create a Chilkat.Global object with a Constructor Node. From the Functions palette, choose Connectivity » .NET » Constructor Node and place it on the diagram. The Select .NET Constructor dialog opens:
   • Click Browse… next to Assembly and select ChilkatDotNet48.dll in your project folder.
   • Under Objects, expand Chilkat and select Global.
   • Under Constructors, select Global() and click OK.
   The Chilkat namespace in this dialog lists every Chilkat class. The Constructor Node now outputs a Chilkat.Global reference.
3. Call UnlockBundle with an Invoke Node. Right-click the Constructor Node's reference output and choose Create » Method for Chilkat.Global Class » UnlockBundle. LabVIEW places an Invoke Node that is already wired to the reference. This right-click menu is how you reach any method or property of any Chilkat class. Right-click the Invoke Node's bundleUnlockCode input, choose Create » Constant, and type your unlock code. For the 30-day trial, any string works.
4. Check the result. UnlockBundle returns a Boolean. Wire it to a Case Structure. In the False case, add a Property Node for LastErrorText: right-click the Invoke Node's reference output, choose Create » Property for Chilkat.Global Class » LastErrorText, and wire it to a string indicator. LastErrorText explains exactly what went wrong.
5. Create a Chilkat.Http object and call QuickGetStr. Place a second Constructor Node, and select Chilkat » Http » Http() in the same way as step 2 (the assembly is already in the list now). Right-click its reference output and choose Create » Method for Chilkat.Http Class » QuickGetStr. Create a string constant for the url input, https://www.chilkatsoft.com/helloworld.txt, and right-click the return value and choose Create » Indicator to show the response.
6. Check the HTTP result. Methods that return a string or an object don't return a success Boolean. Use the object's LastMethodSuccess property instead. Add a Property Node on the Http reference, after the Invoke Node. Right-click the Property Node and choose Add Element (or drag its bottom edge down) so that one node reads both LastMethodSuccess and LastErrorText.
7. Wire the error clusters and close the references. Wire error out of each node to error in of the next, starting at the Global Constructor Node, running through the Http nodes, and finishing at the Close Reference nodes described next. LabVIEW runs nodes in dataflow order, so this error-wire chain is what makes the unlock run before the HTTP request. At the end, wire each reference to a Close Reference node (Connectivity » .NET » Close Reference), and wire the final error out to an error indicator.
8. Run it. Switch to the front panel (Ctrl+E) and click Run. The response indicator shows Hello World!.

The finished block diagram, node by node

Reading left to right along the error wire, the finished diagram contains these nodes:

A single error wire runs through nodes 1, 2, 4, 5, 6, 7, and 8 in that order, which guarantees that the unlock completes before the HTTP request starts.

Working with the Chilkat API in LabVIEW

The Chilkat reference documentation and examples for C# apply directly: the class, method, and property names are the same in LabVIEW. Chilkat methods don't throw exceptions for ordinary failures. They return false (or set LastMethodSuccess to false), and LastErrorText explains why. That means the LabVIEW error wire stays clean even when a Chilkat operation fails, so check the return value or LastMethodSuccess as shown in the walkthrough.

Chilkat's progress events (PercentDone, AbortCheck, ProgressInfo, and others) can be handled with LabVIEW's Register Event Callback node from the .NET palette. Most LabVIEW applications don't need them. Call the methods synchronously, and set a timeout property such as ConnectTimeout or ReadTimeout where the class has one.

Deploying a built application

When you build an executable with the Application Builder, LabVIEW includes ChilkatDotNet48.dll as a dependency and copies it into the build output (by default into the data folder next to the EXE). After a build, check that the DLL is there. On the target machine:

Troubleshooting

Error 1386: "The specified .NET class is not available in LabVIEW"

The Chilkat DLL could not be loaded. The most common cause is a bitness mismatch, such as the x64 DLL in a 32-bit LabVIEW. See Match LabVIEW's bitness. If the bitness is correct, work through the other causes in the next item: a missing Visual C++ runtime, a DLL that Windows has blocked or that is on a network share, or a missing .NET Framework 4.8.

"Could not load file or assembly 'ChilkatDotNet48' or one of its dependencies"

• "An attempt was made to load a program with an incorrect format": the DLL's bitness doesn't match LabVIEW's. Use the other download.
• "The specified module could not be found": the Visual C++ v14 runtime of the same bitness isn't installed. Install it (see Deploying).
• "Operation is not supported" (HRESULT 0x80131515): .NET treats the DLL as coming from a remote source. This happens when the DLL is marked as downloaded from the Internet or is loaded from a network share. Right-click the DLL, choose Properties, check Unblock, then restart LabVIEW. Keep the DLL on a local drive.

The Constructor dialog can't find the Chilkat classes

Make sure the VI is saved inside a LabVIEW project and ChilkatDotNet48.dll is in the project's folder or a subfolder. A VI that isn't in a project looks for private assemblies next to LabVIEW.exe instead, which is not a good place for them.

Updating to a new Chilkat version

After LabVIEW loads a .NET assembly, it keeps the file locked until LabVIEW exits. To update, close LabVIEW, replace ChilkatDotNet48.dll with the new version, and reopen the project.

Other options

.NET 8. LabVIEW 2025 Q1 and later can also load .NET 8 assemblies through a separate Select .NET Core Constructor option on the Constructor Node. That support is newer, NI documents features it does not yet cover, and NI is still extending it in each release. The Chilkat .NET 8 package (ChilkatDnCore) is distributed through NuGet. For LabVIEW we recommend the .NET Framework 4.8 assembly on this page: LabVIEW's .NET Framework support is mature, it works in every LabVIEW version from 2013 on (with .NET Framework 4.8 installed), and it's a single DLL.

ActiveX. LabVIEW can also use the Chilkat ActiveX through its ActiveX Automation Open, Invoke, and Property nodes. The .NET assembly is simpler because it doesn't need registration with regsvr32. The same bitness rule applies.

Documentation & Next Steps

• 📖 Chilkat .NET (C#) Reference Documentation — class, method, and property names are the same in LabVIEW
• 💻 Chilkat C# Sample Code — each example maps line-for-line to Constructor, Invoke, and Property nodes
• 📦 All Chilkat .NET downloads
• ✉ Contact Chilkat support

LabVIEW, CompactRIO, and PXI are trademarks of National Instruments Corporation.