Have you ever been editing text in LabVIEW and tried to use Ctrl-B to make text bold? It doesn’t work, because Ctrl-B is the keyboard shortcut for Remove Broken Wires.

In LabVIEW 2013 and later, however, you can use Ctrl-B to make text bold with the INI token QuickBold=True.

It’s not an official feature… more like a lab experiment that we’ve let out into the wild. It’s highly unusual for an application to use the same keyboard shortcut for completely different menu items based on the current state of the editor. But, I have to admit, in practice it seems pretty intuitive.

The reason this can work is that Remove Broken Wires is disabled while you are editing text. The unpublished INI token re-enables the menu item and makes it perform the same action as selecting Style>Bold from the Text Settings pull-down menu on the toolbar. So, to be clear, it only works in situations where you have text selected and the Text Settings ring is available.

If you use this “hidden feature” and think NI should make it the default behavior for LabVIEW, please consider voting for the suggestion on Idea Exchange.


LabVIEW 2014

by Christina in LabVIEW

Comments closed Comments

Make informed decisions fast with LabVIEW 2014! Learn more at ni.com/labview/whatsnew


Here are some of my favorite features of this latest release:

Preserving Data when Updating Type Definitions

Previous versions of LabVIEW would sometimes revert the values of type def instances to defaults when updating to a new version of the type def. This was, obviously, undesirable, but it was also a very difficult problem to solve. There is no way LabVIEW can know the user’s intention when converting values from one arbitrary type to another. However, LabVIEW can, if needed, ask the user to approve of the value when the type def updates.

In LabVIEW 2014, if a type def cannot automatically update without possible data loss, it will have a new right-click option to Review and Update from Type Def.

Invoking the menu item will open a dialog where you can review all instances of the type def in memory, and approve the new values. You can also modify the values before approving them.

New Quick Drop Keyboard Shortcut

Harness the power of VI Scripting with Quick Drop keyboard shortcuts! These are keyboard shortcuts used in combination with the keyboard shortcut for Quick Drop (which is Ctrl+Space on Windows).

There’s a new one in LabVIEW 2014 to wire all the selected objects together intelligently.

Review all the available shortcuts by invoking Quick Drop and selecting the Ctrl-Key Shortcuts tab.

You can get additional plugins from the LabVIEW Community, or write your own!

Replace Tunnel on a Case Structure with the Selector

This idea came from the Idea Exchange: a small but helpful feature that makes replacing a case structure tunnel with the selector terminal a simple, one-step operation. Just right-click on a tunnel and select Replace with Case Selector.

Recognizing Missing VIs from Known Packages

Have you ever tried to open a VI written by someone else only to find it had missing subVIs that you couldn’t identify? In LabVIEW 2014, if the VIs are from known toolkits, modules, and add-ons, LabVIEW will tell you so in the Context Help and the Error List window.

Web links for VI Help

Instead of linking a VI’s Help to a file on disk, you can configure it to a URL. Keeping your documentation on-line allows you to update it independently of releasing new versions of your package.

64-bit LabVIEW for Mac OS X

For those of us who use the Mac platform, the 64-bit version of LabVIEW for Mac OS X is a major milestone. Using the modern Cocoa APIs, LabVIEW is now more at home on OS X than it has ever been before. And it finally displays POSIX paths instead of HFS!


There are many more features than I listed here, but I wanted to underscore the “non-features” that also get priority: stability and performance. There were times in the past when LabVIEW users complained they were overwhelmed by upgrading, and LabVIEW had “too many” new features. In recent years, we have sought a better balance of new features and improving existing functionality. Read more about this topic in the white paper LabVIEW Accelerates Productivity Through Improved Stability. So when you see those dialogs asking you to submit crash data to NI, please choose to send! And keep in mind that engineers in R&D actually read what you write in the comment box, so we’d appreciate it if you could tell us something about what you were doing when you encountered the problem.


VI Shots Podcast Guest Appearance

by Christina in "Hidden" Features, LabVIEW

Comments closed Comments

Michael Aivaliotis interviewed me for an episode of his VI Shots podcast.

You can hear us chat about the Bookmarks feature in LabVIEW 2013, secret INI tokens (e.g. enabling Ctrl-B to bold text), and my self-published graphic novel.

VI Shots has other great content including many interviews and tutorials. I hope you check it out!


NIWeek 2013

by Christina in NI Week

It’s almost time for NIWeek 2013!

This year I will be presenting Bookmark API in LabVIEW 2013 on Wednesday, August 7, at 1:00PM in Room 16A. Bookmarks are a new feature in the next release of LabVIEW. In this session you will learn how to integrate bookmarks into your own tools or create your own Bookmark Manager. (Session ID: TS2171)

I’ve looked over the NIWeek session list and there are so many great presentations that I’m not going to be able to see all the ones I want!

Here are some of the sessions that I’m most excited to see:

  • LabVIEW GUI Design: Moving Beyond the Palettes
    – Jon McBee, Bloomy Controls, INC., Senior Project Engineer
    A successful GUI is intuitive and user friendly, and it makes users more efficient when interacting with the system. At this session, learn how to use third-party tools to design professional GUI elements as well as how to import these elements into the LabVIEW environment. Study real-world examples and discuss the methods used to create them. Also explore the techniques you need to create streamlined, intuitive, and elegant LabVIEW user interfaces. (Session ID: TS1684)
  • Designing a Framework in LabVIEW: Borrow or Build?
    – Nancy Hollenback, National Instruments, Field Architect
    With larger and more complex applications using LabVIEW, designing a scalable framework that simplifies modification and facilitates team development is important. Many frameworks are emerging in the LabVIEW community. In this session, consider several aspects of framework design to help you decide between using an existing framework or building one. Also review some of the popular options you can choose from now. (Session ID: TS2209)
  • How to Polish Your Software and Development Process to Wow Your End Users
    – Fabiola De la Cueva, Delacor, LabVIEW Consultant
    Hear from LabVIEW Champion and LabVIEW Architects Forum Founder Fabiola De la Cueva about five “little things” that can improve your application’s usability and create happier, more productive end users. From easy ways for your app to look and feel like a “real Windows application” to subtle features that can make every application template easier for developers to use, explore the secrets that professional LabVIEW developers use to make their lives, and their users’ lives, easier. (Session ID: TS1765)
  • User Events, Tips, Tricks, and Sundry
    – Jack Dunaway, Wirebird Labs, Founder
    Didn’t make it to Paris for the European Certified LabVIEW Architect Summit this year? Catch the domestic reprise of this session to hear from a LabVIEW Champion about the key principles that make Events the primary transport mechanism for product design and application architecture at Wirebird Labs. Leave with nearly a dozen downloadable code snippets, featuring practical event-driven design patterns, and focus on the powerful yet simple semantics of the Events API. (Session ID: TS1691)
  • Making the Most of New User Event Features in LabVIEW 2013
    – Michael Aivaliotis, JKI, Product Manager
    Event-based programming is a recognized best practice in software development, and it is particularly important in LabVIEW, where nearly every significant application uses multiple loops and multiple pieces of hardware. Watch a Certified LabVIEW Architect and LabVIEW Champion demonstrate how User Events work, how JKI uses them in every project, and how they are even better in LabVIEW 2013. Also explore Version 2 of the famous JKI State Machine featuring dynamic event registration. (Session ID: TS1761)
  • Queued Message Handler: Caveats and Design Decisions
    – Darren Nattinger, National Instruments, Senior Software Engineer
    The Queued Message Handler (QMH) project template is an architecture used in many different LabVIEW applications and is one of the easiest starting points when developing a multiloop application. Get a detailed look at all of the design decisions, like handling errors and maintaining state between loops, that went into the QMH project template updated in LabVIEW 2013. (Session ID: TS2104)
  • Everything You Ever Wanted to Know About Functional Global Variables
    –  Nancy Hollenback, National Instruments, Field Architect
    As a longtime foundational design pattern in the LabVIEW community, the functional global variable (FGV) meets many common challenges but can also be overused. Join this discussion of best practices for global data storage and the transition from FGVs to data value references. (Session ID: TS2147)
  • Tips and Tricks to Speed LabVIEW Development
    – Darren Nattinger, National Instruments, Senior Software Engineer
    Hear from Darren Nattinger, world’s fastest LabVIEW programmer and NI senior software engineer, about some simple techniques that can help you code more quickly. Learn about little known LabVIEW features, advanced functions, and other tools that can help you save development time. (Session ID: TS2122)

And NIWeek is more than just great technical sessions. The keynotes rock. I’m also looking forward to these events:

  • LAVA BBQ – This is not an NI-sponsored event but rather a gathering of LabVIEW enthusiasts organized by the LAVA and OpenG groups. Tickets are limited so I recommend buying in advance!
  • NIWeek Conference Party – Wednesday night at Brazos Hall.
  • LabVIEW Coding Challenge Finals – Thursday at noon in the Expo Hall (Technology Theater). See the World’s Fastest LabVIEW Programmer, Darren Nattinger, defend his title.

I hope to see you at NIWeek! If it’s your first time, I have two bits of fashion advice:

  1. Wear comfortable shoes!
  2. Layer your clothes – the inside of the Convention Center is frigid and outside it’s like an oven.

Do you have more NIWeek advice or sessions you want to recommend? Leave a comment!


Close All LabVIEW Windows Except One

I heard a feature request today for a menu item for “Close all windows but this one.”

It’s a reasonable request, but I’m not sure it’s worth adding an item to the (already large) set of menus in LabVIEW today.

That’s because there’s already a way to close windows other than visiting them one by one: the All Windows dialog.

  • From the menu, select Window>>All Windows or use the keyboard shortcut Ctrl+Shift+W.
  • In the dialog, select all, either by using the standard listbox multi-selection (click and Shift+Click) or by using the keyboard shortcut Ctrl+A.
  • Deselect the window(s) you want to keep open, e.g. by using Ctrl+Click.
  • Press the Close Windows button.

In addition, when you’re working in a project (which you really should do!), there’s a menu item in the Project Explorer for exactly what was requested: File>>Close All (this Project).

These menu items are handy when you want to “clean up” after debugging many subVIs.


Custom Wire Appearance in LabVIEW

by Christina in LabVIEW, LVOOP

Have you ever wanted to customize the appearance of a type def wire, e.g. by making it a different color? Unfortunately, you can’t.

But you can customize the appearance of wires for a given LabVIEW Class (LVClass) type! This is another way that LVClasses are like type defs with superpowers.

To customize an LVClass wire appearance, right-click on the LVClass item in the Project tree and select Properties.

In the Properties dialog, select the Wire Appearance category and change the radio button to “Use custom design.”

Then you can have fun playing with the pattern, colors and size!


Intro to LVOOP – Part 1

by Christina in LabVIEW, LVOOP

After talking to a few people who were learning LabVIEW Object-Oriented Programming (LVOOP) at NIWeek, I decided to revisit an introduction to LVOOP here on my blog.

You can think of a LabVIEW Class (LVClass) as a cluster with superpowers. An LVClass has many of the advantages of a type definition but it also gives you much more.

Creating a LabVIEW Class

To create an LVClass, you should be in a Project. (It’s not required, but I strongly recommend it).

Right-click on a target (such as My Computer) in your Project Explorer window and select “New>>Class.”

A dialog will ask you to name your LVClass. Let’s say you name it “Widget.” Two items will appear in your Project tree: Widget.lvclass and Widget.ctl.

The CTL item is not a separate file on disk. It is the private data control for the LVClass. Every LVClass must have one (and only one) private data control, and it is saved in the .lvclass file on disk.

Edit the CTL file and you will see an empty cluster. This is the heart of your LVClass. It is where you define the data members.

Let’s say you want two data members: a Color box and a Boolean. You simply add controls to the cluster.

You may think there is a similarity between this Widget class private data control and a type definition. And you would be correct! But the users of this LVClass cannot unbundle the cluster to access the elements – only VIs that are members of the LVClass can do that.

If you want VIs outside of the LVClass to know about a data member – for example, to be able to read the value of the color box – then you need to create a VI for Data Member Access. Rather than bundling/unbundling the cluster, VIs outside of the class must use the interface VI.

So you can think of an LVClass as being like a type def cluster that’s a “black box” to the VIs that use it. They can “see” the interfaces (e.g. that they can read a color) but they have no idea what else is in the cluster.

The encapsulation of the LVClass also makes it easy to perform actions whenever a data member is read or written. As the designer of the LVClass, you know that there is no way a VI can read or write these data members without going through the VI interfaces you have created for the LVClass.

More on LVClasses later! If you have any questions on the basics, feel free to post them in the Comments. If you have any questions beyond the basics, there’s this place online where the most amazing experts hang out called LAVA… 🙂


LabVIEW 2012 Subdiagram Labels

by Christina in LabVIEW

LabVIEW 2012 introduces a feature requested on the Idea Exchange: Subdiagram labels.

These labels are a part of structures such as while loops and case structures. Unlike free labels placed inside the structure, a subdiagram label automatically resizes with the structure.

You can also color the label using the Coloring (aka paintbrush) tool. Select the Coloring tool using the Tools palette, which is shown using the View>>Tools Palette menu.

Since you can also color the structure itself, you can create interesting effects such as this:


LabVIEW 2012 Project Templates and Sample Projects

by Christina in LabVIEW

In LabVIEW 2012, new Project templates and Sample Projects help you get started with a project as quickly as possible.

Some of the best weapons against “spaghetti code” – diagrams that are hard to read and impossible to maintain – are design patterns such as the Simple State Machine and Queued Message Handler. The Project templates promote starting with one of these tried-and-true designs.

You can also create your own Project templates and Sample projects, but I’ll talk about that more in a future post.

To use the new Project Templates and Sample Projects, you’ll use the Create Project dialog. You can access this dialog by clicking the Create Project button on the LabVIEW 2012 Getting Started window. It’s also in the File menu and the Project menu.


The Create Project dialog lists the available Project templates and Sample Projects. I am only showing the core set; modules and toolkits can install additional items.

If necessary, you can narrow your choices by selecting a category in the left-hand column or typing keywords in the Search box.

After selecting your starting point, you click Next. Depending on the item you have chosen, you may see a different dialog than the one below. For the Simple State Machine, you need to decide your project’s name and location on disk. You can optionally prefix your file names (in case you want to make all your VI names unique across multiple projects) and define a custom icon overlay.


When you click Finish, you will have a new project to work with. This project is a customized copy of the template, so you don’t need to worry about edits to the VIs interfering with other applications (which can happen when people edit examples).

You can now open the Main VI and explore the contents of your project. Areas where you will probably want to focus on writing your own functionality are highlighted with blue comments. Here is the Main VI of the Simple State Machine template:

You may also want to review the Project Documentation, which explains the template (or Sample Project) in great detail.

We believe that the Project templates and Sample Projects will not only get you to a working application faster, but also lay the groundwork for applications that can be extended and maintained long into the future.


LabVIEW 2012 Getting Started Window

by Christina in LabVIEW

When you first launch LabVIEW 2012, you’ll see a Welcome pane with resources for learning about LabVIEW and the new features in this version.

  • The first link is for the NI LabVIEW Skills Guide, which I mentioned in an earlier post.
  • The second is for the list of new features.
  • The third link is a new Help topic that guides you through the recommended process for upgrading your VIs to the latest version of LabVIEW.

Initial Appearance

After you close the Welcome pane (and you can uncheck the Show on launch box if you don’t want it to appear every time you launch LabVIEW), you’ll see the redesigned Getting Started window:

There are two basic points of entry: do you want to create a project or open an existing file?

Note that we are strongly encouraging everyone to work in projects. However, New VI is still in the menu if you need it.

Along the bottom, you have resources and news. Click on the links to bring up the Find Drivers and Add-ons pane, the Community and Support pane, or the Welcome pane (which you saw on first launch).

Recent Items

After you create a project or open files, the Getting Started window will display recently-used items.

If you want to see more items, you can resize the entire window. If you want to keep items from “falling off” the list, you can pin them by mousing over them and clicking the pin button that appears.

I hope you enjoy using the new Getting Started window!