No winter slowdown: openDAQ 3.30.0

Dušan Kalanj

12/16/2025

As we approach the end of the year, we’re happy to share the latest openDAQ update. The team has been working steadily on new functionality, performance improvements, and extended device support, all of which are included in openDAQ 3.30.0. Below is an overview of the most important additions.

C Bindings

The openDAQ API now includes C bindings. These bindings allow the development of openDAQ-compatible applications in C. The following example shows how to create an openDAQ instance, detect devices, and display their names.

#include <copendaq.h>
#include <stdio.h>

daqInstanceBuilder* instanceBuilder = NULL;
daqInstanceBuilder_createInstanceBuilder(&instanceBuilder);

daqInstance* instance = NULL;
daqInstance_createInstanceFromBuilder(&instance, builder);

daqList* availableDevices = NULL;
daqDevice_getAvailableDevices((daqDevice*)instance, &availableDevices);

daqIterator* iterator = NULL;
daqList_createStartIterator(availableDevices, &iterator);

while(daqIterator_moveNext(iterator) == DAQ_SUCCESS)
{

daqDeviceInfo* currentDevInfo = NULL;
daqIterator_getCurrent(iterator, (daqBaseObject*)& currentDevInfo);

daqString* name = NULL;
daqDeviceInfo_getName(currentDevInfo, &name);

daqConstCharPtr nameConstChar = NULL;
daqString_getCharPtr(name, &nameConstChar);

printf("Name of the device: %s\n", nameConstChar);

daqReleaseRef(currentDevInfo);
daqRelease(name);
}

// All non-basic objects need to have their references manually released to prevent memory leaks
daqReleaseRef(iterator);
daqReleaseRef(availableDevices);
daqReleaseRef(instanceBuilder);
daqReleaseRef(instance);

The bindings support the entire openDAQ API. More examples of C binding usage can be found in our repository at: examples/applications/c/.

Module Licensing Interfaces

OpenDAQ now features options for modules to implement licensing mechanisms and binary tampering detection. Modules have access to a standardized interface through which license keys can be provided in the form of a license key, certificate path, or others. 

Additionally, openDAQ applications can provide a “Module Authenticator” that allows for tampering detection. Module files are checked with user-provided authenticators before being loaded, allowing applications to selectively load only approved modules.

Examples of licensing and tampering detection usage are available in the openDAQ repository (examples/modules/licensing_module).

Component Property Search

OpenDAQ now supports property search within a property object, as well as recursive search through a component and its child components. Property search filters based on visibility, read-only status, and name are available, along with aggregation filters such as conjunction, disjunction, negation, recursive wrappers, and user-defined custom filters.

To create a property search filter:

#include <coreobjects/search_filter_factory.h>
// ...

using namespace daq::search::properties;

// `visibleWithWriteAccess` filter accepts only visible properties with write access
SearchFilterPtr visibleWithWriteAccess = And(Visible(), Not(ReadOnly()));

// `nonObjectWithName12345` filter accepts only properties with name "12345" except object-properties
SearchFilterPtr nonObjectWithName12345 = And(Name("12345"), Not(Type(CoreType::ctObject)));

// `finalFilter` filter accepts only visible properties with name "12345" and write access
// except object-properties, enabling recursive search in child property objects 
SearchFilterPtr finalFilter = Recursive(And(visibleWithWriteAccess, nonObjectWithName12345));

To find and change specific property(-ies):

using namespace daq;
// Assumes `propertyObject` is a previously defined instance of type `PropertyObjectPtr`
// and `device` is a previously defined instance of type `DevicePtr`

// Filter by property name, accepting all properties whose names start with the word ‘Frequency’.
SearchFilterPtr propertyFilter = search::properties::Name("Frequency.*");

// find properties within the property object
ListPtr<IProperty> properties = propertyObject.findProperties(propertyFilter);

// find properties within the device and all its child components recursively
ListPtr<IProperty> componentProperties = device.findProperties(propertyFilter, search::Recursive(search::Any()));

// change properties values
properties[0].setValue(newValue);
componentProperties[0].setValue(otherValue);

Improved Error Logging

When something goes wrong, openDAQ now provides the full context instead of just a single error message.

Complete Error Chains: Every error captures where it originated and what triggered it. When errors cascade through multiple layers, openDAQ preserves the complete path - showing you how an issue in one component affected others. You can instantly see the causal relationships, making root cause analysis straightforward.

Smarter Validation: The framework validates error chains, ensuring you only see meaningful relationships. You get accurate, actionable information without confusion from unrelated errors. Faster problem resolution, clearer insights, less frustration.

LabVIEW Integration Preview

A preview version of openDAQ for LabVIEW is now available! It demonstrates basic integration of the openDAQ into LabVIEW, including simple examples for device discovery, connection, and signal visualization in the format of VIs. The current LabVIEW driver is available for LabVIEW 2024 on Windows.

You can download the driver from our resources page here: https://docs.opendaq.com/. Any feedback is greatly appreciated (feel free to write to info@opendaq.com). Please note that this version is not intended for production use, but only for testing and as a proof of concept. A full openDAQ LabVIEW driver will be available in the next openDAQ release, featuring full integration of all openDAQ API functionality.

Other Notable Features

  • Intel LLVM compiler: Added native support for the Intel oneAPI LLVM compiler, including a new CMake build preset and multiple compatibility fixes.

  • Parallel device connection: Bulk device connection is now supported, enabling parallel creation and sequential addition of multiple devices under the same parent device.

  • Main thread event loop: We've added a main thread event loop to openDAQ, turning idle main threads into a useful resource. Many applications end with an idle while(true) loop on the main thread. Now you can utilize that thread to schedule and execute tasks. This is particularly valuable for client applications where graphics libraries require main thread execution, but it's equally useful for any custom logic you want to run there.

  • Circular buffer utility: Added an optional utility that allows applications to create circular buffers for received packets, reducing internal memory allocations.

  • Additional function blocks: New function block examples are available in openDAQ:

    • Parquet recorder, enabling simple signal storage in the Apache Parquet format.

    • WAV reader that loads WAV files and replays them as openDAQ signals.

    • Sum function block that uses the openDAQ multi reader to sum an arbitrary amount of synchronous signals of equal sampling rates.

    • Video player function block that is able to visualize simple video signal data.

  • Generalized client-to-device streaming: Introduces a generalized client-to-device streaming mechanism that enables transmitting client signal data to device input ports with configurable streaming sources. Extends the native streaming protocol and related modules to integrate with this mechanism, while allowing adoption by any streaming protocol through an appropriate integration layer. Streaming-source management concepts are now applied to mirrored input ports, consistent with their use for mirrored signals.

  • New LT Streaming server: Adds a high-performance implementation of the LT WebSocket Streaming Server module. The new module coexists with the legacy server module, allowing users to choose which implementation to instantiate. The new implementation addresses performance and reliability limitations of the previous server.

Release Notes

Many additional features and improvements are included in the 3.30.0 release, such as on-read events over native and multi reader improvements. Please check out the official release notes for more information here: https://github.com/openDAQ/openDAQ/releases/tag/v3.30.0.

We’re excited to see what you build with the latest release. As always, we love hearing your feedback—write to info@opendaq.com to let us know what you think, and what you’d like to see next.