Visual anomalies in video games can degrade user experience and impact overall software quality, highlighting the need for scalable methods within modern quality assurance (QA) pipelines. Manual testing remains resource-intensive and difficult to scale, while existing AI-based approaches often struggle to generalize across diverse rendering styles and gameplay scenarios. This paper presents a hierarchical visual anomaly detection framework that integrates game state information to enhance contextual awareness and detection accuracy. A synthetic data generation pipeline is introduced to create high-fidelity, game-specific training samples that capture the visual characteristics and edge cases of individual titles. Human-in-the-loop mechanisms support the identification of challenging scenarios and the definition of functional test conditions suitable for continuous integration workflows. The system operates continuously during production, enabling real-time detection of rendering anomalies without interfering with gameplay. The proposed framework is evaluated across three commercial game titles, demonstrating its effectiveness and adaptability. It comprises a configurable data generation pipeline, a state-conditioned detection model, and an automated anomaly identification tool, forming a modular and extensible QA solution for interactive software systems.

Visual glitches reduce player immersion and compromise product quality, making automated detection a vital component of modern game quality assurance (QA) processes. Manual testing remains costly and difficult to scale while existing AI-based methods often cannot generalize to the wide variety of rendering styles and gameplay scenarios. To address these challenges, a hierarchical detection model is introduced, augmented with game state information to improve contextual sensitivity. A synthetic data generation pipeline is proposed to produce diverse, game-specific datasets, supporting model adaptation to varying visual environments and edge cases. This process is supported by human-in-the-loop techniques that guide the collection of critical samples. Additionally, the framework continuously monitors and evaluates rendering outputs during development, enabling early detection of visual glitches in production workflows. Human oversight further contributes to the design of targeted visual test scenarios, improving detection effectiveness during continuous development cycles. Results from large-scale deployments with industry partners demonstrate the practicality of the system.

Modern cybersecurity incident response workflows remain highly reliant on manual intervention, frequently resulting in delays and inconsistencies in threat mitigation. This paper introduces an automated method that leverages compact, fine-tuned large language models (LLMs) to generate CACAO-compliant security playbooks from structured incident data, aligned with emerging cybersecurity standards. To support both model fine-tuning and empirical evaluation, we introduce a novel dataset that integrates validated real-world incidents with systematically constructed synthetic scenarios. The approach uses a JSON-based intermediate representation to facilitate the structured transformation of incident data into executable mitigation procedures. In addition, we incorporate post-processing routines and prompt optimization techniques to improve structural validity and semantic coherence. Experimental results indicate that task-adapted compact LLMs achieve performance comparable to significantly larger models. At the same time, they reduce computational requirements, enabling deployment in resource-constrained environments and integration with existing SIEM and SOAR systems.

This paper introduces an LLM-augmented pipeline for automating the transformation of unstructured Reddit feedback into structured Jira issues. Designed for DevOps environments, the system performs a two-layered sentiment analysis - combining fast, lightweight classification with high-accuracy LLM-based scoring - followed by LLM-driven summarization and component-aware semantic matching. Feedback is either linked to existing issues or triggers new ticket creation based on similarity thresholds and component alignment. A hybrid graph-relational backend supports issue clustering, trend detection, and historical traceability. Based on real-world game development data, the system shows high scalability and significantly improves triage efficiency and developer feedback coverage.

The gaming industry is an important part of today’s economy. Statistically, many quality issues are found by users in released products or updates. One reason for this is that testing methods from general software development cannot be transferred to test visual outputs without significant human effort. This work focuses on a major problem in this area, namely testing the correctness of the images displayed by cameras in relation to the content of the environment they are intended to see. The techniques used are a combination of state-of-the-art computer vision methods adapted to our specific use cases. Evaluation is performed in a well-known soccer game engine and shows that the proposed methods have the potential to significantly reduce manual work and development costs while improving product quality.

Even though test automation has an increased presence in industry nowadays, there is still room for improvement, especially in the area of end-to-end testing. Most testing methods in the literature focus on techniques that do not test these applications as a typical end user would, i.e., starting from the user interface (UI) level. Our work, done in collaboration with UiPath company, a leader in Robotic Process Automation (RPA), proposes deep reinforcement learning methods that can test applications from end to end at the UI level. In the current implementation of our prototype, abstractions and separation of concerns are considered so that methods can be reused between applications and algorithms can be used with minimal user effort. The testing process that results after training the agents is similar to that of a human tester going through the functions of the application. Empirical evaluation of these agents shows that, on the one hand, they can almost perfectly mimic the behavior of human testers and, on the other hand, they can exceed the human performance level.

Problems related to the quality of games, whether on the initial release or after updates, can lead to player dissatisfaction, media attention, and potential financial setbacks. These issues can stem from software bugs, performance bottlenecks, or security vulnerabilities. Despite these challenges, game developers often rely on manual playtesting, highlighting the need for more robust and automated processes in game development. This research explores the application of Large Language Models (LLMs) to automate the creation of unit tests in game development, focusing on strongly typed programming languages such as C++ and C#, which are widely used in the industry. The study focuses on fine-tuning Code Llama, an advanced code generation model, to address common scenarios in game development, including game engines and specific APIs or backends. Although the prototyping and evaluations primarily took place within the Unity game engine, the proposed methods can be adapted to other internal or publicly available solutions. The evaluation results demonstrate these methods’ effectiveness in improving existing unit test suites or automatically generating new tests based on natural language descriptions of class contexts and targeted methods.

By using Robotic Process Automation (RPA), repetitive processes in companies can be automated and executed with intelligent software agents. These agents are able to run such processes without human effort and with less error-proneness. RPA has gained significant traction in recent years and is being used by many companies to reduce internal costs and achieve a higher return on investment (ROI). In our literature review, we found that there is a gap in the testability of RPA workflows. In this paper, we focus on addressing this gap using concolic execution (also referred to as online symbolic execution in the literature). First, we explore how previous work in the literature on concolic execution can be reused for the RPA domain and we implement a prototype. Then, we evaluate our open source solution for adapting concolic execution to the RPA context, using real-world use cases and best practices.

As is the case with any very complex and interactive software, many video games are released with various minor or major issues that can potentially affect the user experience, cause security issues for players, or exploit the companies that deliver the products. To test their games, companies invest important resources in quality assurance personnel who usually perform the testing mostly manually. The main goal of our work is to automate various parts of the testing process that involve human users (testers) and thus to reduce costs and run more tests in less time. The secondary goal is to provide mechanisms to make test specification writing easier and more efficient. We focus on solving initial real-world problems that have emerged from several discussions with industry partners. In this paper, we present RiverGame, a tool that allows game developers to automatically test their products from different points of view: the rendered output, the sound played by the game, the animation and movement of the entities, the performance and various statistical analyses. We also address the problem of input priorities, scheduling, and directing the testing effort towards custom and dynamic directions. At the core of our methods, we use state-of-the-art artificial intelligence methods for analysis and a behavior-driven development (BDD) methodology for test specifications. Our technical solution is open-source, independent of game engine, platform, and programming language.

In this paper, we propose GameBlockchain, an open-source blockchain framework designed to support secure transactions of NFTs in modern computer games. Its purpose is to enable game industry stakeholders such as game developers, content creators, and regular gamers to create and exchange game assets in a more secure and trusted environment. The security of traditional databases and potential data tampering or dangerous user behavior is improved, as outlined in the paper, by blockchain technology, which is used to record critical operations in a ledger, preserving the identity of the user at all times. From a technical perspective, the main goal is to provide an architecture that is easy to use, flexible, understandable, and has an extensible SDK. Using the framework, game developers and regular users should be able to create and trade assets without third-party providers, and use all related services directly in the game interface itself, without having to switch between applications or pay additional transfer fees to providers. We also encourage the development of games with shared marketplaces and wallets on both the developer and user sides, making it easier to monetize assets and services.

Creating synthetic behaviors of vehicles in simulation applications has always been challenging from a development standpoint. First, it is a real challenge to create a credible and realistic simulation while achieving the required runtime efficiency. Second, the effort required to implement it can add significant cost to the development processes. In this paper, we propose an automated way to design vehicle simulation systems by transfer learning from reality to simulators. Our methods rely on advanced deep learning technologies and datasets commonly used in the field of self-driving cars. To assess how well this approach would work in a simulation environment, experiments using the CARLA simulator are presented in the evaluation. The results show that the proposed transfer learning approach provides good results, both quantitatively and qualitatively, and is suitable for runtime evaluation even in resource-constrained simulation applications such as video games.

Combining fuzzing techniques and reinforcement learning could be an important direction in software testing. However, there is a gap in support for experimentation in this field, as there are no open-source tools to let academia and industry to perform experiments easily. The purpose of this paper is to fill this gap by introducing a new framework, named RiverFuzzRL, on top of our already mature frame-work for AI-guided fuzzing, River. We provide out-of-the-box implementations for users to choose from or customize for their test target. The work presented here is performed on testing binaries and does not require access to the source code, but it can be easily adapted to other types of software testing as well. We also discuss the challenges faced, opportunities, and factors that are important for performance, as seen in the evaluation.

The relation between a structure and the function it runs is of interest in many fields, including computer science, biology (organ vs. function) and psychology (body vs. mind). Our paper addresses this question with reference to computer science recent hardware and software advances, particularly in areas as Robotics, Self-Adaptive Systems, IoT, CPS, AI-Hardware, etc. At the modelling, conceptual level our main contribution is the introduction of the concept of “virtual organism” (VO), to populate the intermediary level between reconfigurable hardware agents and intelligent, adaptive software agents. A virtual organism has a structure, resembling the hardware capabilities, and it runs low-level functions, implementing the software requirements. The model is compositional in space (allowing the virtual organisms to aggregate into larger organisms) and in time (allowing the virtual organisms to get composed functionalities). The virtual organisms studied here are in 2D (two dimensions) and their structures are described by 2D patterns (adding time, we get a 3D model). By reconfiguration an organism may change its structure to another structure in the same 2D pattern. We illustrate the VO concept with a few increasingly more complex VO’s dealing with flow management or a publisher-subscriber mechanism for handling services. We implemented a simulator for a VO, collecting flow over a tree-structure (TC-VO), and the quantitative results show reconfigurable structures are better suited than fixed structures in dynamically changing environments. Finally, we briefly show how Agapia - a structured parallel, interactive programming language where dataflow and control flow structures can be freely mixed - may be used for getting quick implementations for VO’s simulation.

The diversity of agent behaviors is an important topic for the quality of video games and virtual environments in general. Offering the most compelling experience for users with different skills is a difficult task, and usually needs important manual human effort for tuning existing code. This can get even harder when dealing with adaptive difficulty systems. Our paper's main purpose is to create a framework that can automatically create behaviors for game agents of different difficulty classes and enough diversity. In parallel with this, a second purpose is to create more automated tests for showing defects in the source code or possible logic exploits with less human effort.

Programming parallelism with shared memory raises some technical difficulties in synchronization and accessing memory in a thread-safe way. Most of the time the result is a trade-off between application's source code understandability, maintainability and error-prone on one side, and performance on the other side. This trade-off is even tighter when using low-level languages such as C++. The paper presents an open-source library for C++ that provides a Sequential Communicating Processes method for communication and synchronization, and overall, aims to simplify the shared memory parallelism development, make it more predictable and less error-prone, without sacrificing performance. The efficiency of the solution is proven through a set of concrete examples and benchmarks.

As distributed applications became more commonplace and more sophisticated, new programming languages and models for distributed programming were created. In the context of continuously increasing data flows in parallel applications, there is a renewed interest in the dataflow paradigm. This paper shows why AGAPIA language is suitable for dataflow programming. AGAPIA is capable of expressing massive parallelism in a manageable way for programmers, allowing building dynamic nodes and links in the data flow graph at runtime. The nodes of the dataflow graph, also called programs, are modular and reusable. The communication is transparent for users allowing them to concentrate on the high level flow and algorithm. A complete application and an analysis in terms of productivity and performance are presented in order to demonstrate the AGAPIA's capabilities.