GLG Toolkit:
Dynamic Vector Graphics Framework
Visualization and HMI / SCADA

Run Java Demos
Run Mobile Demos
Download C/C++/.NET Demos
Request Evaluation Copy

Request Web Conference


Graphics Builder

HMI Configurator

Widgets and Custom Components


Programming API

Royalty-Free Run-Time Engine

Web Deployment: Java or AJAX

Pricing Information

Industry Examples

Integration with Application Environment

    C# and .NET
    ActiveX Control

Data Integration and Supply

Database Connectivity and Tag Data Access

Object Selection
User Interaction

Cross-Platform Use
    Unix and Linux
    Java / Web / AJAX
Technical Details


    Object Model


    Constraints and Layers

    2D and 3D Dynamics

    Automatic Damage Repair

Supported Platforms



GLG Process Monitoring Demo GLG Toolkit is a state-of-the-art real-time graphics framework for developing highly graphical dynamic interfaces: not just simple buttons and menus, but fully animated graphical objects that show dynamic data and react to users' interactions. It is not just a drawing tool for creating "pretty pictures" (there are plenty), but a graphical engine that allows developers to define graphical objects and interact with them from a program. It is uniquely targeted towards an application developer, converting a tedious job of coding low-level graphics into an engaging interactive design of high-level behavior.

The Graphics Builder plays the central role in the Toolkit. The Builder allows the developer to define the look of an interface independent of its functionality, and change it at any time without touching the code, avoiding time-consuming compile-link cycles. It provides easy access to any and all advanced features of GLG graphical objects, including constraints, 2D and 3D dynamics, custom events, viewport and image objects, layering and  subdrawings, groups and object hierarchies.

The Toolkit maintains the correct balance between the functionality of the drawing editor and the programming API. The Builder allows the developer to define intricate connections between graphical objects, while leaving the functional logic to where it belongs: a more wieldy programming environment. The programming API provides a seamless access to the high-level resources defined in the drawing, so that the code does not need to concern itself with what the interface looks like, only with its logical structure.

GLG Electrical Circuit Monitoring Demo The GLG Toolkit redefines the meaning of the word "framework". Usually, a framework is a structure for enclosing an application, so that the entire application has to be written within it, instead of integrating into a native programming environment. GLG Toolkit may be used as both the framework (in which an application is built) as well as a native component (Motif, Gtk or Qt widget, MFC class, Java bean, C# User Control, ActiveX control, etc.) which can be easily inserted into the framework of your application. As such, it still allows unlimited access to the graphical object engine inside the component.

If the nature of the graphics or the number of objects is not known until run-time, the GLG's Extended API can be used to generate objects dynamically. While other toolkits are limited to defining the graphics at design time, using the either a drawing editor or a limited-feature script, the Toolkit's Extended APIs provide the application with the ability to create drawings at run-time, adding or deleting graphical objects dynamically, based on database query, configuration files or user input. The picture on the right shows an example of a GIS-based application that creates icons at run time to visualize a variable number of moving objects.

GIS Demo uses Extended API to create airplane icons The Toolkit's unprecedented level of control is accomplished with a concise and compact API. A handful of functions provide the functionality which usually requires hundreds. All attributes and resources are accessed and modified with the same Get/Set resource method due to the consistent resource-based model. In other toolkits, each attribute has a different set of access methods, so if an object has 30 attributes, the developer needs to become accustomed with 30 different functions. In GLG, even custom attributes created by the user are still accessed as resources with the same Get/Set resource methods. All a programmer needs to know is the name of a given resource, either an intuitive default such as FillColor, or any custom name given to the resource by the developer.

Click here for examples of the Toolkit used in various industries.

Graphics Builder: Point and Click Graphical Editor

GLG Graphics Builder The dynamic graphical screens are created interactively using a graphical editor - the GLG Graphics Builder. Using the Builder, a developer can draw graphical objects and edit their properties, as well as define dynamic behavior and attach data sources for animating the drawing with real-time data. The drawing is saved into a file, which is later loaded in an application using the GLG library.

In addition to creating drawings from scratch, the Graphics Builder provides palettes of pre-built widgets, such as dials and meters,
graphs and process control symbols, which can be added to the drawing using Drag and Drop. The Builder also allows the user to define custom symbols and add them to a palette as reusable components.

With the help of the Builder, the job of creating and maintaining graphics, from simple dashboards to complex visualizations and custom HMI screens, is done in an interactive, point-and-click environment. The graphics may be easily edited in the Builder with no programming involved. Once the updated drawing is saved, it is ready to be used by the program without recompiling the source code.

The GLG Graphics Builder is geared towards application development and allows the developer to not only draw graphical objects, but also attach 2D and 3D dynamic animation, define object and resource hierarchies, setup constraints, etc. The Builder also provides a way to prototype the drawing with dynamic data to test the drawing's behavior.

The governing principle of the Toolkit is to allow developers to define as much of the graphical aspects of the application in the Builder as possible, leaving the code to handle only the application logic. In the beginning, the Builder is used to draw graphical objects, edit their shapes, define colors, gradients, shadows and other rendering attributes, attach dynamics for animation and layout the graphics in the drawing.

Furthermore, the Builder allows developers  to assign custom names to objects and their attributes. They become resources for the application to access. The Toolkit organizes resources into tree-like hierarchies, resembling the way files are organized in a file system. This decreases the number of resources visible on each level of the hierarchy, making dealing with large drawings easier. The resource hierarchy of the drawing may be tuned interactively with the Builder to minimize later programming efforts.

The Builder provides two ways to access objects: by selecting objects and traversing their hierarchies, or by browsing resources directly. Object selection provides immediate access to objects for editing, while the resource interface views the hierarchy as the application sees it, and is convenient for debugging resource access errors.

The produced drawing encapsulates the graphical appearance of the objects, and is completely separate from the application code. As a result, the application does not need to be recompiled when the drawing changes, as long as the resource hierarchy remains intact. This feature is useful when providing multiple versions of the drawing, all of which contain identical resource hierarchies, but may differ in appearance. For example, some versions of the drawing may contain much more elaborate graphics, while those with simple graphics result in faster updates.

The prototype mode of the Graphics Builder may be used to animate a drawing or widget with real or simulated data. The run command of the Builder has a variety of options for supplying data. For samples of run commands, use Ctrl-Click in widget palettes to load widget drawings with the default run commands, then click on Run in the toolbar to prototype. A custom editor extension DLL can also be used to supply data and handle user input, allowing to prototype a complete application right in the Builder.

HMI Configurator

 The HMI Configurator is a simplified HMI editor intended for use by the end-users. While the GLG Graphics Builder may be used by an application developer or systems integrator for creating elaborate visual components with complex dynamics, the goal of the HMI Configurator is to provide an end-user with an easy-to-use editor to compose custom displays using a library of pre-built components with a minimal learning curve.

With the HMI Configurator, an operator can create and configure HMI displays by dragging and dropping pre-built components from the provided component libraries, as well as draw any graphical primitive such as a polygon, arc or text object. An operator can edit the visual appearance of objects in a drawing, add animation,  browse and select data sources, as well as run the resulting HMI and animate it with live real-time data.

The HMI Configurator supports OEM customization features, such as configurable menus and icons, as well as custom Data Browser and Run-mode animation modules. It also allows an OEM vendor to limit editing of custom components to the component's properties exposed by the application designer, define custom dynamics options and color palettes, as well as provide custom dialogs for application-specific editing actions.

The HMI Configurator may be incorporated into an application to provide the end-user with the ability to create and edit HMI displays.

OEM Extensions

Both the Graphics Builder and the HMI Configurator support OEM customization via loadable DLL extensions (shared libraries on Linux/Unix). Both editors can be customized to add custom icons, menu entries and custom dialogs for application-specific tasks, custom Data Browser, custom animation module for the Run mode, as well as custom dynamic actions and color palettes. An OEM example provides a sample of a custom DLL that allow the user to adds custom actions to objects in the HMI Configurator. The SCADA Viewer Demo provides an example of handling custom actions at runtime.

Widgets and Custom Components

Sample Dashboard with GLG Controls The Toolkit provides a vast library of pre-built widgets: dials and metersgraphs, avionics gauges, process control widgets and other graphical components. All widgets are built on top of the Toolkit's object engine and their behavior is encapsulated in the component's drawing. Each component's drawing can be loaded into the Graphics Builder and extensively customized, including not only editing its resources, but also changing the shape of its graphical elements. Custom components can be created and added to the Builder's palette.

Custom OEM components can be created in the OEM version of the Graphics Builder by defining public properties for easy editing of the custom components. Custom OEM components can be used with the HMI Configurator which provides a simplified editing interface for end users.

Click here for more information on the GLG widgets.

Click here for the list of available widget sets.

GLG Toolkit FeaturesSamples of GLG widgets

Simplified Development Process

GLG Avionics Dashboard Demo A common application requires creating a dynamic screen displaying the current state of a process control, network monitoring or any other mission critical system. The screen must change in real-time to reflect the current data and react to an operator's actions, converting them to signals to control equipment or vessels being monitored. The Toolkit specifically targets such tasks. 

The screen will contain graphical objects representing hundreds or even thousands of pieces of equipment which can move, rotate, change colors, fill levels and labels based on changes in data. The screen should support object selection, flicker-free updates, drill-down, panning and zooming. It must possess the ability to  function on Unix, Linux, Windows and browser environments. The screen should be screen-resolution independent, to display both on small embedded monitors or large wall-mounted displays. With such a specification, the task is nearly impossible-- unless the GLG Toolkit is used.

With the Toolkit, a developer no longer needs to worry about tediously coding low-level graphics for a particular platform. Instead, the developer draws graphical objects in the Graphics Builder, defines dynamics and resources the application accesses, and saves the drawing. He/she then inserts the drawing into an application using one of the provided GLG containers, and starts using GLG's simple but powerful high-level Programming API. The API is used to set the drawing's resources, supply data and handle user interaction.

The Toolkit saves months of development time by eliminating low-level graphics code, providing a point and click drawing editor and allowing fast prototyping directly in the Graphics Builder. Finally, the Programming API allows the developer to concentrate on the application logic by enabling complete control over any and all objects in the drawing and letting the Toolkit to handle the rest.

Inherent Dynamics

Due to the vector nature of the GLG graphics, every attribute of a graphical object, from a line width to gradient color, is inherently dynamic. If an attribute of a graphical object is changed by assigning it a new value, it will be automatically reflected in the drawing, updating not only the object itself, but also all other objects in the drawing affected by the change.

The dynamic nature of GLG objects makes them ideal for rendering dynamic icons. Alternatively, if static bitmaps were used, a separate bitmap would be necessary for each variation in color, line width, fill level, etc., which quickly becomes an unmanageable task as the number of dynamic objects increases.

With the Toolkit's vector graphics and resource mechanism, every attribute of an object is accessible as a resource. If the value of a resource changes, the Toolkit will update the drawing accordingly. The Toolkit's automated damage repair redraws all objects intersecting the update area, as well as objects that have attributes constrained to the changed attribute. The automated damage repair uses double buffering to eliminate flickering.

In addition to changing attribute values directly,  more elaborate dynamics are also available using dynamic transformations. For example, instead of setting an RGB color value directly, a color list transformation may be attached to the object color to change the color from green to red based on the value of the state variable. A threshold transformation may be used to change color when the value of a variable exceeds predefined limits.

Transparency and Alpha-BleningFill Dynamics ExamplesThere are two special attribute dynamics types that deserve a special mention. The fill dynamics is achieved by changing the value of the FillAmount attribute. The fill dynamics using arbitrary fill angle is supported. A visibility dynamics is achieved by simply changing the value of the Visibility attribute. Fractional values of the Visibility may be used for transparency and alpha-blending, as well as object dimming and highlighting.

Unlimited Geometrical Dynamics

In addition to the attribute dynamics, full 2D and 3D geometrical dynamics are supported using geometrical transformations. The move, scale, rotation, shear, mirror and path transformations may be used to change object shape or position in the drawing by specifying the move, scale or angle parameters. The object rendering in the drawing will be automatically updated when the controlling parameter is changed by the program.

The unique feature of the Toolkit is the ability to attach dynamic transformations not only to the geometrical objects, such as polygons, rectangles, etc., but also to the object's attributes. For example, geometrical transformations may be applied not only to objects, but also to the object's control points, providing a powerful way to change an object's shape. Another example is attaching a move transformation to the center of the rotation dynamics to dynamically move the center of rotation.

Scalable Vector Graphics

Upon resizing the drawing, the contained graphics are automatically resized to fit the new screen size, insulating the application from worry about the exact screen size. This transparent handling is convenient for monitoring applications in which the user may want to vary the screen size while still monitoring the entire process. An alternative non-resizable mode is available, which displays more objects as the area is increased.

The Toolkit's selection mechanism assures the object selection will work with an object's new dimensions. If it moves, rotates, or changes its shape, the selection mechanism will handle these changes transparently.

Additionally, the Toolkit's integrated pan and zoom features allow the user to navigate through a large drawing. These features can also be controlled from the API.

Choice of OpenGL or native GDI renderer
The newly added cross-platform support for the OpenGL renderer provides all GLG applications with an access to anti-aliased hardware-accelerated graphics, transparency, alpha-blending and other OpenGL rendering features. The OpenGL support is completely transparent to the application and does not introduce any dependencies on OpenGL libraries. At run time, the same application executable may select an OpenGL or native X/GDI renderer.

An OpenGL driver has been added for both Windows and Unix/Linux versions of the Toolkit.Anti-Aliasing The new features of the OpenGL renderer include:
The OpenGL support is completely transparent, and the application developer does not need to know the OpenGL intrinsics in order to benefit from it. The Toolkit handles all low-level details of the OpenGL renderer, providing the developer with the cross-platform access to the OpenGL renderer's capabilities. The application automatically switches to the native GDI renderer if the OpenGL renderer is not available. For example, if an application is displayed on a remote display that does not have the GLX extension, the application will still run using the native X/GDI renderer to display the graphics. The OpenGL libraries are loaded by the Toolkit dynamically if they are available on the system, which avoids OpenGL dependencies in the applications.

At run-time, the Toolkit auto-detects the presence of the OpenGL driver on the system and uses the OpenGL renderer if possible. If the system does not support OpenGL, the conventional windowing system driver is used. The OpenGL renderer may be disabled or enabled at run time as required, and the same executable may be run in either OpenGL or native GDI rendering mode.
Image and DXF Import

A JPEG, GIF or BMP image may be imported into a drawing to be used as a drawing background or an image icon. Both fixed-size and scalable images are supported. Image transparency is supported with an OpenGL renderer. An image may have dynamics attached as any other graphical object, including the variation of the source image based on user data. For example, an icon may use several images to represent different states of an object and have a variable whose value controls which image is used.

Move and scale dynamics may also be used with an image object to control its position in the drawing.

A DXF converter is provided to import DXF drawings and convert them into GLG drawings, which can then be used the same way as any other GLG drawings.


Constraints are a unique feature of the GLG Toolkit. They are especially useful in large drawings or drawings with complex dynamics. If a drawing contains a map with 50 states, whose color is identical, the FillColor attribute of all 50 may be constrained to each other to ease development. Instead of setting the color of each state separately, setting one will automatically change the rest. The code of an application that uses such a drawing is naturally simpler.

In the Builder, instead of selecting each state and setting its color, only the color of one state needs to be changed. In the code, instead of traversing 50 states and setting 50 colors, one SetResource call will accomplish the same goal.

Constraints can also be used to define complex logical dependencies between graphical objects. For example, several objects may have constrained dynamics in order to move in a related way. GLG  graphs and dials utilize this feature extensively.

Constraints can be used to define complex behavior. For example, the seven segment LED widget uses complex constraints so a single Value attribute controls all segments. In the code, one simple SetResource call will display the requested digit, and the appropriate segments will automatically be lit.

Constraints can also be used to handle objects in separate layers as if they were in one.

Advanced Graphical Features

The Toolkit's robust and sophisticated graphics capabilities include splines, gradients, shadows and other 3D effects, 2D and 3D dynamics, constraints, aliases, integrated zooming and panning, object tooltips, layering and subdrawings, image objects, a choice of an OpenGL or native GDI renderer and a GIS map server component. Combined with easy to use resource-based data access and the virtually unlimited power of the Programming API, the GLG Toolkit is a comprehensive graphical solution tested in a variety of industries.

Cross-Platform C/C++ for Windows or Unix and Linux
The Toolkit provides industry-proven solutions for a variety of Unix, Linux and Windows platforms, including all major Unix flavors, various Linux distributions, Windows 95/98/NT/2000/XP/Vista as well as real-time operating systems, which assures an application's code may be deployed on any platform. The cross-platform nature of the GLG Toolkit facilitates ease of portability of the graphics code. The GLG drawings can be reused between different platforms, and the API is identical in various windowing environment. Click here for more information.

Click here for the list of supported platforms.
Java Class Library
The Java version of the Toolkit implements the GLG object engine in 100% pure Java. It supports all features of the C/C++ version of the Toolkit and provides the same API.

The same Graphics Builder is used to create drawings for both C/C++ and Java versions, while the Java class library provides an API for deploying GLG applications in a Java environment. The GLG Java Bean and Applet containers accomplish easy integration into the native Java GUI and browsers.

The GLG Java class library has the same functionality as the C/C++ library, providing a GLG Java application with complete access to all graphical objects in the drawing. The application may be deployed as a stand-alone Java or a web applet, and can manipulate graphical objects or create new objects at run time in response to user actions.

The full support of the Standard and Extended API in the Java version of the Toolkit differentiates the GLG Toolkit from other frameworks that claim to support both C/C++ and Java. While other frameworks support only a limited functionality of their C/C++ framework in Java and often require a converter to convert the drawing to a special run-time format which may be displayed in a Java applet using thin-client technology, the GLG Toolkit treats its Java version as a full-featured and equal member of the GLG Toolkit tools family.

The Toolkit is configurable to use either AWT or Swing components. The full set of Java 2D primitives is supported, including transparency, anti-aliasing and gradient shading. The Toolkit implements conical and spherical gradients in addition to the linear gradients support provided by Java2D itself. The Toolkit also provides shadows and 3D support implemented in the Toolkit's engine.

Click here to run GLG Java Demos in the browser.
C# Class Library
The GLG C# Class Library  implements the GLG object engine in C# and .NET using Windows Forms. The class library provides GLG C# User Control that integrates GLG drawings into the .NET application framework.

The GLG C# class library has the same functionality as the C/C++ library, providing  a .NET application with complete access to all graphical objects in the drawing. An application can animate the drawing with real-time data and handle user interaction with the objects in the drawing. All versions of the GLG API are supported in C#: Standard, Intermediate and Extended. The Extended API can be used to create and add new objects to the drawing at run time.
AJAX Graphics Server
The GLG Graphics Server provides a thin-client  server-side solution that enables web applications to display dynamic GLG graphics on a web page. It does not require Java or proprietary plug-ins on the client side and is an alternative to the Toolkit's thick-client Java-based option.

The Graphics Server loads the drawings created using the GLG Builder, updates them with current data and generates images that are displayed on the application's web pages.
The Graphics Server also handles AJAX user interaction requests, such as object selection, tooltips and button clicks.

In the JSP environment, the Graphics Server is deployed as a Java Servlet. The source code of a sample servlet is provided and may be customized by the application developers according to the application requirements.

Click here to run GLG AJAX Demos, or click here for more information about the Graphics Server.
Web Deployment: Java Rich Client or AJAX Thin Client
GLG applications may be deployed in a web browser using either a Java-based rich client or AJAX-based thin client. The rich client option uses the GLG Java applet on the client, while the thin client uses the server-side GLG Graphics Server to render graphics. Both deployment options support all features of the Toolkit and provide the same API.

The GLG Java Bean and Applet provide top-level containers for a rich client web deployment using the GLG Java class library. With the rich client technology, the complete Java application runs on a client side, distributing the load to a client. The applet renders the graphics on the client and uses the server only to query data, decreasing the server load. However, the client requires Java to be enabled in the browser.

The GLG Graphics Server provides a server-side support for a thin client deployment, which requires only HTML and JavaScript on the client side. With the AJAX-based thin client, the application runs on the server and the client is used only as a display front end. This approach increases the load on the server, but allows the application to display dynamic graphics with no Java or proprietary plug-ins required on the client side. It also enables clients with limited functionality, such as embedded devices or mobile phones, to display dynamic graphics on the application's web pages.

Click here for online demos that demonstrate both deployment options.

Programming API

While the Graphics Builder is used for interactive design of drawings, the Programming API provides a way for the program to interact with the drawing from a program. The API is the second crucial element of the Toolkit, and provides programming access to objects created in the Builder when the drawing is embedded into an application.

The Toolkit provides a number of native programming containers for deploying the Toolkit's graphics in an application, both C/C++ and Java, Unix, Linux and Windows: a Motif/Gtk/Qt widget, an MFC class, Windows custom control, a Java bean with a Java class library, a C# User Control with a .NET class library, an ActiveX Control and more. Click here for more information on available programming containers and deployment options.

A developer will only need to use a single SetResource function call or method to set any of the drawing's resources, which is a result of the resource based Programming API. The programmer needs to know only the name of a given resource, either an intuitive default such as FillColor, or any custom name given to the resource.

The Programming API may be used to modify resources of the drawing at run-time and supply dynamic data for real-time updates. The application needs to concern itself only with supplying new resource values, and the Toolkit's engine handles all details of the low-level graphics and damage repair. The updates are data-driven, so no CPU time is consumed if the data does not change. Click here for more information.

The API may also be used to handle user interaction, such as object selection or interaction with buttons, sliders and other controls. The object selection is handled transparently by the Toolkit, regardless of the screen size or zooming state, and the program's callback is invoked with all selection information every time an object of interest is selected. Click here for more information.

Click on the following links for more information on specific topics of the GLG Programming API:

Cross-Platform Use
Integration with Application Environment
Data Integration and Supply
Object Selection and User Interaction

Royalty-Free Run-Time Engine

The Standard API provides functionality for loading and displaying drawings, updating them with real-time data, as well as handling user interaction and object selection, as described in the previous section. The Toolkit's resource-based API is used for supplying data and accessing objects and their attributes. An alternative tag-based data API for connecting to PLCs and process databases is also provided.

The Intermediate API can be used instead of the Standard API to get access to objects' internals to manipulate them at run time. The Intermediate API can be used for drawing introspection, object layout, coordinate conversion and other advanced tasks. The Intermediate API includes all functionality of the Extended API except the dynamic object creation at run time.

The Standard and Intermediate APIs are royalty-free for all deployment options. Application written using these APIs may be freely distributed without a run-time license.

Dynamic Configuration and Editing API

The Extended API is also available, in addition to the Standard API described above. It provides all functionality available in the Builder to the program at run-time. The Extended API allows the application to create, add or delete objects from the drawing programmatically, which is convenient if the nature of the graphics or the number of objects in the drawing is not known until run-time. It also allows to programmatically add dynamic transformations and constraints to objects at run-time,  instead of (or in addition to) defining transformations and constraints in the Graphics Builder.

The Extended API may be used to implement drawing editor functionality, such as dragging objects with the mouse, and is often used to build custom diagramming applications. It also provides methods for traversing all objects in the drawing as well as introspection methods for querying a list of all resources contained in a drawing.

The Extended API may also be used to dynamically generate drawings based on configuration files, information from a database or user input. The object-oriented resource-based nature of Toolkit makes it extremely easy to create and add objects at run-time and supply data for them, without the need to attach all data variables by hand in a drawing editor. To create an additional instance of a dynamic object, it is copied using the GlgCopyObject function. The copy will contain the same set of resources as the original object. The resources on the copy may be accessed by simply naming the copy and using the name as part of a path name to access the resources inside the copy.

The Extended API is available with all deployment options (C/C++/C#, Java  and ActiveX):

The following lists the types of applications that need Extended API.

  • GLG Diagram Editor Demo A diagram editor where diagram nodes are created at run-time by the user, by selecting a node from a palette and placing it in the drawing.
  • GIS Application with Variable Number of Icons A GIS-based application that needs to create dynamic icons at run time to represent position of moving objects it needs to visualize. Since the number of icons is not known at the design time, the icons are created at run-time by copying the one or more icon templates. Several templates may be used to represent different types of the monitored objects.
  • Supply Chain VisualizationA network-monitoring or visualization application that needs to create a number of nodes and links at run-time, based on the information in its database. The Extended API is used to create nodes based on a database query, as well as connect them with links based on the received connectivity information.
  • A process control application may read a configuration file that describes equipment at a particular plant and generate graphics at run-time, by copying pre-build templates representing various process control equipment and positioning them in the drawing. 

If the drawing can be built ahead of time using the Graphics Builder, the GLG Standard API is sufficient to display the drawing and update it with real-time data.

Select the links for more information:

Purchasing and Pricing Information

Select one of the following links for purchasing and pricing information: