The Cyber Resilience Act (CRA) is coming and it will impact more than just product developers. Any organization placing digital products on the EU market, including those developed and tested using LabVIEW, must meet new expectations for cybersecurity, transparency, and lifecycle support.
This session demystifies the CRA from a legal and practical perspective. What is the regulation trying to achieve? When does it take effect? Which products and organizations are in scope? And how does compliance tie into CE marking and EU market access?
We will walk through the specific CRA requirements - secure development practices, secure-by-default configurations, vulnerability management, documentation obligations, and long-term security support. We’ll explain what they mean in real engineering terms.
The session concludes with actionable guidance: how teams can start preparing now by adopting secure-by-design principles, implementing update strategies, and creating the documentation needed to demonstrate compliance. Whether you’re developing products or the systems that test them, this presentation will help you align your work with the future of regulatory cybersecurity.
If you’ve ever gotten frustrated with trying to create a complex MS Word document with multiple tables, diagrams, and images, this presentation will show you why you should consider using ASCIIDoc to perform these tasks in the future. I’ll demonstrate how Amentum uses ASCIIDoc, Kroki, Vega, and other tools to create multiple types of documents with a professional look and feel from the same source material, in a CI/CD friendly manner, and in a way that meshes well with Git and multiple authors. I'll also highlight open source toolkits that help you write ASCIIDoc documentation from LabVIEW, and how you might use them to help you document and understand your codebase.
Project Templates allow users to simply the start and creation of new projects. This presentation will look at the mechanics of creating an Instrument Project Template that allows end-users to create their own instrument plug-in PPLs for Molecular Beam Epitaxy Growth software.
MCP (Model Context Protocols) is a plugin interface for large language models (LLMs). It allows an AI chatbot to call functions autonomously. Using the MCP toolkit for LabVIEW an AI Agent can call LabVIEW VIs based on their description to complete a given task. This also enables LLMs to call VI-Scripting functions to generate code which is very experimental, but an exciting usecase.
NI now ships official LabVIEW container images and a licensing model built for automation — but going from "I have a container" to a real CI/CD workflow still takes work. This session presents an open-source reference implementation that does exactly that, and that you can copy into your own repositories.
We'll walk through how it uses NI's containers and the new licensing to run headless LabVIEW on GitHub Actions, and how it parses the .vipc and .dragon files in your repo to build a dependency-matched image stored in your own GitHub Container Registry. On top of that foundation it delivers a rich workflow: whole-project Mass Compile, VI Analyzer reports, visual VIDiffs, a searchable VI Browser, unit tests, and a live dashboard — all on every commit.
The goal is a working example you can learn from and reuse, with a one-click installer to apply it to your own repos in minutes.
Are you curious about what DQMH is and how you can use it for developing applications?
Have you tried using DQMH before but were left confused with the number of VIs that are created and where to use what?
Do you find yourself confusing requests with broadcasts or vice versa all the time?
Are you looking to integrate DQMH modules into existing code or into UIs as subpanels?
Then this session is for you! Vijayanth (a relatively new user to the framework) and Steve (a heavy DQMH user and Enthusiast) will focus on the critical points that make understanding the framework much easier.
We will start with a short presentation where we explore DQMH on a conceptual level, using a real life example to understand the framework design and terminology. Then, we will transition to a coding session where we explore how a user can create a DQMH module, and other users can easily test and integrate it into their existing code. We will wrap up by exploring how DQMH modules can be embedded into UIs with subpanels.
Actor Framework is a powerful architectural pattern for building scalable and maintainable applications. It helps make developer life easy when dealing with applications that need to cater to multiple, concurrent processes. However, it has a steep learning curve if you wish to put all its features to use.This session provides an introduction to Actor Framework, covering its core concepts, commonly used overrides and use cases. It will also showcase utilities and tips that simplify Actor Framework development, helping developers build robust asynchronous applications with greater confidence and efficiency.
I've realized there isn't much information on how to use the latest versions of Panther Dashboard for DQMH. I want to give a quick hands-on tour of this tool, where I'll showcase use cases and highlight some lesser-known features.
Functional Global Variables (FGVs) are a common LabVIEW design pattern for sharing data while encapsulating state and avoiding traditional global variables. Although simple and effective for many applications, they can become a bottleneck as systems grow in size and complexity.
This presentation explains what FGVs are, the problems they solve, and recommended usage practices. It also explores their limitations, particularly regarding scalability, maintainability, and parallel performance, before introducing alternative architectures better suited for larger and more demanding applications. Attendees will gain practical guidance on when FGVs are the right choice and when they are not.
Desktop Execution Trace Toolkit (DETT) is a powerful debugging tool. Especially for LabVIEW applications that cannot be paused — large modular systems, time-critical applications like robot control. Nearly all the information you need is already in the trace log. The problem is that it comes as a flat list of events, and assembling the right picture from those pieces is left entirely to you. When the same data is presented as a sequence diagram or a dashboard with trends in a chart, what was buried in hundreds of log lines suddenly becomes clear from a single glance.
In this presentation, we will discuss the views which are helpful to us.
We will also introduce VisualDETT, an early-stage tool with a plugin-based architecture that decouples trace data from its visualization. We will discuss the motivation, the architecture, and the kinds of views it enables in different situations -- from a sequence diagram of Actor Framework messaging to a dashboard of DQMH messaging intensity and multi-application trace composition.
Continuous Integration and Continuous Deployment (CI/CD) practices can significantly streamline LabVIEW development, but setting up a reliable pipeline requires tying together several tools that don't naturally talk to each other. This session provides a practical, end-to-end guide to building a CI/CD pipeline for LabVIEW applications using the LabVIEW Command Line Interface (LV-CLI) for automating builds, Jenkins for pipeline orchestration, and batch files for scripting the steps in between. It will walk through how these pieces fit together, common pitfalls, and practical tips for setting up automation in real LabVIEW projects.
Developers transitioning from desktop LabVIEW applications to Real-Time (RT) targets often hesitate to adopt advanced software architecture due to concerns about determinism, performance, and resource constraints. This presentation demonstrates that the Delacor Queued Message Handler (DQMH) framework can be successfully applied to LabVIEW Real-Time applications when designed with modularity and deterministic execution in mind. It discusses architectural principles such as minimizing module dependencies through a dedicated Controller Module, organizing software according to hardware or business processes, and separating user interface functionality from RT code. A proof of concept implemented on an NI myRIO using LabVIEW Community Edition 2025 validates the approach, showing reliable execution with low jitter and execution times well below a 10ms Timed Loop period. The results suggest that DQMH provides robust, scalable, and maintainable architecture for Real-Time systems, making it a practical choice for applications ranging from compact embedded controllers to larger Compact RIO and PXI-based platforms.
To the nascent eye, regular expressions (or regexes for short) are confusing. And amazing. A weird combination of brackets and certain symbols, interspersed with letters or numbers produces a bewildering array of matches or lets you replace text like magic. But, learn the syntax, even a little, and you soon realize how powerful regular expressions can be. I would classify the time I spent understanding regex as yielding the greatest ROI. I have found an astounding number of scenarios over the years where my knowledge of regex has shortened the time taken to complete a task, or helped me provide a more flexible, elegant solution.
In this presentation, I would like to introduce you to regular expressions, show how you can learn and master it by yourself, and walk you through LabVIEW specific challenges to help you harness the full power of regex.
The LabVIEW 2026Q3 release includes the open sourced Icon Editor. Let's spend a few minutes going over features we discovered through discussions, digging through code, and performing testing.
Digital Twins, Digital Engineering, and the Critical Role of Measurement Systems
Digital twins are rapidly transforming the way complex systems are designed, validated, operated, and maintained. While much of the discussion around digital twins focuses on simulation, AI, and predictive analytics, the foundation of every successful digital twin is trustworthy real-world measurement data.
This presentation explores what digital twins really are, how they are created, and the ecosystem of organizations and technologies involved in building and maintaining them. We'll examine the growing adoption of Model-Based Systems Engineering (MBSE) and SysML v2 as the backbone of modern digital engineering, enabling organizations to establish a connected digital thread spanning requirements, architecture, design, implementation, verification, and operations.
The session will then focus on where LabVIEW and measurement systems fit into this evolving landscape. Attendees will learn how test systems provide the data needed to validate models, calibrate simulations, refine digital twins throughout a product's lifecycle, and ultimately increase confidence in engineering decisions. Real-world examples will illustrate how measurement systems are becoming an essential component of modern digital engineering workflows rather than existing as isolated validation tools.
Whether you're developing automated test systems, supporting manufacturing, or building next-generation engineering solutions, this session will provide practical insight into how LabVIEW measurement systems can play a central role in the future of digital engineering.
Actor Framework scales well. As an explicitly object-oriented design, it offers the experienced developer an extensive array of options for managing the complexities of large systems. New developers, however, need a way in. This presentation is that starting point! If you understand the queue-driven message handler, I’ll give you the framework-specific knowledge you need to write the actor that takes its place, with almost no knowledge of object-orientation required. I will then show you how to build simple systems at the level of complexity of a few QMH modules. Wrapping up, I will cover the specific applications of a few OO techniques that will let you start to unlock the full potential of the framework. By the presentation’s conclusion, you’ll understand that anyone can start working in Actor Framework!
In windows the common error handling is the dreaded Blue Screen of Death. In this day and age robust error handling is fundamental to building reliable, scalable, and maintainable automated test and measurement systems. However, developer practices around error propagation often range from unhandled error wires to blanket suppression, leading to subtle bugs, poor code readability, and performance degradation.
Furthermore, errors leak across action VIs into test sequences cause the dreaded runtime error dialogue to appear.
This presentation explores the handling of errors in both TestStand and LabVIEW and the combination of the two, and discusses different approaches to make better solutions.
Omni-Bus is a LabVIEW library that provides a common value-based abstraction for both application data and external I/O, including interfaces such as Modbus and UDP. By exposing these different data sources through a unified interface, Omni-Bus helps reduce coupling, simplify integration, and support cleaner, more scalable, and more maintainable LabVIEW architectures.
Generative AI is rapidly transforming software engineering, but most conversations focus on code generation. In reality, engineering teams spend far more time understanding existing applications, reviewing changes, maintaining legacy systems, ensuring compliance with coding standards, and integrating quality checks into continuous integration (CI) workflows.
This presentation introduces GenVI, an AI-powered software engineering assistant designed specifically for LabVIEW developers. Rather than generating LabVIEW code, GenVI helps engineers understand complex codebases, improve software quality, accelerate modernization efforts, and automate engineering workflows across the software development lifecycle.
Through live demonstrations, attendees will see how GenVI can:
- Perform intelligent code reviews and identify architectural, maintainability, and quality concerns.
- Audit LabVIEW applications against coding standards, project specifications, and reference implementations.
- Accelerate modernization initiatives by helping engineers understand legacy applications, identify dependencies, and prepare systems for modernization workflow.
- Integrate with CI workflows to automate code audits, generate review summaries, and provide actionable feedback before changes are merged.
- Enable engineers to interact with large LabVIEW codebases using natural language, making it significantly easier to navigate, understand, and document complex systems.
The session will also discuss practical approaches for incorporating AI into existing LabVIEW engineering workflows while keeping developers in control of design decisions and implementation. Attendees will leave with practical ideas for leveraging AI to improve code quality, reduce maintenance effort, streamline modernization projects, and build more efficient engineering processes for LabVIEW applications.
Security professionals often use TableTop exercises to talk through a "what would we do if ..." scenario. It's a great way to think about what you would do. It also helps to point out where existing policies and safeguards might need updated and where policies and safeguards might need added. I will walk through 3 scenarios that are guaranteed to get you thinking and give you something to talk about with your team.
If you've been around software engineering for a while or follow Kent Beck you may have heard of the term TCR -Test Commit or Revert. It's a really simple idea that can help you build great habits. As Kent Beck says he's not a great programmer just a mediocre programmer with great habits. Learn how to apply this technique in LabVIEW.
Test, automation, and industrial control systems are facing new security risks in the era of AI and highly interconnected systems. Many teams face new regulatory pressure, like the European CRA and US CMMC, which require secure development practices. Until recently, most security guidance and tools available were created for IT and web stacks, leaving LabVIEW teams with a significant gap. This session breaks security down into three fundamental questions every team must answer: What's in your software and is it safe? Did you run security-focused tests and document what you've fixed? Is security considered throughout your software lifecycle? We'll cover how to answer these questions for your LabVIEW development team, including a survey of security tools which support each domain.
Whether you are seeking compliance or simply aiming to build more secure software to protect your data, systems, and customers, this talk will leave you with a foundation for building more secure LabVIEW software.