Next Article in Journal
Systematic Review of Quantization-Optimized Lightweight Transformer Architectures for Real-Time Fruit Ripeness Detection on Edge Devices
Next Article in Special Issue
Potions & Dragons: Player-Informed Web-Based Gamification for Science Attitudinal Change in Initial Teacher Education
Previous Article in Journal
Fast Computation for Square Matrix Factorization
Previous Article in Special Issue
Directional Perception in Game-Based Dyslexia Risk Screening: A Mouse-Tracking Analysis
 
 
Search for Articles:
Title / Keyword
Author / Affiliation / Email
Journal
Article Type
 
 
Advanced Search
 
Section
Special Issue
Volume
Issue
Number
Page
 
Journals
Computers
Volume 15
Issue 1
10.3390/computers15010068
computers-logo
Submit to this Journal Review for this Journal Propose a Special Issue
► Article Menu

Article Menu

share Share announcement Help format_quote Cite question_answer Discuss in SciProfiles
first_page
settings
Order Article Reprints
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

Videogame Programming & Education: Enhancing Programming Skills Through Unity Visual Scripting

by
Álvaro Villagómez-Palacios
1,
Claudia De la Fuente-Burdiles
2 and
Cristian Vidal-Silva
2,*
1
Facultad de Ciencias e Ingenierías, Universidad Estatal de Milagro, Milagro 091050, Ecuador
2
Department of Interactive Visualization and Virtual Reality, Faculty of Engineering, University of Talca, Talca 3460000, Chile
*
Author to whom correspondence should be addressed.
Computers 2026, 15(1), 68; https://doi.org/10.3390/computers15010068
Submission received: 12 December 2025 / Revised: 12 January 2026 / Accepted: 16 January 2026 / Published: 18 January 2026
(This article belongs to the Special Issue Advances in Game-Based Learning, Gamification in Education and Serious Games)
Browse Figures
Versions Notes

Abstract

Videogames (VGs) are highly attractive for children and young people. Although videogames were once viewed mainly as sources of distraction and leisure, they are now widely recognised as powerful tools for competence development across diverse domains. Designing and implementing a videogame is even more appealing for children and novice students than merely playing it, but developing programming competencies using a text-based language often constitutes a significant barrier to entry. This article presents the implementation and evaluation of a videogame development experience with university students using the Unity engine and its Visual Scripting block-based tool. Students worked in teams and successfully completed videogame projects, demonstrating substantial gains in programming and game construction skills. The adopted methodology facilitated learning, collaboration, and engagement. Building on a quasi-experimental design that compared a prior unit based on C# and MonoGame with a subsequent unit based on Unity Visual Scripting, the study analyses differences in performance, development effort, and motivational indicators. The results show statistically significant improvements in grades, reduced development time for core mechanics, and higher self-reported confidence when Visual Scripting is employed. The evidence supports the view of Visual Scripting as an effective educational strategy to introduce programming concepts without the syntactic and semantic barriers of traditional text-based languages. The findings further suggest that Unity Visual Scripting can act as a didactic bridge towards advanced programming, and that its adoption in secondary and primary education is promising both for reinforcing traditional subjects (history, language, mathematics) and for fostering foundational programming and videogame development skills in an inclusive manner.

1. Introduction

The development of algorithmic and programming competencies is widely regarded as essential for modern scientific thinking and computational literacy [1,2]. Programming is now a transversal competence across disciplines, enabling the construction of applications that range from data-intensive systems to simulations and videogames [3,4]. Traditionally, videogames have been associated with leisure and entertainment [5], yet a growing body of research shows that they can be used intentionally to develop skills in health [6], education [7,8], engineering [9,10], and business [11].
In educational contexts, it is critical to explicitly identify the competencies that are to be supported and assessed [12,13]. Courses that involve the design and execution of stepwise procedures, such as introductory programming, physics laboratories, and simulations, can benefit from tools that make algorithmic structures concrete and manipulable [14,15]. However, traditional text-based programming languages often pose a substantial barrier for novices [16,17]. Even when a conceptual task is relatively simple, such as determining whether a person is of legal age (18 years), translating that task into syntactically correct C or C# code requires knowledge of data types, control structures, and error handling that novice learners may not yet possess. Figure 1 illustrates this gap with a flowchart and its corresponding C code for checking whether a person is an adult in Chile.
Given the direct connection between programming and videogame development, this work explores how game projects can serve as a motivating context for acquiring algorithmic and programming skills. Classic titles such as Space Invaders (https://codeheir.com/2019/03/17/how-to-code-space-invaders-1978-7/, accessed on 11 December 2025) or Tetris (https://csourcecodes.blogspot.com/2016/06/tetris-game-c-program-block-game.html, accessed on 11 December 2025) typically require hundreds of lines of code, demanding not only syntactic fluency but also robust design of game loops, collision handling, and feedback mechanisms.
Over the past decade, block-based programming environments such as Scratch, Blockly, and TinkerCAD have helped lower the entrance barrier by allowing learners to construct programs visually [7,18,19]. Unity Visual Scripting extends this idea to a professional game engine, enabling developers to create game logic using nodes and graphs instead of textual code [20,21]. This paper focuses on how Unity Visual Scripting can be employed to develop programming skills in a third-semester course, Physics for Videogames, in the Video Game Development and Virtual Reality Engineering (VGDVRE) program at the University of Talca (UTalca).
Beyond reporting a single experience, this extended version of the article adopts a quasi-experimental perspective. The students first implemented a classic Snake game using MonoGame and C#, and subsequently developed extended variants using Unity Visual Scripting. This design allows us to contrast text-based and visual approaches in terms of grades, development time, and perceived learning. MonoGame is an open-source framework for building 2D games using C#, which provides explicit control over the game loop, rendering, and low-level programming constructs. Frameworks of this type are frequently used in educational settings to support the teaching of core programming concepts through videogame development, particularly in courses that emphasise fundamental logic, graphics pipelines, and hands-on implementation [16,20,22,23].
Prior studies report that block-based and visual programming environments can reduce cognitive load and support conceptual understanding, particularly among novice programmers, while also fostering engagement and positive attitudes toward programming [3,17,24,25]. However, empirical comparisons that explicitly contrast visual and text-based approaches within the same curricular trajectory remain limited. This gap motivates the hypotheses formulated in this study.

1.1. Research Questions and Hypotheses

Building on previous contributions that use block-based tools to develop computational competencies in school and university contexts [7,8,9,26], we define the research questions and objectives summarised in Table 1.
From these questions we derive the following hypotheses:
Hypothesis 1.
Average project grades will be higher in the unit implemented with Unity Visual Scripting than in the earlier unit implemented with MonoGame and C#.
Hypothesis 2.
Students will report higher levels of motivation and confidence towards programming after using Unity Visual Scripting than at the beginning of the course.
Hypothesis 3.
A majority of students will perceive Unity Visual Scripting as a useful intermediate step for later working with text-based languages, rather than as a complete replacement.

1.2. Contributions

This study extends prior work on visual and block-based programming in education by offering an empirical analysis grounded in a controlled, course-level comparison. The main contributions of this article are as follows:
  • We present a within-course, within-subject comparison between a text-based programming unit (MonoGame and C#) and a subsequent visual programming unit (Unity Visual Scripting), implemented with the same student cohort, learning objectives, assessment criteria, and instructional time. This design reduces contextual variability and enables a more direct contrast between programming approaches than studies conducted across separate courses or cohorts.
  • We introduce development time as an explicit educational metric, complementing traditional outcome measures such as grades and self-reported perceptions. By analysing the time required to implement core videogame mechanics, the study provides insight into how different programming paradigms affect implementation effort and learning efficiency in practice.
  • We provide empirical evidence supporting the role of Unity Visual Scripting as a didactic bridge rather than a replacement for text-based programming. The results indicate that visual scripting can facilitate conceptual understanding and confidence while preparing students for subsequent engagement with textual languages in professional or advanced academic contexts.
  • We situate these findings within a physics-oriented videogame programming course, demonstrating how visual programming can be integrated into technically demanding curricula without sacrificing conceptual rigor or alignment with industry-relevant tools.
To the best of our knowledge, this is one of the first studies to empirically compare MonoGame-based text programming and Unity Visual Scripting within a physics-oriented videogame course using both performance and time-based metrics.
The remainder of the article is structured as follows. Section 2 discusses algorithms and programming fundamentals, with emphasis on computational thinking and block-based tools. Section 3 introduces videogame development with Unity and the main features of its Visual Scripting system. Section 4 presents the experimental design, instruments, and main results of the study. Section 5 reviews related work and situates our contribution within the broader literature. Section 6 summarises conclusions and outlines future research avenues.

2. Algorithms and Programming

Developing algorithmic thinking and programming competencies is essential for both children and adults because it supports critical problem solving, logical reasoning, and systematic analysis [1,27]. Algorithmic thinking involves decomposing complex problems into manageable steps, identifying patterns, and designing procedures that can be executed mechanically. These skills are valuable not only in computer science but also in mathematics, engineering, and the social sciences [28,29].
In higher education, programming is increasingly viewed as a form of “literacy” that enables students to explore data, construct models, and build artefacts that embody disciplinary concepts [2,12]. For example, understanding iterative algorithms allows students to simulate physical processes, approximate solutions to equations, or design interactive experiments that respond to user input in real time. In this sense, programming becomes both a means of expression and a tool for inquiry [30].
Text-based programming languages, while powerful and expressive, often present significant challenges to novices [16,17]. They require learners to memorise strict syntactic rules, become familiar with complex development environments, and debug errors that may appear opaque at first. Cognitive load theory suggests that such syntactic overhead can consume working memory resources that might otherwise be devoted to understanding underlying concepts [24,31].

2.1. Block-Based and Visual Programming Paradigms

In response to these challenges, block-based and visual programming environments have emerged as accessible entry points to computational thinking [18,19]. Tools such as Scratch and Blockly offer visual blocks that represent instructions, control structures, and events, which can be snapped together to build programs. This graphical representation removes syntax errors by construction and allows beginners to focus on the semantics of their programs [32,33].
Empirical studies indicate that block-based programming can improve novices’ understanding of fundamental concepts such as sequencing, conditionals, and loops, while also increasing enjoyment and persistence [7,9]. For instance, creating an interactive story in Scratch requires students to coordinate events, manage state through variables, and structure control flow, yet the corresponding code remains readable even for younger learners. Figure 2 illustrates Scratch blocks that implement the legal-age example from Figure 1.
Studies in primary and secondary education suggest that block-based approaches can foster positive attitudes towards computing, especially when connected with meaningful projects and interdisciplinary themes [9,34]. In higher education, block-based tools are increasingly used as scaffolds: they support conceptual understanding before students transition to text-based languages for larger-scale development [9,35].

2.2. From Algorithms to Videogames

While algorithmic exercises in isolation can feel abstract, embedding algorithms within videogame projects often increases engagement and persistence [25,36]. Implementing game mechanics such as movement, collisions, scoring, and feedback naturally introduces loops, conditionals, events, and simple physics models. The gameplay context gives immediate, visually salient feedback whenever a logical or numerical error occurs, which can help students connect cause and effect in their code.
In the present study, algorithms and programming are approached through the lens of physics-based videogame development. Students must reason not only about control flow but also about movement, forces, and interactions in a 2D or 3D environment. Adopting a visual programming interface such as Unity Visual Scripting allows them to focus on this algorithmic and physical logic while postponing detailed exposure to syntax.

3. Video Game Development & Unity

Unity is a widely used game engine that supports both 2D and 3D development, offering cross-platform deployment and a rich ecosystem of assets and plugins [37,38]. Its popularity in industry and education stems from a combination of features: a scene-based editor, a component system for game objects, a built-in physics engine, and integration with C# scripting [22,39]. For educators, Unity provides an authentic environment in which students can develop prototypes that resemble professional games.
Traditional Unity workflows rely on C# scripts attached to game objects. While powerful, this approach inherits the syntactic and tooling complexity of text-based programming. To reduce the barrier for novices and designers, Unity introduced Visual Scripting, a node-based system for defining game logic graphically [20,40].

3.1. Unity Visual Scripting and Bolt

Unity Visual Scripting evolved from Bolt, a third-party asset that gained traction for enabling designers and non-programmers to create game behaviour using visual graphs. Bolt allowed users to compose nodes representing events, conditions, variables, and function calls, which are then executed by Unity’s runtime [41,42]. Recognising its pedagogical and design potential, Unity Technologies acquired Bolt in 2020 and integrated it into the engine as a native feature [43,44].
In Unity Visual Scripting, the main abstractions are as follows:
  • Graphs that define the flow of control and data for a particular behaviour.
  • Nodes that represent actions, conditions, events, and operations.
  • Control ports that determine execution order, similar to the edges between statements in a flowchart.
  • Data ports that carry values (e.g., positions, scores, Boolean flags) between nodes.
Visual Scripting is tightly integrated with Unity’s object and component model. Nodes can reference public fields in components, trigger animations, apply forces in the physics engine, and respond to built-in events such as OnStart, OnUpdate, and OnCollisionEnter. Figure 3 provides an example of a Visual Scripting graph that implements the legal-age check introduced in Section 1, and Figure 4 shows execution snapshots.
Although the Visual Scripting graph for this simple example is longer than the equivalent Scratch project, it operates within a full-featured game engine that supports physics, user interfaces, and asset management [37]. This makes it suitable for higher education contexts where students are expected to approximate professional workflows while still benefiting from visual scaffolding.

3.2. Programming Approaches in Education

Table 2 summarises a conceptual comparison between traditional text-based programming and visual scripting from a pedagogical perspective, extending earlier analyses of block-based tools in K–12 [7,8,18] and higher education [9,18].
Our study positions Unity Visual Scripting as a bridging approach: it aims to preserve much of the authenticity of a professional engine while offering visual affordances similar to block-based environments. The next section describes how this approach was deployed and evaluated in an undergraduate course.

4. Experiment and Main Results

This section presents the design and main results of the empirical study conducted in the Physics for Videogames course. We first describe the course context and participants, then detail the quasi-experimental design and instruments, and finally report the quantitative and qualitative results used to answer the research questions and test the hypotheses introduced in Section 1.

4.1. Course Context and Participants

The study was carried out during the second semester of 2024 in the Physics for Videogames course of the VGDVRE program at UTalca. The course is offered in the third semester and focuses on basic mechanics, collisions, and simple kinematic models implemented through videogame projects.
A total of 22 students participated in the study (all students enrolled in the course). While most had previously taken an introductory programming course using C or Java, diagnostic assessments revealed heterogeneous prior experience with game development and C#. None of the students had prior experience with Unity Visual Scripting.
The study was intentionally designed as a focused, course-level intervention centered on a single, well-defined videogame project. While this design strengthens internal coherence and comparability between programming approaches, it also constrains the generalizability of the findings beyond similar curricular contexts.

4.2. Study Design

The course was organised into two main units:
  • Unit 1—MonoGame and C#: Students implemented a classic Snake game using MonoGame and text-based C#. They programmed movement, collision detection, scoring, and simple game states directly in code.
  • Unit 2—Unity Visual Scripting: Students implemented extended variants of Snake—including multiple fruits, time constraints, and maze-like environments—using Unity and Visual Scripting graphs. Physics and collisions were handled via Unity’s built-in components and Visual Scripting nodes.
All development activities were conducted during scheduled laboratory sessions using institutional desktop computers with identical software configurations. Students did not rely on personal devices for core implementation tasks. Each unit spanned four weeks, with two weekly laboratory sessions of 90 min each, ensuring comparable instructional time across programming approaches. Reported development times correspond to observed and self-reported completion of predefined core tasks during laboratory sessions, rather than total project duration.
Students first worked individually on core programming exercises, and then formed small teams (two or three members) for the main projects in each unit. The same general rubric was used to grade both projects, focusing on correctness, implementation of physics, playability, and code/graph organisation.
The study followed a within-subjects, pre–post design:
  • A diagnostic test on programming and physics concepts was administered at the beginning of the course.
  • After each unit, project grades and development times for key tasks were collected.
  • Surveys were administered before the first project and after completion of the Unity Visual Scripting project, measuring interest, motivation, confidence, and perceptions of the tools.

4.3. Instruments and Data Collection

Three main instruments were used:
1.
Diagnostic and Summative Tests: The diagnostic test evaluated prior knowledge of basic programming constructs (conditions, loops, variables) and their application in simple physics problems. Summative assessments at the end of each unit focused on the correct implementation of game mechanics and conceptual understanding as reflected in code or graphs.
2.
Project Analytics: During both units, instructors recorded approximate development times for key tasks (creating physical objects, applying forces, and implementing collision handling). These times were triangulated with student self-reports and logs from the lab sessions. Table 3 summarises the average time required to complete three representative tasks in each unit.
Visual Scripting systematically reduced the time required to implement core mechanics, suggesting that students could spend more of the lab session refining behaviours and testing variations rather than resolving compilation errors and boilerplate code.
3.
Surveys: Two sets of surveys were used:
  • A pre-survey administered at the beginning of the MonoGame unit, focusing on interest in programming, perceived usefulness, and self-efficacy.
  • A post-survey administered after completing the Unity Visual Scripting project, containing the same items plus additional questions about tool preferences and perceived bridging towards text-based languages.
A 10-point Likert scale was adopted to provide greater sensitivity in detecting moderate changes in motivation and self-efficacy within a small cohort. This scale is commonly used in local institutional evaluations and was familiar to participants, reducing interpretation ambiguity. The survey items were intentionally framed positively to assess students’ self-efficacy and interest levels directly. This approach aligns with guidelines for measuring affective domains in educational settings, where reducing cognitive complexity helps to avoid survey fatigue among novice students [45]. While mixed-framing is sometimes used to detect acquiescence bias, consistent framing was chosen here to maintain clarity and focus on the students’ confidence in their capabilities. Table 4 shows a subset of items where notable changes were observed.
In addition, a final block of items asked specifically about Visual Scripting. Table 5 summarises key results.
To complement mean comparisons, Table 6 reports median values and interquartile ranges for selected survey items. This representation provides a more robust view of response distributions given the sample size, and confirms that observed improvements are consistent across participants rather than driven by outliers.

4.4. Achievement Results

Grades were normalised to a 1.0–7.0 scale, following the Chilean higher-education system. Table 7 compares the distribution of project grades in the MonoGame (P1) and Visual Scripting (P2) units.
On average, project grades increased by 0.31 points in P2. The standard deviation decreased slightly, suggesting more consistent performance across the cohort. A paired-samples t-test on the grade distributions indicated that the difference was statistically significant at the 0.05 level, with a small-to-moderate effect size, supporting H1.
In addition to overall grades, the rubric captured specific programming competencies (conditions, loops, modularity, variables, basic object orientation) and motivation. Table 8 summarises the predominant levels observed before and after the Visual Scripting unit.
While these levels are based on rubric-based categorisations rather than standardised tests, the shift from low to medium–high across most categories aligns with the improved grades and survey findings. Competency levels were classified using predefined rubric thresholds. Scores below 40% of the rubric criteria were categorized as Low, scores between 40% and 70% as Medium, and scores above 70% as High. These thresholds are aligned with the grading regulations of the institution (where 4.0 on a 1.0–7.0 scale represents the passing standard) and are consistent with similar competency-based assessment frameworks in engineering education [14].

4.5. Answering the Research Questions

4.5.1. RQ1: Effectiveness for Programming Competencies

The combined evidence from project grades (Table 7), competency rubrics (Table 8), and reduced development times (Table 3) supports the claim that Unity Visual Scripting is effective for developing programming competencies in this context. Students were able to implement more complex variants of Snake, including timed modes, maze-like levels, and variable speed dynamics—without a corresponding increase in coding errors. H1 is therefore supported.

4.5.2. RQ2: Motivation and Self-Efficacy

The survey results (Table 4 and Table 5) reveal consistent increases of approximately two to three points across items related to interest, enjoyment, and confidence. Students reported that Visual Scripting helped them understand logic and reduced the frustration caused by syntax errors. This pattern is coherent with previous studies that link visual tools and game-based learning to higher engagement and persistence [46,47,48,49]. H2 is thus supported.
Given the sample size and the instructional context of the study, inferential statistical testing was limited to project grade comparisons. Survey-based findings related to motivation, self-efficacy, and perceived bridging effects are therefore interpreted descriptively. These results are intended to provide exploratory evidence that informs pedagogical understanding rather than to support strong causal claims.

4.5.3. RQ3: Visual Scripting as a Bridge

In open-ended responses, students frequently described Visual Scripting as a “comfortable first step” or a “sandbox” for reasoning about logic and physics before writing code. At the same time, several participants noted that writing C# in MonoGame provided finer control and would still be necessary for larger projects. The high mean scores in items that frame Visual Scripting as a precursor to text-based languages (Table 5) indicate that students perceive it as a bridge rather than a terminal solution. This aligns with prior work on block-based tools in higher education [8,9,32,33]. H3 is therefore supported.
Hypotheses H2 and H3 were assessed using descriptive and perceptual indicators rather than formal inferential testing. Given the instructional nature of the study and the limited cohort size, analysis emphasized within-subject comparisons and descriptive trends instead of multivariate modeling. Consequently, inferential testing was restricted to project grade comparisons, while survey-based findings on motivation, self-efficacy, and perceived bridging effects are reported descriptively as exploratory evidence to inform pedagogical understanding rather than to support strong causal claims.

5. Discussion

The present study intersects three main strands of research: computational thinking and programming education, block-based and visual programming tools, and game-based learning using engines such as Unity.

5.1. Computational Thinking and Programming Education

Computational thinking (CT) has become a central concept in discussions of skills of the 21st century [2,50]. CT encompasses problem decomposition, abstraction, algorithm design, and evaluation, and has been advocated as a competence that transcends computer science [51]. In higher education, CT skills assessments are increasingly based on programming tasks, debugging exercises, and authentic projects [13].
Introductory programming courses, however, remain challenging, with high variability in student backgrounds, high dropout rates, and well-documented difficulties in mastering syntax and semantics [16,23]. Systematic mappings of introductory languages highlight the need to reconcile the expressive power of industrial languages with the cognitive demands placed on novices [16]. In this context, scaffolding strategies that reduce extraneous cognitive load—such as visual abstractions, contextualised assignments, and immediate feedback—are particularly valuable.

5.2. Implications of Block-Based and Visual Programming in Education

Block-based programming has been extensively studied as a means to support CT at various educational levels [18,19,46]. Scratch, Blockly, and TinkerCAD have been used in primary and secondary education to introduce core constructs in an accessible way [7,8]. Recent work has also explored block-based approaches in university settings, including the use of Alice and other visual environments in introductory courses [9].
Research suggests that block-based programming tools can foster conceptual understanding and positive attitudes, though questions remain about how best to support transfer to text-based languages [8,9,33]. Some authors advocate for hybrid designs in which block-based and textual representations are co-present [32], while others emphasise the importance of designing projects that gradually increase in complexity.
Unity Visual Scripting contributes to this landscape by embedding a visual language within a professional engine. A recent comparative analysis of visual scripting frameworks highlights Unity Visual Scripting’s strengths in integration and accessibility, particularly for designers and students from non-computing backgrounds [20,41]. Our study extends this line of work by analysing its impact on programming competencies and motivation when used alongside a preceding text-based unit.

5.3. Game-Based Learning and Unity in Education

Game-based learning and serious games have been explored as vehicles for engagement, conceptual understanding, and assessment [5,52]. For university students, designing games can encourage teamwork, creativity, and systems thinking, while also providing concrete artefacts for assessment [53,54]. Unity has been used in courses focused on computer graphics, game design, and introductory computer science concepts [22,37,38].
Jangra et al. report on using Unity and C# to teach interactivity and basic programming, noting the importance of scaffolding and example-driven instruction [39]. Other studies have integrated Unity projects into interdisciplinary courses, demonstrating that students from engineering and design backgrounds can successfully build playable prototypes within a semester [22]. Our work contributes to this literature by shifting part of the programming burden from text-based C# scripts to Visual Scripting graphs, and by empirically comparing both approaches within the same course.

5.4. Comparison with Prior Studies

Prior research has consistently reported that block-based and visual programming environments can support the development of computational thinking, particularly among novice learners and non-computing majors. Studies using tools such as Scratch, Blockly, Alice, and similar environments have highlighted benefits in terms of reduced cognitive load, increased engagement, and improved conceptual understanding of fundamental programming constructs [16,17,18]. However, many of these contributions focus on early educational levels, isolated interventions, or single-paradigm implementations without direct comparison to text-based programming within the same instructional context [8,9].
In contrast, the present study adopts a within-course comparative design that contrasts a text-based programming unit (MonoGame and C#) with a subsequent visual programming unit (Unity Visual Scripting), implemented with the same cohort, learning objectives, assessment rubric, and instructional time. This design allows for a more controlled examination of differences in learning outcomes and development effort than studies conducted across separate courses or cohorts, where contextual variability may obscure pedagogical effects [13,16].
Previous university-level studies have explored the use of visual or block-based tools as introductory scaffolds, often reporting positive student perceptions and improved motivation [9,26]. While these findings align with the survey-based results observed in the present work, our study extends prior evidence by incorporating development time as an explicit metric. The observed reduction in time required to implement core videogame mechanics provides a complementary perspective on learning efficiency that is less frequently addressed in the existing literature [17,20].
Regarding the role of visual programming as a bridge to text-based languages, earlier studies have primarily relied on self-reported perceptions or conceptual arguments [17,33]. The present findings are consistent with this literature, as students perceived Unity Visual Scripting as a preparatory step rather than a replacement for textual programming. Importantly, this perception emerged in a context where students had already experienced text-based development earlier in the course, strengthening the interpretive value of the comparison [9,17].
Overall, while the results corroborate established findings on the pedagogical value of visual programming, the contribution of this study lies in its comparative, within-subject design and its integration of performance, time-based, and perceptual indicators. These elements position the work as a complementary extension of prior studies rather than a replication, and help clarify under which instructional conditions visual scripting can effectively support programming education in higher education [13,16].

5.5. Positioning of the Present Study

Within this broader context, the present article offers three contributions. First, it shows how Unity Visual Scripting can be systematically embedded into an existing physics-oriented course without replacing text-based programming entirely. Second, it provides empirical evidence (grades, development times, and survey data) that supports the use of Visual Scripting as both a learning and motivational scaffold. Third, it explicitly addresses the question of whether visual tools can act as bridges towards more advanced programming, contributing to ongoing debates about the role of block-based languages in higher education [8,9,15]. Future research should replicate this design using different types of videogame projects and diverse student cohorts across institutions. Comparative studies involving multiple genres or disciplinary contexts would allow for stronger claims regarding transferability and external validity.
While several cited studies address programming competencies through game development, the present work differs in its explicit within-subject comparison and its focus on development time as an educational indicator.

6. Conclusions

This extended study examines the use of Unity Visual Scripting in an undergraduate course on physics for videogames, situating it within a broader landscape of computational thinking, visual programming, and game-based learning. By structuring the course around two units, first using MonoGame and C#, then Unity Visual Scripting, we were able to compare text-based and visual approaches in a realistic instructional setting.
The results indicate that Unity Visual Scripting supports the development of core programming competencies, reduces the time needed to implement key mechanics, and is associated with higher project grades and more uniform performance. Students reported increased motivation, confidence, and enjoyment, and described Visual Scripting as a helpful means of understanding logic and physics before engaging with larger text-based code bases. In this sense, the data support our three hypotheses: Visual Scripting enhanced academic outcomes, improved motivational indicators, and was perceived as a bridge towards text-based languages.
From a pedagogical perspective, the findings suggest several implications:
  • Visual Scripting can be used to foreground conceptual understanding (e.g., physics, game logic, computational thinking) while deferring syntactic complexity, especially in early or interdisciplinary courses.
  • Integrating Visual Scripting alongside, rather than instead of, text-based programming offers a pragmatic compromise for programs that must balance industry expectations with the needs of novices.
  • Game projects built with Visual Scripting can serve as tangible artefacts for assessment, reflection, and communication of learning, which is particularly valuable in project-based curricula.
At the same time, the study has limitations. The sample size is modest and limited to a single institution and course. In this context, findings related to motivation, self-efficacy, and perceived bridging effects should be understood as descriptive and exploratory. Future work with larger samples may extend these results through more robust inferential analyses. The quasi-experimental design, while informative, does not fully control for maturation or instructor effects. Additionally, regarding the survey design, we acknowledge that the exclusive use of positively framed items may introduce response bias (acquiescence bias). While chosen to reduce cognitive load, future iterations should consider mixed-item framing to further validate the consistency of student responses. Future work should replicate and extend these results across multiple cohorts and institutions, incorporating more fine-grained measures of CT and longitudinal analyses of students’ trajectories into advanced programming courses.
Promising directions for further research include the following: (i) studying how Visual Scripting can support non-computing majors in disciplines such as physics, architecture, or health; (ii) exploring hybrid representations that combine visual graphs and textual snippets; and (iii) integrating analytics from the Unity editor to better understand students’ problem-solving strategies and debugging behaviours.
In conclusion, Unity Visual Scripting appears to be a promising educational tool that can help bridge the gap between introductory computational thinking and professional game development. When carefully integrated into the curriculum, it offers a viable path for students to acquire programming skills in a context that is both authentic and highly motivating, preparing them for further study and practice in the digital era.

Author Contributions

Conceptualization, C.V.-S. and Á.V.-P.; methodology, C.V.-S.; software, Á.V.-P.; validation, C.V.-S. and C.D.l.F.-B.; formal analysis, C.V.-S.; investigation, Á.V.-P.; resources, C.D.l.F.-B.; data curation, Á.V.-P.; writing—original draft preparation, C.V.-S. and Á.V.-P.; writing—review and editing, C.V.-S. and C.D.l.F.-B.; visualization, Á.V.-P.; supervision, C.V.-S.; project administration, C.V.-S. All authors have read and agreed to the published version of the manuscript.

Funding

This research received no external funding. The APC was funded by the authors.

Data Availability Statement

The original contributions presented in the study are included in the article. Further inquiries can be directed to the corresponding author.

Conflicts of Interest

The authors declare no conflicts of interest.

References

  1. Sarı, U.; Pektaş, H.M.; Şen, Ö.F.; Çelik, H. Algorithmic thinking development through physical computing activities with Arduino in STEM education. Educ. Inf. Technol. 2022, 27, 6669–6689. [Google Scholar] [CrossRef]
  2. Wing, J.M. Computational thinking. Commun. ACM 2006, 49, 33–35. [Google Scholar] [CrossRef]
  3. Kuhail, M.A.; Farooq, S.; Hammad, R.; Bahja, M. Characterizing visual programming approaches for end-user developers: A systematic review. IEEE Access 2021, 9, 14181–14202. [Google Scholar] [CrossRef]
  4. Wongta, N.; Natwichai, J. End-to-end data pipeline in games for real-time data analytics. In Advances in Internet, Data and Web Technologies; Lecture Notes on Data Engineering and Communications Technologies; Barolli, L., Natwichai, J., Enokido, T., Eds.; Springer: Cham, Switzerland, 2021; Volume 65. [Google Scholar]
  5. Pérez, J.; Castro, M.; López, G. Serious games and ai: Challenges and opportunities for computational social science. IEEE Access 2023, 11, 62051–62061. [Google Scholar] [CrossRef]
  6. Tori, A.A.; Tori, R.; Nunes, F.d.L.d.S. Serious game design in health education: A systematic review. IEEE Trans. Learn. Technol. 2022, 15, 827–846. [Google Scholar] [CrossRef]
  7. Vidal-Silva, C.; Serrano-Malebran, J.; Pereira, F. Scratch and arduino for effectively developing programming and computing-electronic competences in primary school children. In Proceedings of the 2019 38th International Conference of the Chilean Computer Science Society (SCCC), Concepcion, Chile, 4–9 November 2019; pp. 1–7. [Google Scholar]
  8. Vidal-Silva, C.; Cárdenas-Cobo, J.; Tupac-Yupanqui, M.; Serrano-Malebrán, J.; Sánchez Ortiz, A. Developing programming competencies in school-students with block-based tools in chile, ecuador, and peru. IEEE Access 2024, 12, 118924–118936. [Google Scholar] [CrossRef]
  9. Vinueza-Morales, M.; Cárdenas-Cobo, J.; Cabezas-Quinto, J.; Vidal-Silva, C. Applying the block-based programming language alice for developing programming competencies in university students. IEEE Access 2025, 13, 21471–21485. [Google Scholar] [CrossRef]
  10. Caeiro-Rodríguez, M.; Manso-Vázquez, M.; Mikic-Fonte, F.A.; Llamas-Nistal, M.; Fernández-Iglesias, M.J.; Tsalapatas, H.; Heidmann, O.; De Carvalho, C.V.; Jesmin, T.; Terasmaa, J.; et al. Teaching soft skills in engineering education: An european perspective. IEEE Access 2021, 9, 29222–29242. [Google Scholar] [CrossRef]
  11. Faisal, N.; Chadhar, M.; Goriss-Hunter, A.; Stranieri, A. Business simulation games in higher education: A systematic review of empirical research. Hum. Behav. Emerg. Technol. 2022, 1578791. [Google Scholar] [CrossRef]
  12. González-Pérez, L.I.; Ramírez-Montoya, M.S. Components of education 4.0 in 21st century skills frameworks: Systematic review. Sustainability 2022, 14, 1493. [Google Scholar] [CrossRef]
  13. Lu, C.; Macdonald, R.; Odell, B.; Kokhan, V.; Demmans Epp, C.; Cutumisu, M. A scoping review of computational thinking assessments in higher education. J. Comput. High. Educ. 2022, 34, 416–461. [Google Scholar] [CrossRef]
  14. Mekterović, I.; Brkić, L.; Milašinović, B.; Baranović, M. Building a comprehensive automated programming assessment system. IEEE Access 2020, 8, 81154–81172. [Google Scholar] [CrossRef]
  15. Lafuente Martínez, M.; Lévêque, O.; Benítez, I.; Hardebolle, C.; Zufferey, J.-D. Assessing computational thinking: Development and validation of the algorithmic thinking test for adults. J. Educ. Comput. Res. 2022, 60, 1436–1463. [Google Scholar] [CrossRef]
  16. Perera, P.; Tennakoon, G.; Ahangama, S.; Panditharathna, R.; Chathuranga, B. A systematic mapping of introductory programming languages for novice learners. IEEE Access 2021, 9, 88121–88136. [Google Scholar] [CrossRef]
  17. Sun, D.; Looi, C.-K.; Li, Y.; Zhu, C.; Zhu, C.; Cheng, M. Block-based versus text-based programming: A comparison of learners’ programming behaviors, computational thinking skills and attitudes toward programming. Educ. Technol. Res. Dev. 2024, 72, 1067–1089. [Google Scholar] [CrossRef]
  18. Resnick, M.; Maloney, J.; Monroy-Hernández, A.; Rusk, N.; Eastmond, E.; Brennan, K.; Millner, A.; Rosenbaum, E.; Silver, J.; Silverman, B.; et al. Scratch: Programming for all. Commun. ACM 2009, 52, 60–67. [Google Scholar] [CrossRef]
  19. Rojas-Valdés, P.; Vidal-Silva, C.; Fuente, C.d.L. Successful development of problem-solving and computing programming competences in children using arduino. In Proceedings of the 2022 International Symposium on Measurement and Control in Robotics (ISMCR), Online Seminar, 28–30 September 2022; pp. 1–6. [Google Scholar]
  20. Castillo-Salvatierra, L.; Cárdenas-Cobo, J.; de la Fuente-Burdiles, C.; Vidal-Silva, C. Programming competencies in university students through game development. Front. Educ. 2025, 10, 1585602. [Google Scholar] [CrossRef]
  21. Villagomez-Palacios, A.; Cardenas-Cobo, J.; de la Fuente-Burdiles, C.; Vidal-Silva, C. Video games and higher education: Enhancing programming learning with unity visual scripting. Form. Univ. 2026; 19, in press. [Google Scholar]
  22. Hanrahan, R. Designing a Computer Game to Teach Computer Science Concepts; Wellington Faculty of Engineering Symposium: Wellington, New Zealand, 2023; Available online: https://ojs.victoria.ac.nz/wfes/article/view/8405 (accessed on 15 January 2026).
  23. Sim, T.Y.; Lau, S.L. Review on challenges and solutions in novice programming education. In Proceedings of the 2022 IEEE International Conference on Computing (ICOCO), Kota Kinabalu, Malaysia, 14–16 November 2022; pp. 55–61. [Google Scholar]
  24. Berssanette, J.H.; de Francisco, A.C. Cognitive load theory in the context of teaching and learning computer programming: A systematic literature review. IEEE Trans. Educ. 2022, 65, 440–449. [Google Scholar] [CrossRef]
  25. Zapata-Cáceres, M.; Martín-Barroso, E. Applying game learning analytics to a voluntary video game: Intrinsic motivation, persistence, and rewards in learning to program at an early age. IEEE Access 2021, 9, 123588–123602. [Google Scholar] [CrossRef]
  26. Vidal-Silva, C.; Barriga, N.A.; Ortega-Cordero, F.; González-López, J.; Jiménez-Quintana, C.; Pezoa-Fuentes, C.; Veas-González, I. Developing computing competencies without restrictions. IEEE Access 2022, 10, 106568–106580. [Google Scholar] [CrossRef]
  27. Juškevičienė, A. Developing Algorithmic Thinking Through Computational Making; Springer International Publishing: Cham, Switzerland, 2020; pp. 183–197. [Google Scholar] [CrossRef]
  28. Dehbozorgi, N.; Roopaei, M. Improving computational thinking competencies in STEM higher education. In Proceedings of the 2024 IEEE Integrated STEM Education Conference (ISEC), Princeton, NJ, USA, 9 March 2024; pp. 1–4. [Google Scholar]
  29. Pirzado, F.A.; Ahmed, A.; Hussain, S.; Ibarra-Vázquez, G.; Terashima-Marin, H. Assessing computational thinking in engineering and computer science students: A multi-method approach. Educ. Sci. 2025, 15, 344. [Google Scholar] [CrossRef]
  30. Fahmideh, M.; Ahmad, A.; Behnaz, A.; Grundy, J.; Susilo, W. Software engineering for internet of things: The practitioners’ perspective. IEEE Trans. Softw. Eng. 2022, 48, 2857–2878. [Google Scholar] [CrossRef]
  31. Chen, C.-Y. Effects of worked examples with explanation types and learner motivation on cognitive load and programming problem-solving performance. ACM Trans. Comput. Educ. 2025, 25, 3732791. [Google Scholar] [CrossRef]
  32. Yusuf, A.; Noor, N.M.; Román-González, M. Interaction patterns during block-based programming activities predict computational thinking: Analysis of the differences in gender, cognitive load, spatial ability, and programming proficiency. AI Comput. Sci. Robot. Technol. 2024, 3, 36. [Google Scholar] [CrossRef]
  33. Batni, B.; Junaini, S.N. Redefining computational thinking: Synergizing unplugged activities with block-based programming. Educ. Inf. Technol. 2025, 30, 2361–2388. [Google Scholar] [CrossRef]
  34. Tramonti, M.; Dochshanov, A.M.; Zhumabayeva, A.S. Design thinking as an auxiliary tool for educational robotics classes. Appl. Sci. 2023, 13, 858. [Google Scholar] [CrossRef]
  35. Wörister, F.; Knobelsdorf, M. Block-based programming in low-level computing: How blocks facilitate learning assembler. In Proceedings of the 2025 IEEE Global Engineering Education Conference (EDUCON), London, UK, 22–25 April 2025; pp. 1–10. [Google Scholar]
  36. Zamorano, M.; Blasco, D.; Cetina, C.; Sarro, F. Video game procedural content generation through software transplantation. In Proceedings of the 2025 IEEE/ACM 47th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP), Ottawa, ON, Canada, 27 April–3 May 2025; pp. 353–364. [Google Scholar]
  37. Hussain, A.; Shakeel, H.; Hussain, F.; Uddin, N.; Ghouri, T. Unity game development engine: A technical survey. Univ. Sindh J. Inf. Commun. Technol. 2020, 4, 73–81. [Google Scholar]
  38. Takoordyal, K. Introduction to Unity; Apress: Berkeley, CA, USA, 2020; pp. 29–58. [Google Scholar] [CrossRef]
  39. Jangra, S.; Singh, G.; Mantri, A.; Angra, S.; Sharma, B. Interactivity development using Unity 3D software and C# programming. In Proceedings of the 2023 14th International Conference on Computing Communication and Networking Technologies (ICCCNT), Delhi, India, 6–8 July 2023; pp. 1–6. [Google Scholar]
  40. Tykoski, S. Mastering Game Design with Unity 2021: Immersive Workflows, Visual Scripting, Physics Engine, GameObjects, Player Progression, Publishing, and a Lot More, English ed.; BPB Publications: Daryaganj, India, 2022; Available online: https://books.google.cl/books?id=P-ybEAAAQBAJ (accessed on 15 January 2026).
  41. Martyastiadi, Y. Observation on the use of visual scripting for interaction design students. Int. J. Creat. Arts Stud. 2022, 9, 133–142. [Google Scholar] [CrossRef]
  42. Using Bolt to Improve Game Development—Alexis Bacot. Available online: https://www.alexisbacot.com/blog/using-bolt-to-visualize-state-machines (accessed on 1 August 2024).
  43. Unity Acquires Bolt—Community Showcases—Unity Discussions. Available online: https://discussions.unity.com/t/unity-acquires-bolt/788469?page=5 (accessed on 1 August 2024).
  44. Secuencias de Comandos Visuales de Unity. Available online: https://unity.com/es/features/unity-visual-scripting (accessed on 1 August 2024).
  45. Bandura, A. Guide for constructing self-efficacy scales. In Self-Efficacy Beliefs of Adolescents; Pajares, F., Urdan, T., Eds.; Information Age Publishing: Greenwich, CT, USA, 2006; Volume 5, pp. 307–337. [Google Scholar]
  46. Vidal, C.; Cabezas, C.; Parra, J.; López, L. Experiencias prácticas con el uso del lenguaje de programación Scratch para desarrollar el pensamiento algorítmico de estudiantes en Chile. Form. Univ. 2015, 8, 23–32. Available online: http://www.redalyc.org/articulo.oa?id=373544191001 (accessed on 15 January 2026). [CrossRef]
  47. Ke, F.; Xie, K.; Xie, Y. Game-based learning engagement: A theory- and data-driven exploration. Br. J. Educ. Technol. 2016, 47, 1183–1201. [Google Scholar] [CrossRef]
  48. Tsai, M.-J.; Huang, L.-J.; Hou, H.-T.; Hsu, C.-Y.; Chiou, G.-L. Visual behavior, flow and achievement in game-based learning. Comput. Educ. 2016, 98, 115–129. [Google Scholar] [CrossRef]
  49. Israel-Fishelson, R.; Hershkovitz, A. Persistence in a game-based learning environment: The case of elementary school students learning computational thinking. J. Educ. Comput. Res. 2020, 58, 891–918. [Google Scholar] [CrossRef]
  50. Tekdal, M. Trends and development in research on computational thinking. Educ. Inf. Technol. 2021, 26, 6499–6529. [Google Scholar] [CrossRef]
  51. Hamidi, A. Advancing computational thinking education: Insights from systems thinking applications. Hum. Syst. Manag. 2025, 44, 1–18. [Google Scholar] [CrossRef]
  52. Gomez, M.J.; Ruipérez-Valiente, J.A.; Clemente, F.J.G. A systematic literature review of game-based assessment studies: Trends and challenges. IEEE Trans. Learn. Technol. 2023, 16, 500–515. [Google Scholar] [CrossRef]
  53. Maxim, R.I.; Arnedo-Moreno, J. Identifying key principles and commonalities in digital serious game design frameworks: Scoping review. JMIR Serious Games 2025, 13, e54075. Available online: https://games.jmir.org/2025/1/e54075 (accessed on 11 December 2025). [CrossRef]
  54. Tahir, R.; Wang, A.I. Completeness and collaboration in the early design phase of learning games: Do ideation cards provide scaffolding? In Learning and Collaboration Technologies: Games and Virtual Environments for Learning; Zaphiris, P., Ioannou, A., Eds.; Springer International Publishing: Cham, Switzerland, 2021; pp. 94–114. [Google Scholar]
Computers 15 00068 g001
Figure 1. Flowchart and C code for determining if a person is of legal age in Chile (18 years).
Figure 1. Flowchart and C code for determining if a person is of legal age in Chile (18 years).
Computers 15 00068 g001
Computers 15 00068 g002
Figure 2. Scratch code and execution for determining if a person is of legal age in Chile (18 years).
Figure 2. Scratch code and execution for determining if a person is of legal age in Chile (18 years).
Computers 15 00068 g002
Computers 15 00068 g003aComputers 15 00068 g003b
Figure 3. Unity Visual Scripting solution for determining whether a person is of legal age in Chile (18 years). Green arrows indicate the execution flow and the active connections evaluated at runtime (true/false branches).
Figure 3. Unity Visual Scripting solution for determining whether a person is of legal age in Chile (18 years). Green arrows indicate the execution flow and the active connections evaluated at runtime (true/false branches).
Computers 15 00068 g003aComputers 15 00068 g003b
Computers 15 00068 g004
Figure 4. Execution of the Visual Scripting graph for the adult/non-adult example. (a) Execution example for an adult. (b) Execution example for a person younger than 18.
Figure 4. Execution of the Visual Scripting graph for the adult/non-adult example. (a) Execution example for an adult. (b) Execution example for a person younger than 18.
Computers 15 00068 g004
Table 1. Research Questions and Objectives.
Table 1. Research Questions and Objectives.
Research QuestionObjective
RQ1: How effective is Unity Visual Scripting in developing core programming competencies (conditions, iteration, modularity, variables, and basic object-orientation)?OBJ1: To assess the effectiveness of Visual Scripting in teaching core programming concepts in a videogame context.
RQ2: Can Unity Visual Scripting enhance motivation and perceived self-efficacy in a physics-based programming course for novice programmers?OBJ2: To analyse the impact of Visual Scripting on students’ motivation, confidence, and satisfaction with programming activities.
RQ3: To what extent can Unity Visual Scripting act as a didactic bridge towards text-based programming languages in higher education?OBJ3: To explore whether experience with Visual Scripting is perceived as a helpful stepping stone towards C#/C++ and other text-based languages.
Table 2. Comparison of Text-based Programming and Visual Scripting in Education.
Table 2. Comparison of Text-based Programming and Visual Scripting in Education.
CharacteristicText-BasedVisual Scripting
Syntactic complexityHighLow
Initial learning curveMedium/HighLow/Medium
Debugging demandsOften high, error messagesLower, visually constrained
Typical use in curriculumIntermediate/advanced coursesIntroductory and bridging activities
Support for scalable architecturesHigh (large code bases)Moderate (suitable for prototypes and medium projects)
Suitability for non-CS majorsLimited without strong supportHigh, especially in project-based settings
Table 3. Average Development Time per Task: C# vs. Visual Scripting.
Table 3. Average Development Time per Task: C# vs. Visual Scripting.
TaskMonoGame (C#)Unity Visual Scripting
Creation of physical objects35 min20 min
Application of forces/movement40 min25 min
Collision simulation and game-over logic50 min30 min
Table 4. Selected Motivation and Self-efficacy Items: Pre vs. Post.
Table 4. Selected Motivation and Self-efficacy Items: Pre vs. Post.
Item (1–10 Scale)PrePost
I enjoy solving problems through programming.5.57.8
Programming is useful for my career.6.28.5
I feel confident in my ability to program a videogame.5.07.9
I can understand basic programming concepts without major difficulties.5.58.2
I can work autonomously when implementing mechanics in a game.5.88.1
Table 5. Perceptions of Unity Visual Scripting (Post-survey).
Table 5. Perceptions of Unity Visual Scripting (Post-survey).
Item (1–10 Scale)Mean
Compared to traditional programming, I prefer using visual tools such as Unity Visual Scripting.8.6
Visual Scripting helped me understand programming logic.8.9
Visual Scripting reduced the difficulties I had when working with textual code.8.7
Visual Scripting is useful for learning fundamentals before moving to textual languages.8.8
I would recommend Visual Scripting to students starting videogame programming.9.0
Table 6. Distribution summary of motivation and self-efficacy survey items (Pre vs. Post).
Table 6. Distribution summary of motivation and self-efficacy survey items (Pre vs. Post).
ItemPre Median (IQR)Post Median (IQR)
I enjoy solving problems through programming.5.5 (4.5–6.5)8.0 (7.5–8.5)
Programming is useful for my career.6.0 (5.0–7.0)9.0 (8.0–9.0)
I feel confident in my ability to program a videogame.5.0 (4.0–6.0)8.0 (7.0–8.5)
I can understand basic programming concepts without major difficulties.5.5 (4.5–6.5)8.0 (7.5–8.5)
I can work autonomously when implementing mechanics in a game.6.0 (5.0–6.5)8.0 (7.5–8.5)
Table 7. Comparison of Project Grades: MonoGame vs. Visual Scripting.
Table 7. Comparison of Project Grades: MonoGame vs. Visual Scripting.
MetricP1 (MonoGame, C#)P2 (Unity Visual Scripting)
Mean6.156.46
Standard deviation0.550.49
Minimum5.05.5
Maximum6.96.9
Table 8. Summary of Programming Competencies Before and After Visual Scripting.
Table 8. Summary of Programming Competencies Before and After Visual Scripting.
CompetencyInitial LevelPost Level
Conditions (if/else)LowMedium–High
Iteration (loops)LowMedium–High
Modularity (functions/components)LowMedium–High
Variables and stateLowMedium–High
Basic OOP conceptsLowMedium–High
Motivation and engagementLow/MediumHigh
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Share and Cite

MDPI and ACS Style

Villagómez-Palacios, Á.; Fuente-Burdiles, C.D.l.; Vidal-Silva, C. Videogame Programming & Education: Enhancing Programming Skills Through Unity Visual Scripting. Computers 2026, 15, 68. https://doi.org/10.3390/computers15010068

AMA Style

Villagómez-Palacios Á, Fuente-Burdiles CDl, Vidal-Silva C. Videogame Programming & Education: Enhancing Programming Skills Through Unity Visual Scripting. Computers. 2026; 15(1):68. https://doi.org/10.3390/computers15010068

Chicago/Turabian Style

Villagómez-Palacios, Álvaro, Claudia De la Fuente-Burdiles, and Cristian Vidal-Silva. 2026. "Videogame Programming & Education: Enhancing Programming Skills Through Unity Visual Scripting" Computers 15, no. 1: 68. https://doi.org/10.3390/computers15010068

APA Style

Villagómez-Palacios, Á., Fuente-Burdiles, C. D. l., & Vidal-Silva, C. (2026). Videogame Programming & Education: Enhancing Programming Skills Through Unity Visual Scripting. Computers, 15(1), 68. https://doi.org/10.3390/computers15010068

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop