LabVIEW
Text Rendering in LabVIEW
More on interfaces (related to my previous post on buttons). On the left in each picture is a button from a Python-based application in what I am pretty sure is Calibri. On the right is LabVIEW's version of Calibri and Calibri light in a Fuse button. Top is actual size more or less. Bottom is magnified. Is there a way to get crispier text in LabVIEW? What makes the difference? These a screen shots from side-by-side windows? Interestingly, the Mac version of LabVIEW has the more Python-like text. -- David
@FlatCat wrote:
I am to new manifests, and I notice that mt.exe is not even on my computer and needs to be installed (apparently as part of Windows SDK). In which case, doesn't it also need to be installed on the user's computer so it can be executed there by the built app? Does mt.exe then need to be part of the Installer (as an additional installer, perhaps)?
On an even simpler level, where does mt.exe get executed? Within the application via system exec.vi?
Basically it is part of your application build process.
1) Built your LabVIEW application
2) Run mt.exe to add this (and other manifest settings) into the created exe file.
3) If you have a signing certificate and need to sign your executable so users in high security restricted IT environments won't be prompted with ugly warning dialogs about untrusted software, sign your executable now.
4) Optionally create a LabVIEW installer
5) Distribute exe or installer to your users
@FlatCat wrote:
I am to new manifests, and I notice that mt.exe is not even on my computer and needs to be installed (apparently as part of Windows SDK). In which case, doesn't it also need to be installed on the user's computer so it can be executed there by the built app? Does mt.exe then need to be part of the Installer (as an additional installer, perhaps)?
On an even simpler level, where does mt.exe get executed? Within the application via system exec.vi?
As Rolf already explained, this only needs to be executed once as one of the final steps in the build process. The manifest is embedded into the executable’s Resources section (the same section that stores the application icon, for example), just open LabVIEW-built Application in any text editor, search for dpiAware string an you will see.
And yes, "mt.exe" is part of the Windows SDK, sorry, I didn't mentioned it before. It is also installed with NI CVI (as part of SDK) or with the latest SDK under "C:\Program Files (x86)\Windows Kits\..."
However, the good news is that you don’t actually need to install the SDK to obtain just mt.exe. Don’t underestimate modern LLMs — you can ask almost any Copilot to generate a small script that modifies a manifest, and it will do so easily. Here is a simple Python example, just a few lines:
from pathlib import Path
import lief # python -m pip install --upgrade lief
exe_path = Path("Application.exe")
manifest_path = Path("manifest.xml")
output_path = Path("App_with_manifest.exe")
if not exe_path.is_file(): # Check that the input files exist.
raise FileNotFoundError(f"Executable not found: {exe_path}")
if not manifest_path.is_file():
raise FileNotFoundError(f"Manifest not found: {manifest_path}")
manifest = manifest_path.read_text(encoding="utf-8") # Read the manifest
image = lief.PE.parse(str(exe_path)) # Parse the existing executable.
if image is None:
raise ValueError(f"Could not parse PE executable: {exe_path}")
image.resources_manager.manifest = manifest # replace the manifest.
image.write(str(output_path)) # Write the modified executable
print(f"Manifest embedded successfully: {output_path}")
A prefer Rust personally, works as well
use editpe::Image;
use std::fs;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let exe_path = "Application.exe";
let manifest_path = "manifest.xml";
let output_path = "App_with_manifest.exe";
// Read the manifest as UTF-8 text.
let manifest = fs::read_to_string(manifest_path)?;
// Parse the existing executable.
let mut image = Image::parse_file(exe_path)?;
// Keep existing resources and create a resource directory if absent.
let mut resources = image.resource_directory().cloned().unwrap_or_default();
// Add or replace the application manifest.
resources.set_manifest(&manifest)?;
// Update the executable's resource directory.
image.set_resource_directory(resources)?;
// Write the modified executable to a separate file.
image.write_file(output_path)?;
println!("Manifest embedded successfully: {output_path}");
Ok(())
}
By the way, you can explore your executable using tools such as TotalPE2 by Pavel Yosifovich (author of several Windows Internals books): https://github.com/zodiacon/TotalPE2/releases
And, as mentioned above, if you inspect the original LabVIEW application, you’ll see that it already contains a manifest:
A more elegant solution is therefore to modify the existing manifest instead of replacing it completely. You can still use the script above (or mt.exe) — simply extract the manifest from the LabVIEW EXE, update the DPI settings manually, and embed it again. Or you can ask "AI" to extend the script above with a bit of “intelligence” to patch the manifest automatically.
