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.

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.

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.

We present a binary analysis framework based on symbolic execution with the distinguishing capability to execute stepwise forward and also backward through the execution tree. It was developed internally at Bitdefender and code-named RIVER. The framework provides components such as a taint engine, a dynamic symbolic execution engine, and integration with Z3 for constraint solving. In this paper we will provide details on the framework and give an example of analysis on binary code.

We propose an approach which, given a state-transition model of a system, constructs, in parallel, an approximate automaton model and a test suite for the system. The approximate model construction relies on a variant of Angluin's automata learning algorithm, adapted to finite cover automata. A finite cover automaton represents an approximation of the system that only considers sequences of length up to an established upper bound ℓ. Crucially, the size of the cover automaton, which normally depends on ℓ, can be significantly lower than the size of the exact automaton model. Thus, controlling ℓ, the state explosion problem normally associated with constructing and checking state-based models can be mitigated. The proposed approach also allows for a gradual construction of the model and of the associated test suite, with complexity and time savings. Moreover, we provide automation of counterexample search, by a combination of black-box and random testing, and metrics to evaluate the quality of the produced results. The approach is presented and implemented in the context of the Event-B modeling language, but its underlying ideas and principles are much more general and can be applied to any system whose behavior can be suitably described by a state-transition model.

Mobile distributed systems involve specific aspects such as migration, communication and concurrency, usually under temporal constraints. In this paper, we deal with formal modelling of timed migrating and communicating processes, as provided by the TiMo calculus. In this framework, mobile processes can move between different locations and communicate when collocated, all this happening in the presence of local timers. Our contribution is a general framework for reasoning about systems specified using TiMo. We use the Event-B modelling method as the target for translating TiMo specifications. Subsequently, we utilise the supporting Rodin platform of Event-B to verify system properties using the embedded theorem-provers and model checkers. The main feature of our encoding include a generic model capturing the syntax and semantics of TiMo, together with a concrete model corresponding to each specific TiMo specification. We illustrate our approach by a non-trivial example featuring different concepts of TiMo.

Zielonka's theorem, established 25 years ago, states that any regular language closed under commutation is the language of an asynchronous automaton (a tuple of automata, one per process, exchanging information when performing common actions). Since then, constructing asynchronous automata has been simplified and improved ([Cori/Métivier/Zielonka,1993],[Klarlund/Mukund/Sohoni,1994], [Diekert/Rozenberg,1995], [Genest/Muscholl,2006], [Genest/Gimbert/Muscholl/Walukiewicz,2010], [Baudru/Morin, 2006], [Baudru,2009], [Pighizzini,1993], [Stefanescu/Esparza/Muscholl,2003]). We first survey these constructions and conclude that the synthesized systems are not realistic in the following sense: existing constructions are either plagued by deadends, non deterministic guesses, or the acceptance condition or choice of actions are not distributed. We tackle this problem by giving (effectively testable) necessary and sufficient conditions which ensure that deadends can be avoided, acceptance condition and choices of action can be distributed, and determinism can be maintained. Finally, we implement our constructions, giving promising results when compared with the few other existing prototypes synthesizing asynchronous automata.

This paper shows that language based top-down supervisor synthesis of Ramadge-Wonham supervisory control theory is in general not feasible. We show this as a direct consequence of the undecidability result of Decomposable Subset problem (and its prefix closed version), which in turn is a corollary of the undecidability result of Trace Closed Subset problem. Essentially, it is in general not possible to decide in finite amount of time whether there exists a string in a regular language such that all those strings indistinguishable from it are contained in the same language. We bring these results to the attention of control community and investigate the decidability status of some other related problems.

We present a computational framework for automatic synthesis of control and communication strategies for a robotic team from task specifications that are given as regular expressions about servicing requests in an environment. We assume that the location of the requests in the environment and the robot capacities and cooperation requirements to service the requests are known. Our approach is based on two main ideas. First, we extend recent results from formal synthesis of distributed systems to check for the distributability of the task specification and to generate local specifications, while accounting for the service and communication capabilities of the robots. Second, by using a technique that is inspired by linear temporal logic model checking, we generate individual control and communication strategies. We illustrate the method with experimental results in our robotic urban-like environment.

We consider the following problem: GIVEN (1) a set of service requests occurring at known locations in an environment, (2) a set of temporal and logical constraints on how the requests need to be serviced, (3) a team of robots and their capacities to service the requests individually or through collaboration, FIND robot control and communication strategies guaranteeing the correct servicing of the requests. Our approach is hierarchical. At the top level, we check whether the specification, which is a regular expression over the requests, is distributable among the robots given their service and cooperation capabilities; if the answer is positive, we generate individual specifications in the form of finite state automata, and interaction rules in the form of synchronizations on shared requests. At the bottom level, we check whether the local specifications and the synchronizations can be implemented given the motion and communication constraints of the robots; if the answer is positive, we generate robot motion and service plans, which are then mapped to control and communication strategies. We illustrate the method with experimental and simulation results.

Software development and testing of enterprise resource planning (ERP) systems demands dedicated methods to tackle its special features. As manual testing is not able to systematically test ERP systems due to the involved complexity, an effective testing approach should be automated, also requiring that the appropriate test data has to be provided alongside. In this paper we identify four main challenges regarding the provision of test data for automatic testing of ERP software: system test data supply, system test data stability, input test data constraints and test data correlation. Several possible solutions to these challenges are discussed. We conclude with an outlook to possible research activities.

Summary form only given. Our research aims towards a new method of synthesis for distributed systems using Mazurkiewicz traces for specification and asynchronous automata for models. Mazurkiewicz trace languages are languages closed under an explicit independence relation between actions and therefore they are suitable to describe concurrent behaviour. The main objectives of this work are: (a) to develop a specification language based on a distributed version of temporal logic on traces that is able to express properties about the independence of actions; (b) to design a synthesis procedure based on improvements and heuristics of the algorithms for asynchronous automata; (c) to implement the new procedure efficiently (and so to turn the theory into a reliable tool that can be used in practice); (d) to apply it to case studies in areas like small distributed algorithms (e.g. mutual exclusion, communication protocols) and asynchronous circuit design. The idea used for the core of the synthesis procedure is that of unfoldings, a successful technique based on branching time partial order semantics. Promising preliminary results were obtained: we were able to automatically synthesize mutual exclusion algorithms from regular trace specifications.