This presentation explores the integration of Microservice Architecture (MSA) with LabVIEW, focusing on how to build scalable, modular, and maintainable systems. It covers the principles of microservices, independent service design, and communication within the LabVIEW ecosystem, and we will explore the different technologies we can use.
You've already learned the basics of DQMH and now want to use it in existing or new projects. What practical consideration do you need to make when it comes to integration with existing architectures, hardware abstraction layers using classes, and even TestStand. We will also explore some design patterns using DQMH, tips and tricks, and add-on tools that augment the framework with practical examples from a LabVIEW veteran.
Vecto is a new library that's been written for distributed systems that combines periodic telemetry, commands, and lower priority status and file transfers. Vecto is not an application framework and is intended to be integrated into other application frameworks or used more directly. Using Google's Protobuf serialization format, this library aims to be easier to integrate into other environments. This presentation will cover an overview of the networking and protocols in use, high level organization of the library, performance demos, debug tooling, and example use cases. An application framework (Volatus) has been developed that uses Vecto directly and will be used for some demos.
The plan would be to talk about cybersecurity best practices with OT technology. This includes how to best manage network infrastructure along with best practices for securing OT devices such as Arduino, Raspberry PI, PLCs, cRIOs, and other IoT and OT devices.
We will see a demo of developing GenAI applications in LabVIEW using LabVIEW LLM libraries. We will use LabVIEW LLM libraries to talk more in detail about the following:
1. Interact with large language models (LLMs), be it online or offline models. The libraries provide pre-built support for popular models.
2. Use the libraries to build a RAG (Retrieval-Augmented Generation) system, which combines the power of LLMs with a retrieval mechanism to enhance the quality and relevance of generated content.
3. Interact with the vector databases for efficient storage and retrieval of embeddings. The libraries provide seamless integration with popular vector databases, but also allow for custom implementations if required.
4. Utilize the libraries to build your own data processing pipelines for tasks such as data extraction, chunking, embedding.
5. Last but not the least, lets see the VLM(Vision Language Model) capabilities of these libraries to implement some interesting applications using LabVIEW.
Link - https://github.com/solitontech/labview-llm-libraries-eap
Processing large datasets in LabVIEW requires careful attention to memory management and execution efficiency. This paper explores key optimization strategies, including memory preallocation, in-place data manipulation, loop refinement, and parallel processing. By applying these techniques, developers can significantly enhance performance, reduce execution time, and build scalable LabVIEW applications capable of handling high-volume data with minimal resource overhead.
Discover the current state of NI's open-source program, the community behind its evolution, and the latest developments that might just inspire a second look.
Configuration is something that practically every program needs. Over the years, I have seen many approaches, but few that managed to be reused from project to project. The DVE Library was my approach to trying to create a scalable reusable configuration tool that could be used from project to project
Many frameworks focus on event driven notifications centered around Actors (DQMH, AF, etc) as the dynamic event source. The Data Librarian, a scalar data storage re-use library inverts the paradigm, instead of caring about the source of the data, it allows modules to only care about the data itself.
So we all have that time when we are asked to work on a piece of code we don't know about, or know the framework. (Mainly the who wrote this and we should rewrite it moment.) This presentation explains how to ensure the software is supportable going forward and the team stays together and excels.
The integration of Raspberry Pi with LabVIEW opens new possibilities for automation, control, and data acquisition in embedded systems. This presentation explores the seamless deployment of LabVIEW applications on Raspberry Pi, enabling engineers and researchers to leverage its low-cost, high-performance capabilities. We will discuss the setup process, required software components, and key considerations for deploying and running LabVIEW-based programs on Raspberry Pi.
NI's Actor Framework ships with LabVIEW and is especially good for creating medium to large applications. This presentation will show you simple and straightforward ways to get started using it.
We present SOTA, the first complete deep learning and computation framework built entirely on ONNX and ONNX Runtime, allowing engineers, researchers, and academic users to import, edit, train, execute, and deploy AI models and general-purpose computation graphs directly in LabVIEW, the industry-standard graphical data-flow programming language.
No Python. No Docker. No Jupyter.
Just pure data-flow programming—powered by LabVIEW, designed for those who demand modularity, determinism, and performance in their control, measurement, or AI systems.
Unlike traditional code-based environments, LabVIEW’s graphical data-flow design enables real-time interaction with variables, live updates, and intuitive debugging. This built-in interactivity offers a unique development experience where users can manipulate, observe, and annotate execution flows directly—making AI model development not just efficient, but truly interactive.
For the first time, we offer a simple graphical interface to the ONNX / ONNX Runtime ecosystem, unlocking new development approaches powered by LabVIEW’s graphical data-flow paradigm.
SOTA goes further than any existing solution.
It delivers a unified platform experience that eliminates the fragmentation typically encountered when getting started in AI development.
Not only does it support both training and inference, but it also enables intuitive construction and editing of computation graphs: users can visually build, modify, and orchestrate ONNX graphs as native LabVIEW workflows.
SOTA goes further than any existing solution:
Executing pre- and post-processing functions as native LabVIEW nodes
Running Reinforcement Learning agents with full ONNX execution graphs
Reproducing advanced deep learning workflows like YOLOv11 segmentation—entirely within ONNX Runtime, and without relying on Python or Ultralytics
This is a technological first.
By extending ONNX Runtime beyond AI—into the execution of general-purpose computation graphs—SOTA introduces a new paradigm: graph-based computing for control, test & measurement, and high-performance applications.
SOTA was built for three core domains:
Industry, where ONNX models are integrated into state machines, QMH, or Actor Frameworks for real-time automation and embedded deployment
Research, where low-level ONNX graph control enables complex architectures, custom training loops, and experimental flexibility
Academia, where the Keras-like high-level API and visual data-flow design drastically lower the entry barrier, accelerating AI education
We actively contribute to the ONNX Runtime training branch and have implemented missing operators to unlock full training support, enabling two global firsts:
Training a YOLOv11 segmentation model entirely within ONNX Runtime: https://www.youtube.com/watch?v=noDajU7TQDU
Implementing a DDPG reinforcement learning agent as ONNX graphs in LabVIEW: https://www.youtube.com/watch?v=PVkrpMrQd1s
The ONNX Runtime / LabVIEW combination empowers users to integrate AI models into any software architecture, positioning ONNX as a true runtime backend for industrial-grade systems.
SOTA was showcased at NI Connect 2025 in Fort Worth, where it received enthusiastic feedback from the LabVIEW community.
It is also available for free to students, supporting education and open research.
SOTA has been shortlisted for the EIC Accelerator, one of Europe’s most competitive deep tech funding programs—often considered the European counterpart to Y Combinator.
More on the vision behind SOTA: https://youtu.be/H796QY27Nw8?si=27EC2Skgpm3-1bR4
LabPcap enables direct network packet capture and injection from LabVIEW, built on top of a robust packet capture backend.
With LabPcap, developers can:
- Discover live network interfaces
- Apply Berkeley capture filters
- Capture packets in real time
- Dump captured packets to .pcap files
- Emulate a live capture from a .pcap file
- Inject custom traffic from memory or from a .pcap file — all from within their LabVIEW applications
Born out of a need at Framatome to test a proprietary nuclear I&C network, LabPcap helped bypass the complexity of integrating its custom C driver.
The talk will include live demos and discuss practical use cases.
I’ll also share the steps taken to make LabPcap open source, and invite the LabVIEW community to help shape its future — through code reviews, beta testing, and open discussions around .NET/LabVIEW deployment.
We introduce a comprehensive LabVIEW-based calibration automation solution that integrates local calibration benches with a cloud-based SaaS platform via a custom socket protocol. This paper highlights the architectural design, emphasizing the challenges overcome in establishing reliable real-time communication and automating highly repetitive calibration processes. By providing a user-friendly framework, we aim to empower calibration labs to embrace automation and contribute to the evolution of digital calibration certificates, ultimately enhancing data integrity and operational efficiency across the manufacturing sector.
DQMH 7.1 introduced a new feature that allows to execute code after each of the DQMH Scripting tasks, Panther Dashboard uses this feature to have a deeper Framework integration.
In my talk I´ll describe:
What is this feature
Where to get the Scripting VI templates
Explain how Panther Dashboard uses this feature
Managing development environments in LabVIEW projects has historically posed challenges in version control, dependency management, and integration with private packages. To address these issues, we introduce a LabVIEW library inspired by Python's requirements.txt, enabling seamless configuration of the development environment directly within LabVIEW projects. This solution supports both online packages and locally configured folders, allowing developers to specify version constraints and manage dependencies without bundling packages into the project itself. Our approach not only simplifies collaborative development but also ensures reproducibility and compatibility across different systems. In this presentation, we delve into the architecture, versioning strategy, and implementation details, highlighting the key differences from existing tools and demonstrating practical applications in LabVIEW environments.
LabVIEW environment behavior is controlled by many options, but only part of them is accessible through the Preferences dialog. But some of these options are very useful—and it's not just about disabling the ZOOM feature. We implemented a package that adds our favorite options to that dialog and also allows further expansion. No more manual editing of the LabVIEW.ini file!
I am planning to talk about how to communicate data from Real Time (RT) systems to host (PC). I will be listing the possible ways to do the same and then would like to elaborate more Shared Variables. That will have the following agenda,
1. What are Shared Variables?
2. And its types
a. Single Process
b. Network Published
3. Explain both of the types and its use cases
4. And its advantages and disadvantages
5. Finally a demo
6. Conclusion
In this presentation, I would like to show an easy way to build your application along with the practical exam for Certified LabVIEW Developer (CLD) certification.
Here, I encourage you to use the DQMH framework available in LabVIEW to easily build your application, each requirement for the exam and demonstrate an impressive knowledge about a complex software development approach in your exam.
SOLID design principles help improve OOP based programs. They are an integral factor in writing better code that minimizes bugs or helps make it easier to debug. Novice programmers are unaware of them, and even experienced programmers might overlook them from time to time.
There have been quite a few presentations before about the SOLID design principles and their use in LabVIEW. However, they all follow a set pattern (run through them in order from S to D). More importantly, they were all from a time when LabVIEW did not support interfaces as a core language feature.
Now that interfaces are officially supported, it is important we revisit these design principles and understand how to implement them when writing LabVIEW code. I would also like to structure my presentation to complement these older presentations rather than rehash them. I plan to emphasize more on the why than the what. Starting with a small example, I will show how, as new features are added, SOLID design helps the example to become more modular, scalable, testable and flexible to modifications.
Building on my previous presentation idea, "A Fluid Understanding of the SOLID Design Principles and their use in LabVIEW", I would like to illustrate implementing the SOLID Design Principles in a real project.
The LabVIEW File Read/Write VIs have two issues. The first, LabVIEW happily allows the developer to write code that reads from a write-only file or writes to a read-only file at edit time. It is only when the program is run that an error pops up. It would be better if the error is at compile time rather than at run time. The second issue is a long standing bug that gives erroneous outputs with Preallocated Read from Binary File. Both of these issues can be circumvented with an OOP based approach.
LabVIEW on Windows also offers support for DLL based or .NET file read/write. If interfaces are added into the above API, we could provide the end user with a really flexible API that allows them to choose which type of flie read/write they wish to do as well.
I would like to illustrate all this with code I am developing at present. I feel it would help cement the understanding of the more theoretical aspects of my other presentation.
Think Workers for LabVIEW is just for Windows-based applications? Think again.
With modern NI real-time targets becoming increasingly powerful, deploying structured, scalable architectures on embedded systems is not only possible, it’s practical. This presentation will walk through how Workers 5.0 is designed to support seamless development across both desktop and NI real-time platforms.
We’ll cover features that make this possible, including the RT Worker Convert Tool, the built-in TCP Server/Client Network Endpoint Workers, and how the Workers Debug Server can be used to monitor real-time systems over a local network.
To tie it all together, the session will include a live demonstration of two Workers applications — one running on an NI cRIO and another on a host PC — communicating in real time.
Have you ever used FIFO to stream high-speed data from your FPGA target to the host? But after compiling your FPGA, you realize you'd rather stream another signal—then you need to recompile. Could there be a way to do this dynamically so that you can select which signals to stream at runtime?
In this presentation, I will show how I have developed a FIFO-based system to high-speed monitor (or write) a large number of signals in FPGA code. It is used in projects ranging from motor control in medical rehabilitation equipment to hardware-in-the-loop engine simulation.
This presentation is aimed at fellow beginners who are curious about the DQMH design pattern. As someone who is new to DQMH myself, I’ll be walking you through what I’ve learned while getting started with it. We’ll begin by looking at what DQMH is, how it builds on the familiar Queued Message Handler (QMH) pattern, and why it’s a powerful tool for creating organized, modular, and scalable applications in LabVIEW.
Using simple examples and clear explanations, I’ll share how DQMH has helped me better structure my code, manage communication between different parts of an application, and make my projects easier to debug and maintain.
Whether you’re a student, a junior developer, or just starting out with LabVIEW frameworks like I am, I hope this session gives you a solid foundation in DQMH and the confidence to begin using it in your own work.
This presentation introduces the Behavior Tree for LabVIEW framework, a powerful alternative to traditional state machines for managing complex process logic.
An early preview of Micron, an open source LabVIEW based microservice architecture. The presentation will cover Micron APIs and will walk through how to create a microservice application and send messages from an external application.
I presented on why we need an autoformatter at GDevCon NA. One piece of feedback I got was people wanted to see more demos. I'll spend 2-3 minutes talking about the different use cases and then I'll do a demo (maybe just prerecorded short video) and then I'll answer any questions.
Find All Uses is by far my favorite short cut menu plug in.
It has some limits though. I finally start resolving those limits and I'll share the process.
I've been busy building out the hardware landscape for the CTI project. I'm hoping this will be useful for trainers, learners and hobbyists.
I'll introduce Grove from SEEED
Demonstrate VIs for the various Grove projects
Describe I2C comms and how to write drivers using protocol.
Describe my plans for OS material based on this (hopefully demo, but no promises)
Show Radxa X4 Grove hat that I've been designing.
and more as I think of it