Hugging Face Comes to SOTA: SafeTensors Models Now Run Natively in LabVIEW

Hugging Face is now available in SOTA.

With this new add-on, LabVIEW developers can load and run AI models distributed in the SafeTensors format natively inside LabVIEW, using the LabVIEW Deep Learning Toolkit available directly from the SOTA platform.

This is an important step for the Graiphic ecosystem. SOTA already gives LabVIEW users a practical path to modern AI through ONNX, ONNX Runtime, GGUF workflows, PyTorch-oriented model paths, and Graiphic’s own Deep Learning, Computer Vision, Accelerator, GenAI, DeepMX, GraphMX, and VisionMX toolkits.

Hugging Face was the missing bridge.

With SafeTensors support, SOTA now connects LabVIEW developers to one of the most important model ecosystems in modern AI while keeping inference, deployment, data processing, and orchestration inside LabVIEW applications.

Why Hugging Face Matters

Hugging Face has become one of the most important entry points for modern AI models. Researchers, companies, open-source communities, and independent developers use it to distribute models for computer vision, natural language processing, multimodal AI, generative AI, classification, detection, segmentation, embedding, and many other tasks.

For many teams, Hugging Face is where modern AI starts.

But for LabVIEW developers, accessing that ecosystem has usually meant leaving the LabVIEW environment, writing Python glue code, converting models, managing dependencies, and creating fragile integration layers between a model repository and an industrial application.

That is exactly the type of fragmentation SOTA was designed to reduce.

With the new Hugging Face add-on, SOTA makes this model ecosystem more accessible from LabVIEW. The goal is simple: allow engineers to use modern AI models without forcing them to rebuild their workflow around external scripts, notebooks, or disconnected runtimes.

SafeTensors: A Modern Format for Model Weights

SafeTensors has become a major format for distributing model weights in the AI ecosystem.

Its purpose is clear: store tensors in a format that is safer and faster to load than older pickle-based approaches, while keeping model weights portable and practical for modern AI workflows.

For LabVIEW users, the important point is not only the file extension. The important point is access.

Many modern models are now distributed with SafeTensors weights. By supporting this format inside SOTA, Graiphic opens a direct path between the Hugging Face ecosystem and LabVIEW applications.

A model that would previously require a separate Python workflow can now become part of a LabVIEW-centered engineering pipeline.

Completing the SOTA Model Format Story

This new add-on completes an important part of the SOTA strategy.

SOTA has already been built around model interoperability and graph-based execution. ONNX and ONNX Runtime provide the historical foundation for portable model execution and optimized runtime deployment. GGUF support gives SOTA a practical path for local generative AI workflows. PyTorch-oriented integration gives engineers a bridge toward one of the most widely used training ecosystems.

Hugging Face SafeTensors support adds the model-distribution layer that was still missing.

In practical terms, this means SOTA is no longer only about running models created inside a specific workflow. It becomes a stronger bridge between the places where AI models are trained, published, shared, downloaded, and deployed.

The result is a more complete LabVIEW AI ecosystem:

• ONNX for portable graph-based model execution,
• ONNX Runtime for optimized execution and hardware provider support,
• GGUF for local generative AI runtime workflows,
• PyTorch-oriented paths for model development and compatibility,
• SafeTensors for Hugging Face model weights,
• SOTA for LabVIEW integration, orchestration, and deployment.

This is not just another format checkbox. It is a major step toward making LabVIEW a practical environment for modern AI.

Native LabVIEW Workflows for Modern Models

The goal of the Hugging Face add-on is not to make LabVIEW developers think like Python infrastructure engineers.

The goal is to let them stay inside the engineering environment they already use.

With SOTA and the LabVIEW Deep Learning Toolkit, the model becomes part of the application workflow. Engineers can connect model execution to data acquisition, image processing, signal processing, test benches, automation logic, monitoring interfaces, and deployment targets.

This is where LabVIEW has always been strong: orchestration.

LabVIEW is not only a place to run a function. It is a place to connect systems. A model can receive data from sensors, images, files, test sequences, or industrial processes. Its outputs can feed decisions, indicators, dashboards, alarms, control logic, or post-processing pipelines.

By adding Hugging Face SafeTensors support, SOTA brings more modern models into that same orchestration environment.

Why This Matters for Industry

Industrial AI adoption is often slowed down by integration work.

Teams may find a model that looks promising, but the real question comes later: how do we run it in our application, on our hardware, with our data, inside our deployment constraints?

That is where SOTA becomes important.

SOTA is designed to reduce the distance between model availability and engineering usability. It gives LabVIEW developers a more coherent environment for loading models, preparing data, running inference, using optimized execution paths, and integrating results into real applications.

With Hugging Face SafeTensors support, this becomes even more relevant.

Industrial teams can now explore a wider model ecosystem while keeping the final workflow closer to their LabVIEW systems. That matters for test benches, machine vision, measurement systems, embedded applications, research platforms, robotics, automation, and AI-assisted engineering tools.

The result is not only easier access to models. It is a more practical path from model discovery to system integration.

More Than a Model Loader

The Hugging Face add-on should not be seen only as a file loader.

It is part of a larger Graiphic direction: making modern AI techniques usable in LabVIEW without forcing engineers to manage fragmented external stacks.

Graiphic develops the toolkits, the model execution layers, the orchestration logic, the examples, and the integration workflows needed to make advanced AI usable in real systems.

DeepMX makes model execution feel like a driver. GraphMX extends graph-based computation. VisionMX simplifies practical computer vision workflows. The GenAI Toolkit brings language, audio, and multimodal workflows into LabVIEW. The Deep Learning Toolkit remains the foundation for model creation, training, and inference.

Hugging Face SafeTensors support strengthens that stack.

It gives SOTA access to a model ecosystem that modern AI teams already use, while preserving the Graiphic philosophy: keep the workflow graphical, integrated, inspectable, and usable by engineers.

A Bridge Between Model Ecosystems and LabVIEW Applications

Modern AI is not built around one format, one framework, or one runtime.

Engineers need to move between ecosystems. Researchers may publish a model on Hugging Face. A team may train with PyTorch. Another workflow may rely on ONNX. A local generative AI application may use GGUF. An industrial application may need to run everything inside LabVIEW.

SOTA is built to connect those worlds.

The Hugging Face add-on is a major part of that bridge. It gives LabVIEW users access to models distributed in SafeTensors format while keeping the execution workflow inside the SOTA platform and the LabVIEW Deep Learning Toolkit.

That is the real value: not only reading a file, but making the model usable inside an engineering application.

What This Enables

This new integration opens the door to many practical workflows.

Computer vision teams can explore modern image models and integrate them into LabVIEW inspection pipelines.

Research teams can test model architectures while keeping their experiment orchestration graphical and visible.

Industrial engineers can connect model inference to acquisition, automation, and reporting logic.

Educators can use LabVIEW as a visual environment for understanding model behavior and AI workflows.

Companies can reduce the gap between open model ecosystems and internal engineering systems.

This is exactly where SOTA is strongest: it turns AI models into system components.

Conclusion

Hugging Face is now available in SOTA.

With the new SafeTensors add-on, LabVIEW developers gain direct access to one of the most important model ecosystems in modern AI, while keeping inference, deployment, data processing, and orchestration inside their LabVIEW applications.

This completes a major part of the SOTA model-format story. After ONNX, GGUF, and PyTorch-oriented workflows, SafeTensors brings the Hugging Face ecosystem closer to LabVIEW.

For Graiphic, this is not only a format integration. It is another step toward a larger objective: giving engineers access to modern AI techniques inside the environment where they already build real systems.

SOTA is becoming the bridge between model ecosystems and industrial LabVIEW applications.

Explore SOTA, install the Hugging Face add-on, and start running SafeTensors models natively in LabVIEW.