After LabVIEW, Beyond Python: Why Graiphic Is Building FROG
After LabVIEW, beyond Python.
At Graiphic, we believe a new era of graphical programming can begin.
LabVIEW showed generations of engineers something powerful. When you can see the system, you can understand it differently. You can follow dataflow, timing, state, and interaction with far more clarity than in large volumes of syntax alone.
That idea still matters. In fact, it matters even more today.
With GO HW, we pushed our graph vision beyond AI inference and toward system and hardware orchestration. That journey confirmed something important. A graph can become much more than a model. It can become the foundation of how intelligent systems are designed, executed, monitored, and deployed.
But it also revealed a deeper limit.
As long as the graphical language itself depends on closed formats, opaque execution layers, or toolchains that cannot truly be opened and standardized, the promise remains incomplete.
That is why we are building FROG.
FROG stands for Free Open Graphical Language.
It is not just another IDE. It is our attempt to open the foundation itself. A modern graphical dataflow language designed for the AI era, with an open source format, an inspectable execution path, and a clear separation between language, IR, runtime, and IDE.
This is also about Python.
Python changed the world. It democratized AI, automation, prototyping, and research.
But in industry, too many systems now depend on growing layers of glue code, wrappers, scripts, and hidden complexity. What was flexible at first can become harder to inspect, harder to govern, and harder to deploy at scale.
Our ambition is not to erase Python everywhere.
Our ambition is to make possible, for a whole class of industrial and intelligent systems, something more visual, more structured, more inspectable, and more accessible to engineers and domain experts.
Less glue code. More structure. More visibility. More control.
We believe the next generation of software infrastructure must be built for a world where AI increasingly generates, rewrites, transforms, and assists software creation.
Recommended by LinkedIn
In that world, representation becomes strategic.
The question is not only whether AI can generate code.
The real question is whether humans can still inspect it, validate it, govern it, and trust it.
That is where graphical structure becomes more than a convenience. It becomes an industrial advantage.
FROG is a difficult path.
Opening the file format is hard. Opening the IR is hard. Standardizing the language is hard. Separating semantics from execution is hard.
But this hard path is also the sovereign path.
It is the path of long term control. The path of long term inspectability. The path of long term industrial independence.
And we believe it is the necessary one.
Graiphic intends to build a flagship proprietary IDE on top of this open foundation. We believe open standards and product ambition are not opposites. They are complementary. An open standard enables an ecosystem. A great product pushes that ecosystem toward excellence.
We think there is a missing zone to open in modern software systems.
A zone where accessibility meets system grade execution. A zone where graphical programming is not shallow. A zone where open standards strengthen industrial seriousness. A zone where AI generated systems remain human governable.
That is the future we want to help build with FROG.
What if the next great software leap is not more code, but better representations for building, reviewing, and governing systems?
Explore the repositories: https://github.com/Graiphic/FROG https://github.com/Graiphic/GO-Whitepapers
#FROG #Graiphic #LabVIEW #Python #GraphicalProgramming #Dataflow #AI #OpenSource #IndustrialSoftware #EmbeddedSystems
LabVIEW need improvements to the IR layer to leverage AI better, that's for sure, so, your initiative sounds interesting. It's a tall order though; The IDE and IR are hard problems, granted, but at least three other hard problems remain: 1) Which library code do you plan to leverage to get feature parity with an industrial heavy language like LabVIEW / G? You know, to talk to hardware, industrial protocols etc. 2) What will the executable artifacts be? In essence, how will the runtime environment look like to support various targets such as real time and FPGA? 3) What does your timeline and roadmap say about pieces beyond the IDE and language itself (commercial add-ons, community corpus, integrations into the world of standards, compliance, user onboarding initiatives, academia initiatives, global support)?
I am not sure which approach you are going to use for the IDE but I think the User interface of comfy UI is great. It uses json and workflows can be exported and AI can be used to edit, understand and make new workflows which can be imported to the editor.