PWCT2: A Self-Hosting Visual Programming Language Based on Ring with Interactive Textual-to-Visual Code Conversion

Abstract

Visual programming languages (VPLs) play a significant role in simplifying the process of learning to program and reducing development time. Most VPLs are developed for use in education or specific domains. Recently, some projects have aimed to provide general-purpose VPLs. Among these projects is the Programming Without Coding Technology (PWCT) project, which has been used for several years to develop and maintain the compiler and virtual machine for the Ring programming language. However, PWCT faces several issues related to code generation performance and the operating systems it supports. Additionally, its visual editor lacks many features, such as rich comments, auto-run, and the ability to import textual code, which are highly important in the era of using large language models for generating textual code. In this research, we present the PWCT2 visual programming language, which is distributed on the Steam platform. On Steam, 1772 users have launched the software, and the total usage time recorded exceeds 17,000 h. This generation provides approximately 36 times faster code generation and 20 times lower storage requirements for visual source files. It also allows for the conversion of Ring code into visual code, enabling the creation of a self-hosting VPL. It consists of approximately 92,000 lines of Ring code and comes with 394 visual components. Moreover, using Ring in this project demonstrates the feasibility of utilizing the language for projects of this scale. Ring compiles PWCT2 in less than one second, and the generated bytecode consists of approximately 724,000 instructions.

1. Introduction

Programming languages are essential for the development of systems and applications. They act as a bridge between humans and computers, facilitating control and the creation of software. Over time, a variety of programming languages have emerged, most of which use textual source code to create and represent computer programs [1,2]. During the evolution of programming languages, a category known as visual programming languages (VPLs) emerged. These languages create and represent computer programs graphically, using more than one dimension and incorporating a mix of text, colors, and shapes in their visual representations [3,4]. In Figure 1, we present some of the VPLs developed from 1966 to 2024, showcasing a clear trend of increasing innovation and development in this field. Early pioneering efforts are illustrated by the development of GPE (Graphical Program Editor) in 1966 and Pygmalion in 1975 [5,6], followed by subsequent languages such as Prograph, Simulink, and LabVIEW in the 1980s [7,8,9]. The 2000s saw the emergence of educational and accessible VPLs, like Scratch and Alice, which have become instrumental in teaching programming to younger audiences. For example, Scratch enables children to create stories, multimedia applications, and computer games using a user interface in their native language (Arabic, English, etc.) [10]. More recent advancements introduced in the literature include Envision, Node-RED, Blueprints, and FlowPilot, reflecting the continuous expansion and diversification of VPL applications [11,12,13,14,15].

Most visual programming languages are either used in education or specific fields. Only a few projects have been designed to be general-purpose and versatile. One of these projects is the Programming Without Coding Technology (PWCT), which supports code generation in multiple textual programming languages, such as C, Harbour, Python, and Supernova [16,17]. PWCT was used to create the compiler and virtual machine for the Ring programming language, as demonstrated in Figure 2, resulting in approximately a 23.5% increase in the level of abstraction when using the visual implementation.

This elevated level of abstraction leads to a more efficient development process by enabling developers to concentrate on the overall architecture and functionality of the program, instead of becoming entangled in the details of code syntax. The visual elements offer a more intuitive and user-friendly interface, making it simpler for developers to comprehend and alter the codebase. Moreover, this method enhances usability by lowering the chances of syntax errors [18,19,20].

PWCT has some drawbacks, such as requiring a large storage size for visual source files. Additionally, the Steps Tree Editor lacks features like rich comments and auto-run, and there are performance issues with code generation for large visual source files. Additionally, PWCT does not support the import of textual source code and is designed to operate exclusively on Microsoft Windows. Furthermore, the implementation of PWCT is based on Microsoft Visual FoxPro, which is no longer under active development. These issues need to be addressed when developing a new generation of PWCT [21,22,23].

The proposed PWCT2 design is influenced by advancements in other VPLs. For instance, the inclusion of rich colors and drag-and-drop functionality, as seen in Scratch, could enhance the user experience [24,25,26]. The visual steps editor could also be improved by adopting features from the Envision visual programming system, such as rich comments and interactive visualization. By integrating these proven features from other successful VPLs, PWCT2 can provide a more flexible and user-friendly environment [27].

Most VPLs are developed using textual programming languages; for example, the first generation of PWCT was developed using Visual FoxPro and Envision was developed using C++. Self-hosting PWCT2 is crucial, as it allows the development and modification of the PWCT2 environment using the same visual programming tools that it provides to users. This means that developers can update and enhance PWCT2 through visual programming rather than writing textual code, making the process more intuitive and accessible [28].

We assume that using the Ring programming language to develop PWCT2 could yield better results. The choice to transition from Visual FoxPro to the Ring programming language for the second generation of PWCT was driven by several key factors. Both Visual FoxPro and Ring are dynamic languages that support object-oriented programming (OOP), and each comes with an integrated development environment (IDE), a Graphical User Interface (GUI) framework, and a form designer, making them both suitable for many similar programming tasks. However, Ring distinguishes itself with the advantage of compatibility across multiple modern operating systems, which ensures that the new generation of PWCT can operate efficiently on various systems. Moreover, Ring was specifically designed for developing PWCT2. This decision not only leverages Ring’s strengths but also provides an excellent test of its features and capabilities, particularly since PWCT2 is an advanced project and, to our knowledge, Ring has not previously been utilized for such extensive applications. By incorporating Ring, the second generation of PWCT aims to offer a useful tool for Ring developers while also validating Ring’s effectiveness in handling projects on a scale similar to PWCT2 [29,30].

Therefore, the primary aim of this work, as demonstrated in Figure 3, is to use the Ring programming language to develop a research prototype for the second generation of the PWCT visual programming language. PWCT2 offers several enhanced features, including a more flexible environment, time dimension and auto-run, rich colors and customization, rich comments using text, lines, images, and HTML, an enhanced form designer for GUI applications, support for importing Ring source code and interactive textual-to-visual code conversion, self-hosting of the PWCT2 environment, and cross-platform implementation that supports Windows, Linux, and macOS. These features aim to improve the overall functionality, user experience, and performance of the PWCT2 environment.

The main contributions of this study are:

• The design and implementation of the research prototype PWCT2, which offers enhanced features, lower storage requirements for visual source files, and better code generation performance compared to the first generation.
• The design and implementation of the first VPL that supports code generation in the Ring language (RingPWCT), containing 394 visual components. This integrates visual programming with the flexibility of the Ring language.
• The design and implementation of a textual-to-visual code conversion tool called Ring2PWCT that can import Ring programming language code. Using this tool enables a self-hosting VPL based on Ring.
• Testing the feasibility of using the Ring programming language compiler and virtual machine in the development of projects on a scale similar to PWCT2.

The remainder of this paper is structured as follows: Section 2 delves into related work. Section 3 describes the materials, methods, and the proposed visual programming language. In Section 4, the results and evaluation of the visual programming language are presented. Section 5 includes the discussion. Lastly, Section 6 provides concluding remarks and outlines future work.

2. Related Work

Languages like Visual Basic and Visual C# fall into the category of textual programming languages, not visual programming languages (VPLs). Programmers need to write text-based code using the specific syntax of these languages to develop large and complex real-world applications. Tools like Microsoft Visual Studio 2022 are known as integrated development environments (IDEs) rather than VPLs. These environments allow software developers to create portions of applications using visual elements, but textual code is essential to achieve full control over the application’s functionality. In contrast, VPLs rely exclusively on visual components without the need to write textual code directly. In text-based programming languages like C++ and Java, the code is linear and one-dimensional, with the compiler processing it token by token. In contrast, VPLs utilize graphical representations that span multiple dimensions. Each graphical element occupies a specific position within a 2D or 3D space and can have unique shapes, colors, and images. Various relationships can be depicted between these objects, such as being inside, outside, touching, or adjacent to one another. Additionally, some visual languages incorporate the time dimension (before/after) to further enhance the graphical code representation [4,31].

A visual programming language can have several different representations. One option is diagrammatic, which uses shapes and text components with links to connect shapes and illustrate control or data flow. Another representation is iconic, which utilizes icons derived from the problem’s domain. There are also form-based representations that incorporate forms like spreadsheets or data-entry forms and block-based representations that feature blocks assembled to form programs. Additionally, a VPL can be hybrid, combining elements of any of these four representations [32,33].

The design of the proposed visual programming language is associated with various categories of VPLs. In

Table 1. Some categories of visual programming languages and examples.

Refs.	Category	Examples
[34,35,36]	Block-based	Scratch, Snap!, etc.
[37,38,39,40]	Diagrammatic	Tersus, RAPTOR, etc.
[41,42,43,44]	Iconic	Kodu, Limnor, etc.
[45,46,47]	Form-based and spreadsheet-based	Forms/3, FAR, etc.
[48,49]	Domain-specific	Blueprints, Pure Data, etc.
[50,51]	General-purpose	PWCT, Envision, etc.

, we present some of the different categories based on their visual representations or usage scope, along with examples of visual programming languages that fit within them. It is worth noting that some VPLs can be classified into more than one category. For instance, Scratch could fall into both the first and fifth categories, as it is a visual programming language that uses block-based programming and is designed for use in education and teaching children about programming.

In

Table 2. The main features of the proposed visual programming language.

Criteria	Scratch [52]	Forms/3 [53]	Envision [54]	Lava [55]	PWCT [56]	Proposed VPL (PWCT2)
Open Source	√	X	√	√	√	√
Portable	√	X	√	√	X	√
Rich Colors	√	X	√	X	X	√
Time Dimension	X	√	X	X	√	√
Auto-Run	√	√	X	X	X	√
Rich-Comments	X	X	√	X	X	√
Generate Ring Code	X	X	X	X	X	√
Interactive Visualization	X	X	√	X	X	√
Implementation using Ring	X	X	X	X	X	√
Import Ring Code	X	X	X	X	X	√
Self-hosting	X	X	*	X	X	√
Form Designer	X	√	X	√	√	√
Steps Tree/Blocks	√	X	X	√	√	√
Steps Tree/Blocks (DAD)	√	X	X	X	X	√
Play programs as movie	X	X	X	X	√	√
Supports OOP	X	X	√	√	√	√
Designed for Children	√	X	X	X	X	X
Just for Research	X	√	√	√	X	X

, we present the key features of our proposed visual programming language and its connections to some other visual programming languages from different categories. As we compare these visual languages, if a feature is absent but available through external ongoing projects, we denote it with a (star) in the corresponding cell.

We selected Scratch because it is a popular VPL for education that uses blocks-based programming. Forms/3 is chosen as an example of form-based and spreadsheet-like programming, with support for the time dimension. Lava is included because it is a VPL that uses the TreeView control and supports object-oriented programming (OOP). Envision is selected as a research prototype for a general-purpose VPL that features interactive visualizations. Finally, PWCT is chosen because it is a general-purpose VPL used in advanced projects, such as developing the Ring programming language.

In the efforts made by the researchers to make Envision a self-hosting programming environment, significant strides were achieved. A code generation framework was designed and implemented to represent macros in Envision when importing code from C++. Additionally, an extra stage in the existing C++ import system was developed to facilitate macro import by reconstructing them from expanded code using preprocessor information from Clang. Although the authors reported that time constraints and issues in existing components prevented the complete achievement of the goal, it is important to note that using C++ for Envision implementation introduces some challenges in implementing a self-hosting VPL because of the numerous features and preprocessor usage [28].

Multiple research studies highlight the importance of ensuring the construction of correct programs through visual programming languages. This addresses key aspects of program correctness and reliability, which are critical for enhancing both usability and the practical effectiveness of visual programming environments. PWCT provides two modes of operation. The first mode follows the concept of a syntax-directed editor and prevents composition errors when connecting components. The second mode uses a free editor where mistakes can occur and are then detected by the compiler. In PWCT2, the visual editor prevents composition errors, and the user can use the customization window to allow or disallow errors when typing expressions in the interaction page [57,58].

The first generation of PWCT is influenced by Lava 0.7.2 (using a TreeView control to represent the program structure) and Forms/3 (using the Time Dimension). It introduces new features like the Graphical Code Replacement (GCR) method (instead of drag-and-drop) and playing programs as a movie using the Time Dimension. The proposed visual programming language (PWCT2) builds on PWCT by incorporating the GCR method, Steps Tree, Time Dimension, and playing programs as a movie. It also draws inspiration from Scratch, incorporating rich colors and block-level drag-and-drop support. Additionally, PWCT2 is influenced by the Envision visual programming system, enabling rich comments and supporting interactive visualization.

The proposed VPL is implemented using the Ring language, supports Ring code generation, and enables importing Ring code, making it a self-hosting VPL. These capabilities are particularly important in the age of large language models (LLMs) and code generation, as they enable the use of LLMs to generate Ring code that can be used in PWCT2 and updated using visual programming. Since Forms/3, Lava, and Envision are no longer under active development, and while Scratch is actively developed, it is domain-specific, and PWCT, though general-purpose, is designed for MS-Windows, we expect that the proposed VPL, with its support for multiple platforms and modern features, could be a valuable addition to the landscape of VPLs. It could be especially useful for Ring programmers or novice programmers who want to learn about the Ring language through visual programming, as this proposed VPL is the first to support the Ring programming language.

While visual tools such as Blockly 2022 and Node-RED 4.0.2 are very popular and serve as the foundation for many visual programming languages, we believe that the PWCT2 approach and its interactive textual-to-visual code conversion offer notable flexibility. This could attract more users with coding backgrounds to try the PWCT2 visual programming approach. Additionally, such features could influence future updates to Blockly and Node-RED if more users find them useful and necessary [12,13,59,60].

No-code platforms provide highly intuitive drag-and-drop interfaces and prioritize rapid development, allowing non-technical users to quickly build entire applications without any coding knowledge. These tools simplify the development process for specific application types, making them accessible to a wider audience. While visual programming languages (VPLs) provide a visual approach to traditional programming [61,62].

Both PWCT2 and no-code development tools aim to simplify the creation and development of software and applications, but they serve different needs. For example, PWCT2 focuses on making traditional coding more accessible by providing flexibility and customization for a wide range of applications. Through further development, the PWCT2 visual programming language can act as an intermediate-level abstraction layer between traditional coding and no-code. General-purpose visual programming languages like PWCT2 can be used as the foundation for building no-code platforms, enabling higher levels of abstraction and ease of use while maintaining full control through visual programming.

3. Materials and Methods

In this section, we describe our system design and implementation. We highlight the important features of the proposed visual programming language, PWCT2, and present the system architecture, which is implemented using the Ring programming language version 1.22.

3.1. Implementation Using the Ring Language

The architecture of the proposed visual programming language (shown in Figure 4) is divided into three main layers: Use Cases, PWCT Environment, and Ring Language. Each layer contains specific components that contribute to the overall functionality of the system. The bottommost layer, Ring Language, includes Development Tools, Libraries, Compiler, and Virtual Machine (VM). Development Tools provide various tools that assist in the development process, such as the package manager and Ring2EXE. Libraries consist of pre-written code libraries that developers can use to add functionality to their programs, saving time and effort by providing reusable code for common tasks. The compiler processes Ring textual source code and generates bytecode for the Ring Virtual Machine if the program is correct. If there are issues, it produces compile-time errors. The Virtual Machine (VM) provides a runtime environment for the programs written in Ring, executing the compiled code and managing the program’s execution [23,30].

The middle layer, PWCT Environment, consists of Visual Programming, the Ring to PWCT converter, and the File System (Visual Source). Visual Programming allows developers to create programs using visual elements rather than traditional text-based code, providing a more user-friendly development experience. This is achieved through tools such as the Steps Tree editor, time machine, components browser, interaction pages (data-entry forms), and form designer. The Ring to PWCT converter assists in importing the textual source code written in Ring and visualizing the structure and flow of the program by offering graphical representations of the program’s logic. This enables us to continue program development using visual programming instead of relying on the textual source code. The File System (Visual Source) manages the visual source files within the PWCT environment, organizing and storing information about the visual elements used in the development process. PWCT can generate Ring source code from these visual source files, enabling the execution of these programs using the Ring compiler and virtual machine.

The topmost layer, Use Cases, includes the various applications and 2D games that can be developed using PWCT based on the Ring programming language, ranging from simple utilities to complex software solutions. Overall, the architecture of the proposed system is designed to provide a comprehensive and user-friendly environment for visual programming based on the Ring programming language, making it accessible to both novice and experienced Ring developers.

3.2. Flexible Visual Environment

In this section, we introduce the design differences between PWCT1 (the first generation of Programming Without Coding Technology) and PWCT2 (the proposed new generation). In the first generation of PWCT, visual programming is achieved through four sub-systems: Goal Designer, Components Browser, Interaction Pages, and Form Designer. The Goal Designer is used for designing modules and provides the Steps Tree Editor and the Time Machine. The Components Browser enables users to select specific components, each offering one or more interaction pages (data-entry forms). Entering data into these interaction pages generates or updates steps managed by the Goal Designer [16,17].

3.2.1. Single Main Window and Several Dockable Windows

In PWCT1 [17], the visual programming sub-systems are not designed to be used simultaneously on one screen; each sub-system uses a separate window. For instance, the Goal Designer and Components Browser, or the Components Browser and Interaction Pages, cannot be viewed at the same time. In the proposed visual programming language PWCT2, this design has been revised to use a single main window for all sub-systems, as shown in Figure 5. Each sub-system now occupies a separate dockable window [63,64], allowing users to view all sub-systems simultaneously, which avoids the complete redrawing of the screen when switching from one to another. We also added two dockable windows: one for Project Files, where users can quickly navigate to specific folders and open visual source files, and another for the Output window, where users can see the program output, send input to the running program, or terminate it at any time.

The previous generation of PWCT did not provide these features (project files/output window) and relied on operating system dialog boxes to open files and the command prompt window to display program outputs [21]. Another feature added by PWCT2, which does not exist in PWCT1, is the ability to open multiple interaction pages simultaneously. This simplifies the process of reading and updating programs. The Steps Tree Editor provides a feature to open all of the interaction pages at once through a keyboard shortcut.

The program illustrated in Figure 5 is a simple example that prints two lines of text: “Hello, World!” and “Welcome to PWCT2”. The proposed visual programming language makes it straightforward to create and modify the program visually. Users can add, remove, or change steps by interacting with the Steps Tree and the Print Component. For instance, to change the text being printed, users can simply edit the text in the Print Component interaction page and click “Ok”. Additionally, new steps can be added by selecting the desired components from the Components Browser.

The Components Browser (left panel) lists various visual components that can be used in the program. These components belong to the RingPWCT visual programming language. Categories include Comments, Templates, Console, Control Structures, and more. Each category contains specific components, such as “Print Text”, “Get Input”, “The If Statement”, and “For Loop”. We can find and select a component using the mouse or through a search process by the component name or part of the name.

The Steps Tree (middle panel) displays the structure of the program in a hierarchical tree format. The program starts with a “Start Point” and includes steps generated by the Basic Program component, such as “The First Step”, “Load Files”, “Statements”, “Functions”, and “Classes”. Using the Basic Program component is optional, and these generated steps are just comments for organization. Additionally, there are steps generated by the Print Text component, like “Print Hello, World! (New Line)” and “Print Welcome to PWCT2 (New Line)”. In general, each step represents a specific action or command in the program, or it could be just a comment to provide a better understanding of what the program does or its structure.

3.2.2. Flexible Steps Tree Editor

The Steps Tree editor in PWCT2 is designed for flexibility and provides many features that do not exist in PWCT1, including drag-and-drop functionality to move steps from one location to another instead of using cut and paste. This enhanced flexibility significantly improves the user experience by simplifying the process of organizing and modifying steps. In PWCT1, when we add a step as a child to another step, the parent step must be of a type that allows children, and the added step will be at the end of the children. This is a limitation if we want to insert a new step between two other children, requiring the steps to be added first and then moved to the desired location.

In PWCT2, the insertion process is supported, where selecting a step that does not support children and then adding a new step inserts it after the selected step. This change enhances the capability to modify the program’s structure on the fly, making development more intuitive.

The Steps Tree editor provides common features expected from editors, such as Find and Replace, Go-To, and Print to PDF, ensuring that users have access to essential editing tools. In Figure 6, we demonstrate how to insert steps between other steps by inserting the “Print TWO (New Line)” step between the steps that print the “ONE” and “THREE” messages on the screen. In the second section of the figure, we show how to use the Find and Replace window to find steps that contain specific text. These improvements collectively contribute to a more user-friendly development environment.

3.2.3. RingPWCT Components in the Components Browser

In PWCT1 [17], the environment includes multiple visual programming languages, such as HarbourPWCT, CPWCT, PythonPWCT, and SupernovaPWCT. Each visual language comes with a group of components classified into different domains, generating textual source code in specific textual programming languages like Harbour, C, Python, and Supernova. In our research prototype of PWCT2, we focus on supporting the Ring programming language through the RingPWCT visual programming language, which provides visual components that generate textual source code in the Ring programming language.

Table 3. The RingPWCT visual programming language components.

ID	Domain	Components Count	Example
1	General	6	Quick Start
2	Console	4	Print Text
3	Control Structures	13	For-In Loop
4	Variables and Operators	17	Assignment
5	Functions	3	Define Function
6	Program Structure	2	Load Source File
7	Lists	15	New Empty List
8	Strings	16	Get String Length
9	Date and Time	7	Add Days
10	Check Data Type	3	Check Character
11	Math	1	Math Functions
12	Files	29	Read File to String
13	System	12	Get System Variable
14	Dynamic Code	3	Eval
15	Database	34	ODBC Connect
16	Security and Internet Functions	11	Download
17	Object-Oriented Programming	10	Define Class
18	Functional Programming	3	Anonymous Function
19	Reflection	29	Globals Info
20	Standard Library	71	Stack Class
21	Web Library	12	WL WebPage Class
22	LibCurl Library	5	LibCurl Easy Init
23	GUI	88	Window Class

provides an overview of the 394 visual components available in the RingPWCT visual programming language within PWCT2.

The table categorizes the components into different domains, specifying the number of components in each domain and providing an example for each domain. For instance, the General domain includes six components, with “Quick Start” as an example, while the Console domain comprises four components, with “Print Text” being one of them. Other notable domains include Control Structures, with 13 components like “For-In Loop”, and GUI, which has the highest count of 88 components, exemplified by the “Window Class”. The table also highlights various other domains such as Functions, Program Structure, Lists, Strings, Date and Time, and Math, among others. Each domain contains a specific number of components tailored to different programming tasks. For example, the Date and Time domain includes seven components like “Add Days”, while the Database domain, one of the most extensive, contains 34 components such as “ODBC Connect”. This comprehensive categorization helps users navigate and utilize the diverse set of tools available in RingPWCT to enhance their programming experience within PWCT2.

3.2.4. Advanced Visual Components and Templates

In PWCT1 [21], visual components are based on a specific scripting language designed for the PWCT environment. This scripting language is intended to be easy to use and increase productivity by providing specific commands that guide the steps generation process based on data entered in the interaction pages. However, this scripting language is very limited and provides simple concepts related to variables, if-statements, steps/code generation, and rules for relationships between components. It does not have loops, functions, or the ability to be extended without modifying its interpreter [65].

These limitations prevent the development of rich and powerful components that could perform advanced tasks during steps generation. Components are designed under the assumption that the component generating the steps will also be responsible for updating these steps. In other words, a component cannot generate steps that belong to other components. For example, to create a template of steps that belong to different components, a specific visual source file with these generated steps must be created. The user can then start a new visual source file from these templates. This means that these templates must be used at the start of creating new visual source files, and multiple templates cannot be used in the same visual source file without creating a new template that integrates them.

PWCT1 uses two different programming languages: Visual FoxPro for developing the PWCT environment and a scripting language called RPWI designed for developing visual components. In the proposed visual programming language (PWCT2), the Ring textual programming language is used for developing both the PWCT2 environment and the visual components. Using Ring for developing the environment components enables us to create advanced components and avoids the known limitations of RPWI. For example, we have the Quick Start component, which can be used to generate steps that belong to multiple components, as shown in Figure 7.

The Quick Start component contains many templates that we can use. One of these templates is the Modify Lists Using Loop template. Selecting this template generates multiple steps that belong to different visual components, such as the For In component, Switch component, Case component, etc. The Quick Start component can also generate comments and provides a No Comments checkbox to avoid generating comments if desired.

3.3. Time Dimension and Auto-Run

In PWCT1, users can use the Time Machine to change the time position and go backward in time to see the program at a specific point in the past and check the order of steps added to the program. We also have the option to play the program as a movie and see how the visual components are used step by step to create the program. Additionally, we can run the program at a specific point in the past and see the program output at that point. In PWCT2, we support the Auto-Run feature as shown in Figure 8, where changing the time position or adding new steps to the program will directly execute the program and display the output in the output window.

The program contains a for-loop and a conditional statement. The first position in the figure shows the initial state with a For loop running from x = 1 to 10 with a step of 1 and an If statement checking if x equals 3. The second position captures the execution of the If statement when x equals 3, printing “Three” on a new line. The third position demonstrates the continuation of the loop, printing the value of x on a new line for each iteration. The output on the right side of the third screenshot lists the numbers 1 to 10, with “Three” replacing the number 3, highlighting the effect of the conditional statement.

3.4. Rich Colors and Customization

Unlike PWCT1, which provides one style for the environment (White Style), PWCT2 enables us to select the PWCT environment style (White, Dark, Blue, etc.). Like in PWCT1, we have a Customization window to determine the colors used in the Steps Tree editor based on the step type (see

Table 4. Different types of Steps inside the Steps Tree.

ID	Step Type	Description
1	Start Point	The program root (one for each visual source file)
2	Comment	Just a comment and does nothing during runtime
3	First	The first step generated by the component
4	Allows Interaction	The step could include sub steps
5	Leaf	The step cannot include sub steps

). Each visual component can generate one or more steps in the Steps Tree after entering the required data on the interaction page. These generated steps might belong to the same component or be related to other components if the original component is a template. We can use the same component again by clicking the ‘Again’ button on the interaction page.

PWCT2 can use multiple colors in each step to highlight the data entered by the user from the text generated by the visual component, whereas PWCT1 uses one text color and one background color per step. This improvement is inspired by Scratch [66]. Additionally, we can show or hide the dockable windows as needed. As shown in Figure 9, we focus on the Steps Tree editor and interaction pages after setting the style to Dark and customizing the Steps Tree colors using the Customization window.

Additionally, the Customization window enables us to set the Steps Tree background color and adjust the indentation level in the Steps Tree. In the Options tab, we also have advanced options that can enable the Auto-Run feature and control the environment’s behavior in different situations, such as opening the interaction pages in the Steps Tree dockable window or in separate windows.

In PWCT1 [21], users can open only one visual source file at a time for each instance of PWCT1. Opening multiple visual source files simultaneously requires running multiple instances of PWCT1. In PWCT2, we have the Project Files dockable window, as shown in Figure 10, where we can easily select and open any visual source file or form file. Additionally, using the options in the Customization window, we can choose to open files in new tabs, allowing us to work with and view multiple files simultaneously. This improvement is inspired by popular editors and IDEs like Visual Studio and NetBeans [67,68].

The Customization window is open in the center, displaying two tabs: “Colors” and “Options”. The “Options” tab is selected, showing a list of customization options with checkboxes. The options listed in the Customization Window include Auto Run, Open files in new tabs, Show the Time Machine options, Steps Tree—Hide Step Code Tab, Show Steps Tree Lines, Light Tree Lines, Steps Tree—Show Nodes Icon, Open interaction pages in new windows, Allow Syntax Errors in Interaction Pages, Avoid Components Browser, Avoid Components Browser Auto-Complete, Components Browser—Always Show Search Window, Reflect changes in font size to other windows, and Borders around steps (in supported styles).

For projects with many files, we have the option of a Main File (available in the toolbar), which we can run at any time to start the project, even if we are focusing on another sub-file within the project. Switching between files is easy using tabs that include the file name and are located at the bottom of the window. We can also view two files side by side in the PWCT2 environment by moving the dockable window of the file.

On the left side, there is a “Project Files” dockable window displaying a list of files and folders related to a project named “GoldMagic800”, which is a puzzle game that contains 44 levels [69]. The highlighted file is “gamebase.pwct”. In the center, there is a “Steps Tree” dockable window showing a hierarchical list of methods under the “Class GameBase”. On the right side, there are interaction pages for defining function components, if-statement components, assignment components, and class components. The user can determine which interaction pages to open simultaneously and use them to generate new steps and create programs without having to switch back to the components browser.

3.5. Rich Comments Using Text, Lines, Images, and HTML

PWCT1 [21] enables adding comments to our Steps Tree, referred to as “user steps”, which use text to describe something or add information about the program. In PWCT2, we use different types of comments, not just text. We can add lines, images, and headers with specific fonts and colors. In Figure 11, we have a program that uses a Raspberry Pi Pico to control an LED, making it blink, with the ability to interact using a switch [70]. Using rich comments, we added a header that represents the sample title, followed by a horizontal line, and then an image of the circuit. Comments could include HTML, as demonstrated in Figure 12. This feature could be used for adding tables from both local and online web pages to our program. This improvement is inspired by the Envision visual programming system [27].

3.6. Enhanced Form Designer for GUI Apps

The Form Designer is a tool that simplifies the process of creating user interfaces by allowing users to easily add UI controls to the form, adjust properties, and define events such as click actions for buttons. In PWCT1, the Form Designer, used for GUI applications, differs from popular form designers like those in Visual Studio. Instead of using a Toolbox and Properties window, the PWCT1 Form Designer utilizes the Components Browser and Interaction Pages, making it tightly integrated with the Goal Designer and not suitable for use as an external tool [71].

In PWCT2, we revised this design and provided a reusable Form Designer, which is successfully used in both PWCT2 and Ring Notepad (the IDE provided by the Ring programming language). In PWCT2, the Form Designer uses the Model-View-Controller (MVC) design pattern [72,73,74].

The Form Designer, as shown in Figure 13, allows users to visually design the user interface of their application. It includes the Toolbox, Form Layout, and Properties Panel. The Toolbox contains various UI elements, like labels, buttons, text edits, checkboxes, etc., that can be added to the form. The Form Layout is the main area where UI elements are placed. For example, in the figure, we notice it includes UI controls such as Title, Author, Abstract, and Output. This layout is related to an application that predicts the citation count of research papers in the field of Otology. The Properties Panel shows the properties of the selected object (e.g., a button named btnSelect). Properties include Name, Position (X and Y), Size (Width and Height), Text Color, Background Color, Font, Text, Image, and Click Event.

The Steps Tree (left panel) displays a hierarchical view of the steps involved in the Controller visual source file, including importing the System.GUI package, checking if the file is the main source file, creating and accessing objects, defining the class, and more. The New Object Component (top middle panel) allows users to create a new object from a specific class. The Access Object Component (middle panel) is used to access an existing object within the program and allows us to use the object’s attributes and methods. The Call Method Component (bottom middle panel) is used to call a specific method supported by a specific object.

3.7. Interactive Textual-to-Visual Code Conversion

PWCT2 comes with a feature called interactive Textual-to-Visual code conversion, as demonstrated in Figure 14. The first section of the image illustrates the user writing Ring code, showcasing the textual input of programming constructs. In this section, the code creates an object from the point class, sets the object’s attributes, and defines the point class using the Ring programming language. In the second section, this Ring code is automatically converted into a visual representation using Ring2PWCT. The visual interface displays the code elements as graphical components, arranged in a logical flow that mirrors the structure of the original Ring code. This conversion allows users to interact with and manipulate the program visually, making it easier to understand, modify, and debug without delving into textual syntax. The transition from text to visual representation bridges the gap between textual programming and visual programming, enhancing the user’s experience and productivity.

To start using this feature, it is sufficient for the keyboard Focus to be active at the Steps Tree at any step. Once the user starts typing, the components browser will be activated, where PWCT2 expects that the user is searching for a visual component to use. If the visual component does not exist, PWCT2 expects that the user will type Ring source code and highlight this code. If the user presses ENTER, PWCT2 will then use Ring2PWCT to generate the visual representation. The generated steps will be inserted into the selected location in the Steps Tree, enabling us to use this feature at any location in our program.

This feature can be used to mix textual programming (for writability) and visual programming (for readability) in the same project [75,76]. Additionally, the code could be generated using large language models (LLMs) such as Copilot [77] as demonstrated in

Table 5. Using Copilot and PWCT2.

Step	Description	Image
1	Use Copilot AI to generate textual source code in the Ring programming language, then copy the generated code to the operating system clipboard. The task is to write a method in Ring code to be added to a class called Point, which has three attributes: x, y, and z. The method should ask the user for the values of these attributes using the getNumber() function and print a message asking the user to enter the value before using getNumber(). The provided solution includes a method named ask_values that prompts the user to enter values for x, y, and z. This method assigns these values to the respective attributes after using the getNumber() function to obtain input from the user.
2	In this step, we switch to PWCT2, select the parent step in the Steps Tree Editor, and finally paste the generated source code. The parent step is called “Methods”, which exists in the Point class. Once we paste the textual source code, PWCT will display the pasted code in a popup rectangle to indicate that this is a textual-to-visual code conversion operation (not a search operation by the visual component name). Pressing ENTER will start the conversion process.
3	After the textual-to-visual code conversion process using Ring2PWCT, we will see the generated steps in the Steps Tree. We can continue development using the visual programming features provided by PWCT2, such as the Steps Tree Editor and Time Machine.

. Furthermore, this feature enables us to import current projects written in Ring so that we can continue developing them using PWCT2.

The implementation of Ring2PWCT involves some of the same phases as compiling, such as scanning and parsing [78,79]. Instead of low-level code generation, we generate a visual source file. Alternatively, it can update the current file if Ring2PWCT is used to insert steps into the existing visual source file instead of creating a new one. Ring2PWCT is generally considered a form of translation, specifically source-to-source translation, because it converts source code from one high-level language to another (in this case, from Ring code to PWCT visual code) [80]. Ring2PWCT is designed to pass errors when possible. For example, using the Ring code (for x = 1 to 10 if x = 3 ? “Three”) as input can be converted to visual code (similar to the first section in Figure 8), even if keywords such as EndFor and EndIf are missing.

3.8. Self-Hosting the PWCT2 Environment

PWCT1 is developed using Visual FoxPro, where enhancing the development environment requires using VFP textual code. Although the environment includes a domain-specific language (RPWI) for visual component development, it remains textual code, and using visual programming to improve PWCT1 itself is not supported. Therefore, self-hosting PWCT2 could be an attractive feature because it allows the development and customization of the PWCT2 environment using its own visual programming tools. This approach enables us to improve and refine PWCT2 through visual programming instead of traditional textual coding, making the process more user-friendly and accessible, as shown in

Table 6. Using Ring2PWCT to convert the PrintComponentView class.

Attribute	Value
Class Name	PrintComponentView
Parent Class	ComponentViewParent
Textual Source (Ring)
Visual Source (PWCT2)

, which demonstrates converting a class from textual code to visual code.

While PWCT2 is designed to support interactive textual-to-visual code conversion, this feature is intended to be used within the PWCT environment inside the Steps Tree Editor. Based on this feature, we developed a command-line tool that can take a Ring source file as input and produce a visual source file as output. Since PWCT2 and its visual components are written in Ring, we used this tool (Ring2PWCT) to convert the PWCT2 source code files from Ring to visual source files, allowing us to use PWCT2 to continue developing itself. In Table 6, we present an example of using Ring2PWCT to convert one of the source code files related to the PWCT2 implementation using the Ring language. This file contains the View class for the (Print Text) visual component. This class inherits from the ComponentViewParent class, which contains common attributes and methods useful for developing new visual components inside PWCT2.

3.9. Cross-Platform and Faster Implementation

PWCT1 was developed as a Microsoft Windows product, with no native support for other operating systems like Linux and macOS. Additionally, PWCT1 is 32-bit software. Since PWCT2 is developed using the Ring programming language, which is a lightweight, versatile, and cross-platform language, it was possible to create a cross-platform and 64-bit version of PWCT2 based on Ring and the Qt framework, supported by the RingQt extension. In

Table 7. PWCT2 modules.

ID	Module	Files	LOC	Comment
1	Environment	5	2649	300
2	General Functions	9	524	122
3	Translation	3	584	20
4	Goal Designer	27	4908	1473
5	Components Browser	5	8876	70
6	VPL Components	1185	57,612	7167
7	Component Parent Classes	3	739	283
8	Form Designer	52	9487	312
9	File System (Visual Source Files)	6	368	415
10	Tools	59	6484	546

, we present the modules, along with the count of files and lines of code. Figure 15 demonstrates using PWCT2 on macOS to develop the Tetris game using the Ring game engine for 2D games, which is based on the Allegro game programming library [81,82]. The game engine provides classes that can be used to quickly prototype simple 2D games. These classes include Game, Text, Sprite, Animate, Map, etc.

The PWCT2 project is one of the early advanced projects developed using Ring (see Figure 16). The Environment module provides the main window and creates the different dockable widgets. The General Functions module encompasses general functions required by the software. The Translation module handles various translation functions. The Goal Designer modules contain the Steps Tree Editor and the Time Machine. The Components Browser allows users to navigate through available components and select a component to use.

The VPL Components module, being the largest, includes all the RingPWCT visual programming language components necessary for creating and managing programs. The Component module provides the foundational elements required for the different visual components, including interaction pages and generating visual steps. The Form Designer module provides functionality for designing forms within the environment. The File System module manages the visual source files. Finally, the Tools module contains various utilities, including the textual-to-visual code converter (Ring2PWCT).

During the development of PWCT2, we made specific design decisions that resulted in improved performance compared to PWCT1. These design decisions helped enhance various aspects of PWCT2, with notable improvements in code generation time and storage requirements for the visual source files.

These design decisions are as follows:

• The Steps Tree is stored in the visual source files in the correct order of control flow, with PWCT2 adding steps at the end of the file or inserting them based on their actual position. In contrast, PWCT1 always adds new steps at the end of the file, requiring the Steps Tree to be ordered during the code generation process.
• Storing the visual source in memory through Ring Lists during development and saving to storage only when needed, instead of using database files and storage on the hard disk during development as in PWCT1. It is known that accessing computer memory is faster than accessing the hard disk drive.
• Using the Ring programming language instead of Visual FoxPro. Since Ring development is active, the latest versions of the Ring Compiler/VM are produced using the latest versions of C/C++ compilers, which also benefit from the performance improvements in these tools.
• Using the Qt framework for the GUI environment through RingQt. The framework is written in C++ and provides better performance with each update and direct support for the TreeView control instead of using ActiveX control as in PWCT1.

4. Results

The development of the software started in October 2016, the same year the Ring programming language was released. The development continued slowly, with more time invested in improving the Ring language itself, enhancing its stability, performance, and libraries. PWCT2 was released on the Steam platform in March 2023, based on Ring 1.17, and has received continuous updates based on community feedback [83]. We also keep updating the Ring version included in the software after each Ring release. The current version of the software is PWCT 2.0 Rev. 2025.01.20, which is based on Ring 1.22. In this section, we present the various results related to our study. First, we explore a variety of use cases. Subsequently, we examine our observations regarding the implementation of PWCT2 using the Ring language. Furthermore, we discuss the performance metrics of PWCT2. Finally, we provide details about download numbers, usage time, and user feedback.

4.1. Use Cases

The primary use case for the PWCT2 software is as an alternative to the Ring Code Editor, allowing users to create new projects based on Ring or to import and update/execute Ring programs instead of using Ring Notepad. Ring2PWCT plays a significant role in this process, while the Time Machine feature enables users to read the program step by step and run it from a previous point in time. This functionality facilitates the continued development and maintenance of numerous Ring samples and applications.

In Figure 17, we introduce the SuperMan game, which is distributed with the Ring language. Using PWCT2, it was possible to import the game implementation and check it step by step. The game is based on the Ring game engine, which is designed for developing simple 2D games. PWCT2 comes with many samples related to game programming libraries like Allegro, RayLib, and Tilengine. These samples are converted from the Ring programming language project to PWCT2 through the Ring2PWCT tool, which converts Ring textual code to a PWCT2 visual source file.

Since PWCT2 comes with a Form Designer and the required visual components to build GUI applications, it was possible to use it in developing multiple GUI applications, including an application to predict citation counts in the Otology field using the research paper title, author, and abstract [84]. In the Citations Prediction application, the user interface is designed using the PWCT2 Form Designer (the same designer provided by the Ring language), and the application logic is designed using PWCT2 before generating Ring code. The application receives input from the user and submits it to the machine learning model through the internet using the LibCurl library. The models are developed using Microsoft Azure Machine Learning. The 394 visual components provided by RingPWCT and introduced in Table 3 offer sufficient features to develop such applications.

In Figure 18, we demonstrate the Azure class used by the Citations Prediction application to connect to the Machine Learning model. This class could submit the research paper title, authors, or abstract as input to the model and receives the predicted citation count as output. Different machine learning models are utilized based on the selected input. The class contains the web service URL and the API key as attributes. Within the same project, in addition to the azure.pwct file, there are other files, such as sysdata.pwct, which includes some research paper samples. There are two form designer files: dataset.rform and predict.rform. The first file provides a table to select a research paper from the available samples. The second form is the main form of our application and allows users to enter the paper information to be used as input for the model and includes a button to open the other form in the dataset.rform file. These forms respond to GUI events that are handled by the files datasetController.pwct and predictController.pwct. When we open a form file using the project files window, PWCT2 will automatically open the corresponding visual source file for the controller class.

Another known application in the Ring language community that is developed using PWCT2 is the Find in Files application, which is distributed with Ring Notepad [23]. The application is shown in Figure 19. The application’s user interface is developed using the form designer and utilizes Qt layouts to automatically resize the controls.

The Find in Files application supports search, replace, and replace all operations on one or more files. During a search operation, the user can enable the (Match Case) checkbox to perform a case-sensitive search. Using the (Browse) button, the user can select a specific folder to be used when searching for files. The application utilizes visual components related to file and text processing, as shown in Figure 20. The (Read File) component receives two parameters: the (File) variable, which contains the file name to read, and the (Output) variable, which contains the file content as a string. The (String to List) component converts a Ring string to a Ring list that can be processed using list functions. Each list item will contain one line of text and can be processed using string processing components. For more efficient and high-performance implementation, it is recommended to avoid converting the string to a list since the string can be processed directly.

4.2. Implementation of PWCT2 with the Ring Language

The implementation of PWCT2 using Ring involves using the language compiler, virtual machine, libraries, and tools. Ring 1.17 was sufficient to release the PWCT2 software on the Steam platform in 2023, but we found the language features and stability more satisfactory starting from Ring 1.19, where Ring 1.18 improved support for references and Ring 1.19 improved performance. Later versions released in 2024, such as Ring 1.20, Ring 1.21, and Ring 1.22, provided additional features, stability, and performance improvements. In

Table 8. PWCT2 project size including dependencies.

Attribute	Value
Source code files	1354
Lines of Code	92 KLOC
Dependencies	27 KLOC
Total Lines of Code	119 KLOC

, we list information about the project size, including dependencies such as the standard library and the GUI library from Ring 1.22.

In

Table 9. Using Ring to build the PWCT2 project.

Attribute	Ring 1.17 (2022)	Ring 1.19 (2023)	Ring 1.22 (2024)
Compile-time (ms)	1480	1152	871
Byte-code Instructions	900,113	899,984	724,382
Ring Object File Size (KB)	22,184	22,825	18,952
Object File Compressed (KB)	2463	2483	2322

, we present the compile-time using different versions of the Ring language, the size of the generated Ring VM byte-code instructions, and the size of the generated Ring object file (default size and compressed size). The tests are done using a Victus Laptop [13th Gen Intel(R) Core(TM) i7-13700H, Windows 11].

The data show a substantial reduction in compile-time from 1480 milliseconds in Ring 1.17 to 871 milliseconds in Ring 1.22 (see Figure 21), highlighting significant enhancements in the compilation process.

There is a notable decrease in the number of byte-code instructions from 900,113 in Ring 1.17 to 724,382 in Ring 1.22 (see Figure 22), indicating more efficient bytecode generation. We can compile the PWCT2 project to a Ring object file, which can be run directly using the Ring Virtual Machine without the need to compile the project again using the Ring compiler. The size of the Ring object file initially increased slightly but then decreased significantly (see Figure 23) to 18,952 KB in Ring 1.22, reflecting optimization improvements.

The compressed object file size remained relatively stable. Compressing the object file and reducing the required storage could be useful when distributing the project over the internet. However, the real size of the object file (without compression) matters because the Ring Virtual Machine processes and loads this file into memory when running the project. These results collectively illustrate the progress achieved with the subsequent versions of the Ring language.

4.3. PWCT2 Performance

Table 10. Measuring performance of PWCT2.

ID	File	Storage (KB)	Components	Steps	LOC	LT (ms)	CGT (ms)
1	StopWatch	41	40	74	54	73	3
2	Snake	138	149	234	185	199	9
3	Matching	218	215	330	275	287	13
4	Sokoban	217	235	330	269	269	13
5	Escape	250	277	401	329	330	14
6	Tessera	268	269	418	337	370	17
7	FlappyBird3000	260	263	429	341	358	17
8	Pairs	283	287	432	362	374	17
9	Cards	298	305	457	399	363	15
10	SquaresPuzzle	299	327	513	378	429	20
11	StarsFighter	321	329	530	423	449	21
12	KnightTour	347	386	549	465	448	21
13	Tetris	351	402	586	483	459	20
14	Game2048	371	356	588	461	499	22
15	Othello	427	422	653	536	562	25
16	DiscreteFourierTransform	787	538	677	603	784	22
17	MagicBalls	438	510	700	602	567	24
18	Minesweeper	449	509	701	611	559	24
19	SuperMan	465	480	757	607	622	30
20	Laser	707	825	1139	955	918	39
21	GameOfLife	773	870	1253	1066	1068	43
22	Checkers	845	968	1307	1128	1077	43
23	GoGame	946	1089	1453	1271	1166	47
24	GetQuotesHistory	1021	1269	1555	1407	1228	51
25	Chess	1012	1166	1560	1340	1270	52

presents performance results related to the PWCT2 environment, showcasing various visual source files and their corresponding metrics. These files represent games and utilities such as StopWatch, Snake, Matching, Sokoban, Escape, Tessera, FlappyBird3000, and others. Each sample is evaluated based on several criteria: file storage in kilobytes (KB), the number of visual components, steps involved, generated lines of code (LOC), loading time (LT) in milliseconds required to display the visual representation, and code generation time (CGT) in milliseconds. The data demonstrate a range of sample complexities, with file storage sizes varying from 41 KB to over 1000 KB, and visual components ranging from 40 to 1269. The number of steps and lines of code also vary significantly, highlighting the diverse nature of these visual source files. Loading and code generation times provide insights into the performance efficiency of PWCT2 across different applications. The measurements are done using a Victus Laptop [13th Gen Intel(R) Core(TM) i7-13700H, Windows 11, PWCT 2.0].

In Figure 24, we present the relationship between the number of steps and the required storage. The figure is a stacked bar chart comparing the storage (in KB) and steps for various applications or games developed using PWCT2. The x-axis lists the names of the applications/games, while the y-axis represents the values for storage and steps. The blue segments of the bars represent storage, and the orange segments represent the number of steps in the visual source file.

In Figure 25, we present the relationship between the number of visual components and the generated source code, showing that using visual components increases the abstraction level. In Figure 26, we demonstrate the relationship between both the loading time/code generation time and the step count in the visual source file.

We notice from Figure 26 that the loading time increases significantly as the file size and complexity grow, with a noticeable spike around the 600 ms mark, indicating that more complex files require more time to load. The orange line represents the code generation time, which remains relatively low throughout the different samples, with only minor fluctuations. The code generation time is more critical for developers because they may need to run the program multiple times during development and updating the visual code, making it essential to keep this time low for a smoother and more efficient development cycle. On the other hand, the loading time, while important, is typically incurred only once per file. By maintaining consistently low code generation time, PWCT2 enhances the development experience, making it more efficient and less time-consuming for developers.

Table 11. A table of some visual source files containing steps equal to or greater than 1000 steps.

Generation	VPL	File	Storage (KB)	Steps	LT (ms)	CGT (ms)
PWCT2	RingPWCT	GameOfLife	773	1253	1068	43
PWCT2	RingPWCT	Checkers	845	1307	1077	43
PWCT2	RingPWCT	GoGame	946	1453	1166	47
PWCT2	RingPWCT	Chess	1012	1560	1270	52
PWCT1	CPWCT	Vmfuncs	7966	1000	549	1748
PWCT1	CPWCT	Refmeta_ext	8243	1075	593	1993
PWCT1	CPWCT	File_ext	9799	1235	747	2651
PWCT1	CPWCT	Vm_oop	11397	1497	862	3862

demonstrates the performance and storage requirements of PWCT2 and PWCT1 [23] when using visual source files that contain at least 1000 steps by evaluating various metrics: file storage in kilobytes (KB), the number of steps, loading time (LT) in milliseconds (ms), and code generation time (CGT) in milliseconds (ms). These visual source files pertain to different visual programming languages (CPWCT vs. RingPWCT) and various programs. However, the step counts fall within the same range, representing the size of the visual programs, which influences the code generation performance and storage requirements. PWCT2 shows significant improvements in file storage efficiency and code generation time, with much smaller file sizes (773 KB to 1012 KB) and faster code generation (43 ms to 52 ms) compared to PWCT1, which has larger file sizes (7966 KB to 11,397 KB) and much longer code generation times (1748 ms to 3862 ms). Although PWCT2 has higher loading times for the visual source files (1068 ms to 1270 ms) than PWCT1 (549 ms to 860 ms), this difference is not substantial and is due to new optional features in PWCT2, such as rich colors where the same steps can use more than one color. The faster code generation time in PWCT2 is crucial for developers who need to run the program multiple times during development, making it more efficient and less time-consuming.

In

Table 12. Statistical Analysis of RingPWCT and CPWCT samples.

Attribute	PWCT1	PWCT2
Visual Programming Language	CPWCT	RingPWCT
Visual Source Files Count (Sample Size)	43	25
Pearson Correlation (Storage vs. Steps)	0.8693	0.9662
Pearson Correlation (CGT vs. Steps)	0.9105	0.9947
Spearman Correlation (Storage vs. Steps)	0.8198	0.9867
Spearman Correlation (CGT vs. Steps)	0.9914	0.9855
Average Storage per Step (KB/step)	13.6751	0.6543
Average CGT per Step (ms/step)	1.2956	0.0353
RMSE for Storage	23.4063	0.1082
RMSE for CGT	1.0539	0.0032

, we present a summary of the key statistical metrics derived from analyzing the relationship between the number of steps, storage requirements, and code generation time (CGT). The analysis for PWCT2 is done for 25 visual source files presented in Table 11 which used RingPWCT. The analysis for PWCT1 is done for 43 visual source files related to CPWCT and introduced in the literature with storage size and code generation time [23].

We used the same hardware for all experiments. Also, to ensure the reliability and validity of our findings, we calculated the p-values for both Pearson and Spearman correlation coefficients across storage vs. steps and code generation time vs. steps. This statistical analysis allowed us to determine the significance of the observed relationships. By verifying that the p-values were well below the accepted threshold of 0.05.

For PWCT2, our analysis revealed a very strong positive correlation between the number of steps and both storage and code generation time. This indicates that as the number of steps increases, both storage and CGT also increase in a nearly linear fashion. The average storage required per step was found to be 0.6543 KB, while the average CGT per step was 0.0353 milliseconds. Furthermore, the Root Mean Square Error (RMSE) values for storage per step (0.1082) and CGT per step (0.0032) were low, suggesting that the average values are reliable and well represented by the data. These findings demonstrate the efficiency and scalability of code generation in PWCT2, particularly in handling visual source files with a high number of steps.

For PWCT1, the average storage required per step was found to be 13.6751 KB, while the average CGT per step was 1.2956 milliseconds. Furthermore, the Root Mean Square Error (RMSE) values for storage per step (23.4063) and CGT per step (1.0539) were calculated, indicating some variability around the averages. Despite this variability, the correlations remain strong and statistically significant, underscoring the reliability of the data and the performance characteristics of PWCT1. These findings highlight the substantial resource demands of code generation in PWCT1, particularly as the number of steps increases.

The statistically significant data and strong performance metrics allow us to generalize the findings when discussing the performance improvements of PWCT2 over PWCT1. On average, PWCT2 is approximately 36.7 times faster in code generation time (CGT) per step and uses approximately 20.9 times less storage per step compared to PWCT1. This significant improvement is evidenced by the lower average CGT and storage per step for PWCT2, as well as the low RMSE values, indicating high efficiency and consistency. These results highlight the advancements and effectiveness of PWCT2, making it a more efficient tool for visual programming tasks.

4.4. User Feedback

Once we started distributing the software and describing it as a visual programming tool and a replacement for the Ring Code Editor, users began joining the community group, which now has over 750 members, more than 100 discussion topics, and over 50 announcements about software updates. In early 2023, most discussion topics were questions about using the software, its capabilities, and a few bug reports. We fixed the reported bugs and provided educational videos (see

Table 13. Statistics about educational videos introducing PWCT2.

Attribute	Value
Total Videos Count	39
Average Duration (M:S)	8:47
Total Duration (H:M:S)	5:42:27

) to help users learn about the software and how to use it [85]. Then, we guided them to the PWCT2 samples and Ring language documentation to learn more about the software. Many of the recent topics in 2024 are questions about future directions and requests to support other textual programming languages like Lua, Python, and C#.

Based on statistics from the Steam platform regarding PWCT2 web page visits from March 2023 to December 2024, the platform displayed the project title, logo, and short description over 1.73 million times to users through various lists. The software web page received over 159 K visits (a 9.2% clickthrough rate), including over 72 K visits from the United States, over 33 K visits from the Russian Federation, and over 11 K visits from Saudi Arabia. Over 20,000 users own the software and have added it to their Steam library, enabling them to download and use it at any time. In

Table 14. Usage time as reported by the Steam platform.

Minimum Usage Time	Percentage of Users
30 min	27%
1 h 0 min	19%
2 h 0 min	13%
5 h 0 min	8%
10 h 0 min	5%

, we present the minimum usage time and the percentage of users as reported by the Steam platform. Steam reported that 1772 users have downloaded and launched the software through Steam, with an average usage time of 9 h and 40 min. This means the software has been used for over 17,000 h as shown in

Table 15. Statistics about the PWCT2 software from 1 March 2023 to 21 December 2024.

Attribute	Value
Impressions	1.72 M
Web page visits	159 K
Software owners	20,623
Users launched the software	1772
Average usage time	9 h and 40 min
Total usage time	Over 17,000 h

.

In Figure 27, we present a horizontal bar chart that shows the download statistics of the PWCT2 software across different regions, listing only the top regions, such as North America and Western Europe.

The regions and their corresponding percentages are as follows: North America at 36.20%, Western Europe at 25.70%, Latin America at 6.20%, Central Asia at 6.10%, Asia at 5.90%, and Eastern Europe at 5.20%. The chart highlights the significant differences in the distribution of downloads across these regions, with North America having the highest percentage and Eastern Europe having the lowest. In Figure 28, we present the downloads across the top countries, showing that the United States has the highest number of downloads (31%), followed by Germany (10%) and Canada (5%).

We conducted an analysis for the user reviews for the PWCT2 software on the Steam platform, while noticing important details such as review type, language used to write the review, and usage time in hours. The reviews are written in various languages, indicating a diverse user base. Out of the thirty-one reviews, twenty-eight users recommended the software, while three users did not. The languages used in the reviews include Arabic, Chinese, English, Italian, Polish, Portuguese, Russian, Thai, and Turkish. Usage times vary significantly, from as little as 0.1 h to an extensive 560.1 h. Notably, a user who used the software for 560.1 h recommended it, showing a high level of engagement. Other notable usage times (in their respective review languages) include 93.4 h (Thai), 61.4 h (English), and 56 h (Portuguese), all with positive recommendations.

Figure 29 illustrates the proportion of positive and negative reviews for the PWCT2 software on the Steam platform. The user reviews provide a mix of positive and critical feedback. Users appreciate the software’s educational value, especially for beginners. The visual and organized approach to programming is praised, with some comparisons to Scratch. Users find it helpful for those with little coding knowledge and believe it has great potential for learning programming.

With respect to negative feedback, we noticed that it was based on various reasons, including encountering bugs, requiring more educational resources, and seeking additional features to enhance usability. During 2023 and 2024, we worked on resolving all reported bugs, introduced more educational resources (videos and documentation), and added requested features such as Drag-and-Drop support in the Goal Designer, an expression builder in the interaction pages, as well as preventing composition errors in the Steps Tree. However, we believe there is room for further improvement in the educational resources and the features provided.

The software’s interface is described as smooth, with many features to learn. Some users highlight the convenience of having the entire programming interface visible and the ability to keep necessary interaction pages open. Some users also express satisfaction with features like Ring2PWCT and the Time Machine, which enhance their programming experience. There are positive remarks about the potential for serious projects. Many users express satisfaction with the software’s development and updates. On the other hand, a few users feel the software is not beginner-friendly and recommend it only for those with prior programming knowledge. Continued development and support are encouraged, with some users acknowledging our responsiveness in fixing issues. Overall, the reviews highlight both the strengths and areas for improvement in PWCT2, reflecting diverse user experiences and perspectives.

5. Discussion

The diverse use cases of PWCT2 demonstrate its adaptability and utility in various programming scenarios. The primary use case for PWCT2 is as an alternative to the Ring Code Editor, which allows users to create new projects based on Ring, as well as visualize and execute Ring programs. This flexibility is further enhanced by the Time Machine feature, which enables users to read programs step by step and run them from a previous point in time, facilitating the continued development and maintenance of numerous Ring samples and applications. Additionally, PWCT2 supports the development of GUI applications through its Form Designer, which has been utilized to create applications for predicting citation counts in the Otology field and for finding files distributed with Ring Notepad. These applications showcase PWCT2’s capability to handle different tasks, such as integrating machine learning models developed using Microsoft Azure Machine Learning and providing user-friendly interfaces. Moreover, PWCT2’s ability to convert Ring textual code into visual code and vice versa using the Ring2PWCT tool underscores its potential as a flexible tool in both educational and professional settings. The practical use cases of PWCT2 highlight its contributions to simplifying programming and enhancing the overall development process based on the Ring programming language.

The results presented in Table 8 and Table 9 highlight the excellent compilation performance achieved during the development of PWCT2 using various versions of the Ring language. Furthermore, the number of byte-code instructions decreased in Ring 1.22, indicating more efficient byte-code generation. However, despite these improvements, the size of the generated Ring object file remains relatively large, even though there was a reduction from 22,825 KB in Ring 1.19 to 18,952 KB in Ring 1.22. Addressing the large object file size could reduce the storage and memory requirements of the PWCT2 project. Table 10 and Table 11 present an insightful comparison of PWCT2’s performance and its improvements over PWCT1 [23]. PWCT2 demonstrates significant enhancements in file storage efficiency and code generation time. The results show that PWCT2 has much smaller file sizes, and a notably faster code generation compared to PWCT1, which is crucial during multiple programs runs and updates.

User feedback has played a crucial role in the development and refinement of PWCT2. Since its distribution as a visual programming tool and a replacement for the Ring Code Editor, the community group has grown significantly, now boasting over 750 members. Notably, over 20,000 users have added the software to their Steam libraries, enabling them to download and use it anytime. Steam reported that 1772 users have launched the software, with an average usage time of 9 h and 40 min, cumulatively amounting to over 17,000 h of usage (Table 15). Regional and country-specific download data highlight that North America and the United States lead in downloads (Figure 27 and Figure 28). User reviews on Steam (Figure 29) also present a mix of positive and critical feedback, with notable appreciation for the educational value, smooth interface, and unique features like Ring2PWCT and the Time Machine.

Since PWCT2 currently supports the Ring programming language through RingPWCT visual components, these visual components follow the Ring language approach for representing different data structures, where Ring lists are used instead of arrays, linked lists, trees, hash tables, etc. However, by using classes and operator overloading, we can create custom types. The Ring Standard Library comes with specific classes for lists, trees, hash tables, etc., and the RingPWCT includes visual components that enable the use of these classes. With respect to scalability and creating large projects, the PWCT2 approach is based on organizing large projects into folders, subfolders, and different visual source files, where a visual source file can load other files and use the functionality provided by them, such as functions and classes. However, more improvements are required in this area to provide visualizations that highlight information from different visual source files.

The development and evaluation of PWCT2, the proposed research prototype and successor to PWCT1, bring several noteworthy limitations to light. First and foremost, PWCT2 supports only the Ring programming language, whereas PWCT1 provided visual components for various textual programming languages, including Harbour, C, Supernova, Python, and C# [17]. This limitation restricts the versatility of PWCT2 and may reduce its appeal to users who require support for multiple programming languages. Secondly, PWCT2 is not compatible with PWCT1 in terms of visual component design or visual source file formats. This incompatibility necessitates the development of tools to convert projects from PWCT1 to PWCT2, which could pose challenges for users looking to transition their existing projects. Additionally, PWCT2 is currently distributed as a desktop tool rather than a web-based application. The lack of a web-based version limits accessibility and convenience, highlighting a potential area for future development to enhance user experience and broaden the tool’s reach. Since PWCT2 is based on the Qt framework, which supports WebAssembly, and the Ring language also supports the WebAssembly platform, we plan to develop PWCT2 for WebAssembly in the future. At this stage, we have an online version of the Form Designer, and other components will be ported as well. While PWCT2 includes the Ring2PWCT feature, which allows it to accept Ring code generated by large language models, the process currently requires a copy-and-paste operation (e.g., from Copilot to PWCT2) [77]. A fully integrated solution, where writing a natural language prompt directly generates a visual representation without needing manual transfer, would be more efficient and user-friendly. This enhancement could significantly streamline the workflow and improve usability. Moreover, despite providing 39 instructional videos to explain PWCT2 features, using PWCT2 still demands a general understanding of programming and specific knowledge of the Ring language [85]. To achieve broader adoption, it may be necessary to expand educational resources, including tutorials and documentation, to support users with varying levels of expertise.

In summary, while PWCT2 advances the capabilities of its predecessor and offers a robust platform for developing Ring-based applications, addressing the limitations identified could enhance its functionality, user experience, and appeal to a broader audience. Future work should focus on expanding language support, ensuring compatibility with PWCT1, developing a web-based version, improving integration with natural language processing tools, and enhancing educational resources to support a diverse user base.

6. Conclusions and Future Work

In this research paper, we introduced PWCT2, a visual programming language developed and maintained for many years using the Ring programming language. Visual programming languages are helpful in making programming easier and faster to learn. This study introduces some useful improvements. We have developed a new version of the PWCT visual programming language that includes enhanced features, works on different systems, performs code generation more efficiently than before, and reduces storage requirements.

We also created the first visual programming language that generates code in the Ring programming language. This helps combine the ease of visual programming with the flexibility of Ring. Additionally, we tested how well the Ring programming language Compiler/VM works for developing an advanced project like PWCT2. We also designed a tool to convert textual Ring code into visual code in PWCT2, making it easier to use. These improvements show that there is potential for making visual programming languages more accessible and effective for Ring developers. Our work provides a foundation for further development in this area.

In the future, we aim to enhance PWCT2 by supporting additional textual programming languages such as C, Java, C# and Python. We also plan to improve the environment by offering translations in various human languages, to make it more accessible to a global audience. Moreover, we intend to add more components that provide better support for Ring libraries, further enriching the functionality and usability of PWCT2. These enhancements will continue to build on the progress made and open new possibilities for users and developers.