Skip to main content

Introduction

Open Node Protocol (ONP) is a foundational shift in how we build software, designed specifically for the AI era. Imagine a system of intelligent, digital LEGOs – each block ("node") representing a specific function, UI element, or piece of data. These nodes seamlessly connect to build anything from simple applications to complex, AI-powered systems. ONP provides the standardized, modular framework that makes this possible, enabling faster, more intuitive, and collaborative software creation.

What is a Node?​

Think of an ONP node as a smart, self-contained building block for digital creations. Just like LEGOs:

  • Nodes connect to other nodes.
  • Each node has unique properties (inputs, outputs, triggers, actions).
  • Combining multiple nodes creates larger, more sophisticated systems.

Learn Key Concepts​

Ready to dive in? Here's where to start:

  • Tutorial: Get a quick, hands-on understanding of how nodes connect and communicate.
  • Playground: Start building interactive applications by visually arranging nodes.
  • Showcase: Discover the vast range of possibilities with ONP – see what others have built!

Core Principles​

The Open Node Protocol is built upon these key principles:

  • AI-Native: Nodes are inherently understandable by Large Language Models (LLMs).
  • Human-Friendly: Designed for intuitive use by both non-coders and developers.
  • Language-Agnostic: Build nodes in any programming language.
  • Highly Reusable: Nodes are designed to be used and reused across different projects.
  • Open Standard: The specification is open and encourages community contributions.
  • Extensible: Developers can extend the specification to meet specific needs.
  • Composable: Nodes can be easily connected and arranged to create complex systems.
  • Modular: Each node is a self-contained, independent unit of functionality.
  • Data-Driven: Nodes communicate through well-defined data inputs and outputs.
  • Event-Driven: Nodes can trigger and respond to events.
  • Secure: Nodes are designed with security considerations in mind.
  • Scalable: ONP is designed to support large and complex applications.
  • Interoperable: Nodes built to the ONP standard can seamlessly interact.
  • Portable: Nodes can be portable.

Terminologies​

Nodes​

A node is a building block (like Lego blocks) that allow users to piece them together to create interactive pages or applications. A Node can be as simple as a single function (e.g. age calculator) or as complex as an entire entity with complex visual and interactive elements (e.g. a map component).

More fundamentally though, a Node is the description of a building block, the blueprint of it. It describes the node itself (the Manifest), the means of communication with the Node (the Properties), and the logic that is performed when the node is used or changes in some way (the Logic).

Instances​

An Instance is a running copy of a Node. If a Node is blueprint, an instance is a single implementation of that blueprint. If you think of a Node as a blueprint of a house, an Instance is the actual built house, a single stamped output of taking a blueprint and implementing against it.

When you add a Node to an Openexus application, you are creating an Instance of that Node. Changes you make to that Instance are only applicable for that Instance and do not change the node itself.

Properties​

Each node defines zero or more Properties. A Property is a single named data point of a Node. These data points each hold a specific value. The type of the value and use are entirely dependent on the Node.

Connections​

Instances are tied to one another by a Connection. A Connection represents a binding between two specific Properties in two separate nodes. You connect a Property on some Node to a Property on a different Node.

When a Property changes on the first Node, the Property on the second Node is changed as well. We describe this as the Properties being "in-sync" meaning that what happens to one is reflected in the other.

Nodes Assembly​

A collection or group of nodes is called a Nodes Assembly. Typically a group of nodes are arranged and connected together to create an interactive page, or a backend pipeline.

Stitcher​

The stitcher is the canvas where you can assemble nodes together. On the stitcher, you can add nodes and connect them together via drag-and-drop.