Skip to main content

Kelp Glossary

This glossary defines common terms that you might see as you're working with Kelp, or throughout our Documentation and Help Center.

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z



An app is a web application created in Kelp. The app runs in a browser and provides interactive features to its users.



The canvas is the working space where you define the app logic. To create an app, you place components on the canvas and connect them with wires.


A component is a building block in Kelp. You create apps using components and connecting them with wires. Basically, Kelp has two types of components: components and widgets. Widgets are visual components that show information to users. However, in the component library, we keep components in different categories, for example, utils, connectors, data processing components, and many others.

Component Library#

The component library is the list of available Kelp components. To open the component library, right-click anywhere on the canvas in Developer mode.

Composite Component#

Composite components consist of core components or other composite components. You create composite components by grouping a piece of the app schema into a single composite component. Composite components help create different abstraction levels in Kelp.

Core Component#

Core components are default components that you see in the component library. Unlike composite components, you can't break down core components into other components.


Data Gateway#

The data gateway is a secure backend service between your app and external data sources. All API calls from Kelp apps go through the data gateway. The data gateway is multipurpose. Kelp uses it for monitoring, security, load balancing, caching, protocol translation, and so on. What security is concerned, the data gateway helps protect, manage, and share user credentials with external secure data sources. The data gateway doesn't store or log any app data. All the app data passing through the data gateway is end-to-end encrypted while in transit.

Data Source Connection#

A data source connection (or a connection for short) is a configuration of settings that Kelp apps use to connect to external data sources. Depending on the data source, a connection contains various settings. For example, connections to secure APIs include necessary authentication information. Connections are reusable: you can use them inside one app or across multiple apps. Kelp has two types of connections: preconfigured and custom, which users add themselves. A list of preconfigured connections covers popular APIs (Google API, HubSpot API, Dropbox API, and more).

Data Stream#

A data stream is a sequence of ongoing events ordered in time. A component that receives the data stream processes each piece at a time. Data streams usually pass events to the List widget or to another component.

Data Transformation#

A data transformation is a transformation of the data that flows between components as events. Each component has the specific data structure it expects to receive. If an in-port of a component receives the data whose schema differs from the expected one, the component won’t operate as it’s supposed to. In this case, you need to apply a data transformation to the data the component receives. Kelp supports various JSON transformation languages, for example, KelpQL, JMESpath, JSPath, and others. To see which data schemes in-ports of a component expect, open the component library and search for the component.

Design Mode#

In Design mode, you arrange and format widgets, which show information to users. You can also set up the app navigation, change styles, and break down the information the app shows into pages.

Developer Mode#

In Developer mode, you build apps by placing components and connecting them with wires.



Events are containers that hold and transfer the response data of HTTP requests through wires. Kelp has two event types: data events and signals. When we mention "events" in the Kelp documentation, we mean data events in most cases. Data events can hold and transfer HTTP requests, constants, changes on a variable, ingested messages, and many other things.

Event Listener#

The event listener is a debugging tool available in Developer and Preview modes. As an interface element, the event listener is a panel, which you can open. The event listener records data events and signals passing through the selected wires. You can then view the recorded data in chronological order.



Component grouping is useful if you want to do the following:

  • Declutter the app schema. If you have a large number of components, the app schema becomes messy. To make it neat, you can hide multiple components in a group.
  • Create a composite component. To create a composite component, you first need to group the constituent components. You decide which components to group. For example, you can group components that have the same objective or those related to a particular piece of the app logic.



The layout is the widget arrangement you create in Design mode.



Components use in-ports to receive events and out-ports to emit events. Each component has one or more in- and out-ports. To trigger a component, no need to connect all ports. The exact ports you need to connect depend on the component type and desired functionality. Kelp has three port types: standard, queryable, and hybrid. To see which ports a component has, open the component library and search for the component.

Preview Mode#

In Preview mode, you can see how an app looks to users.


Queryable Ports#

Queryable ports (or q-ports for short) are bidirectional ports. Unlike standard unidirectional ports, q-ports are pink in the Kelp interface. A q-port is, in fact, two standard ports joined together, where one port can only receive events, while the other one—emit. q-ports can be connected with q-wires only. A real-life analogy of a q-port is a double socket.

Note: Apart from q-ports, Kelp also has hybrid ports, which can accept both standard and q-wires.

Queryable Wires#

Queryable wires (or q-wires for short) are bidirectional wires that connect q-ports and hybrid ports. Unlike standard wires, q-wires are pink in the Kelp interface. A q-wire is, in fact, a bundle of two standard wires, where one wire is a forward data stream, while the other one—a backward data stream. You can split a q-wire into two standard wires, and vice versa: bundle two standard wires into a single q-wire. To do so, you need to use the QPort Client and QPort Server components respectively.



The schema is the logic layer of an app, which you create in Developer mode. The schema is the combination of components, groups of components, and wires that you put on the canvas and connect. As a data structure, the whole schema or any part of it is a JSON object. You can copy and paste a part of the schema on the canvas of other apps.


Signals are special events that can affect the app schema by changing the default operations of components. Signals are a part of the control flow mechanism. They can do the following:

  • Mark the beginning and end of a batch of events.
  • Instruct widgets to display a progress bar.
  • Reset buffer on ports, and so on.

Kelp has several types of built-in signals. Some components, such as the HTTP component, emit signals by default. In some cases, to control the data flow of your app schema, you may need to inject signals yourself.


UI Blocks#

UI blocks are primitives you use to create custom widgets. The Kelp interface is based on Blueprint JS: a react-based UI toolkit for building complex data-dense interfaces for desktop applications.


Vega Chart#

Vega Chart is an integrated widget that supports Vega and Vega-Light declarative visual language. Vega Chart helps to create rich data visualizations.



A widget is a visual component you add to your app schema to design your app interface layout. You add widgets in Design mode. Widgets can show information to users as charts, graphs, icons, tabs, lists, cards, and so on.


As a concept, a wire is a data stream. As an interface element, a wire is a thin line that connects components. You define how data flows in your app by connecting components with wires. Kelp has two wire types: standard and queryable.