Progetti di corso
| homehome | per annoper anno | per statoper stato | per tipoper tipo | personepersone | tag 965tag | tutti 782tutti | cercacerca |
2026 822025 652024 632023 602022 462021 482020 342019 392018 202017 292016 212015 202014 142013 302012 272011 452010 362009 42008 72007 152006 72005 62004 72001 2— 55
782 record: qui il primo gruppo; per gli altri, sceglierne uno sopra.
2026 82
@courseproject{debate2rescue-ise2526, abstract = {Debate2Rescue is a multi-agent simulation for the dynamic allocation of scarce resources in disaster-response scenarios. When multiple emergencies require the same resource—such as a medical helicopter or heavy machinery—autonomous rescuer agents negotiate by exchanging structured logical arguments rather than numerical bids. The project investigates how argumentation-based negotiation can support transparent and context-sensitive decisions in situations where fixed priority metrics are insufficient. The system combines BDI agents implemented in Jason/AgentSpeak, logic-based argument evaluation through tuProlog and Arg2P, and a custom Java-based discrete spatial simulator. Rescuer agents perceive the environment, maintain beliefs about emergencies, formulate rescue intentions, and justify their resource requests. A dispatcher coordinates task assignments, while the argumentation engine evaluates conflicts and determines the prevailing request according to domain-specific rules. A dedicated communication protocol introduces performatives such as {{code language="none"}}ARGUE{{/code}}, {{code language="none"}}ATTACK{{/code}}, {{code language="none"}}CONCEDE{{/code}}, and {{code language="none"}}REJECT{{/code}}. The resulting prototype will provide a visual or command-line monitor and structured event logs, making both spatial coordination and the reasoning behind every resource-allocation decision observable and explainable.}, apice = {Debate2Rescue}, author = {Amadori, Nicolas and Mazzi, Riccardo and Nanni, Denise}, howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026}, month = oct, sort = {simulation}, supervisor = {Omicini, Andrea}, title = {Debate2Rescue}, type = {Standard Project}, url = {https://github.com/NicolasAmadori/Debate2Rescue}, year = 2026 }
@courseproject{gridsim-ds2526, abstract = {GridSim-Distribuited simulates a small electrical grid — houses, solar panels, batteries and the cables connecting them — as a genuinely distributed, tick-driven system rather than as a single-process program. On the backend, every grid entity and every running simulation is an independent, event-sourced Apache Pekko actor: cluster sharding gives each one a stable identity regardless of which node currently hosts it, and Pekko Persistence lets it recover its exact state by replaying its event log. Because that log is kept in a Redis store shared by every backend node, rather than inside the node that hosts the actor, a simulation survives not only an actor restart but also the crash of a whole node, resuming on a surviving one. Each simulated tick is a scatter/gather exchange between a simulation’s orchestrating actor and its entities, guarded by a timeout; a timed-out tick is retried with exponential backoff, the retry is idempotent with respect to the at-least-once delivery a distributed system has to assume, and a run of repeated failures is reported to clients as a degraded status rather than silently retried forever. A Split Brain Resolver, configured with a keep-majority strategy, gives the cluster a deterministic response to a network partition. A separate ScalaFX desktop client, structured with an MVVM architecture, drives the simulation’s lifecycle through a synchronous HTTP API and observes its progress through Protobuf-encoded telemetry published over Apache Kafka, a channel that lets several GUI instances watch the same simulation at once without the backend tracking who is listening. Grid topologies are authored through a small internal Scala DSL with accumulating validation, from which the system’s four built-in scenario presets are built. This report documents the requirements, architecture, implementation and validation of the system.}, apice = {GridSim}, author = {Matteo Bambini and Nardini, Michele}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = nov, sort = {simulation}, supervisor = {Matteini, Mattia}, title = {Grid Sim}, type = {Simulation Project}, url = {https://github.com/michelenardini99/GridSim-Distribuited}, year = 2026 }
@courseproject{fallsgame-ds2425, abstract = {This report presents the "Falls Game" project, realized for the "Distributed Systems" course at the University of Bologna. The project is a multiplayer game inspired by one of the levels of Fall Guys: players compete in a multi-layered arena where the platforms disappear beneath their feet, and the last one standing wins. The game is written in Python with the Ursina engine. The main focus of the project is the networking. The matchmaking mode relies on a matchmaking server that creates a separate game process for each match, while in the peer-to-peer mode there is no server: all the players run the same program and one of them, the host, also acts as the authority of the match (a peer-to-peer architecture with a host). Both modes are played on a local network; hosting the matchmaking server on a cloud service is left as future work. In both modes an authoritative host or server decides the state of the match and the clients only send their positions and requests. The system uses TCP for the operations that must be reliable (matchmaking and joining) and UDP for the real-time game traffic, and it uses Redis to keep track of the matches in progress. It also tolerates failures: a player who loses the connection can rejoin the match, and a peer-to-peer match survives the loss of its host thanks to an automatic host migration.}, apice = {FallsGame}, author = {Guo, Jiahao}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = nov, sort = {game}, supervisor = {Ciatto, Giovanni and Matteini, Mattia}, title = {Falls Game}, type = {Game Project}, url = {https://github.com/schwein69/Falls-Game}, year = 2026 }
@courseproject{kafkarabbitmq2026-ds2526, abstract = {The goal of this project is to analyze and compare Apache Kafka and RabbitMQ within the context of modern event-driven distributed systems. The project focuses on asynchronous communication, distributed messaging, scalability, reliability, and fault tolerance. Theoretical analysis will be supported by a lightweight experimental environment for practical validation and observation of distributed-system behaviours.}, apice = {KafkaRabbitmq2026}, author = {Pulighe, Mara}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = oct, sort = {technology}, supervisor = {Omicini, Andrea and Matteini, Mattia}, title = {Event-Driven Architectures in Distributed Systems: A Comparative Study of Apache Kafka and RabbitMQ}, type = {Technology Project}, url = {https://github.com/mara-pulighe/KafkaRabbitmq2026}, year = 2026 }
@courseproject{realtimeincidentmanagementdashboard-ds2526, abstract = {This project presents a distributed real-time incident management dashboard designed for collaborative ticket resolution in operational environments. The system enables multiple operators to simultaneously interact with a shared pool of incidents through a web-based dashboard. The architecture follows a three-tier pattern: a Vue.js 3 single-page application serves as the presentation layer, an Express.js API with Socket.IO handles real-time communication and business logic, while a MongoDB Replica Set ensures persistent strongly-consistent state and Redis provides distributed coordination. Key distributed systems patterns implemented include: (i) Redis-based distributed locking and Lua scripts for check-then-act operations, preventing race conditions during ticket assignment; (ii) optimistic locking via document versioning in MongoDB to avoid lost updates during concurrent modifications; (iii) leader election using Redis TTL keys for exclusive execution of background tasks (automatic escalation of stale incidents); (iv) event-driven synchronization of all connected clients without polling, combining MongoDB Change Streams for incident updates with Redis Pub/Sub (via the Socket.IO adapter) for lock and presence events. The entire system is containerized and orchestrated via Kubernetes (validated via Minikube), featuring a 3-node MongoDB StatefulSet for data persistence and failover, Horizontal Pod Autoscaler for the API tier (3--10 replicas), and an Ingress with session affinity.}, apice = {RealTimeIncidentManagementDashboard}, author = {Martini, Alessandro}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = oct, sort = {classic}, supervisor = {Magnini, Matteo and Matteini, Mattia}, title = {Real-Time Incident Management Dashboard}, type = {Standard Project}, url = {https://github.com/AlleMartins/Distributed_Systems_Project}, year = 2026 }
@courseproject{donkeykongrush-ds2425, abstract = {This report presents the "Donkey Kong: Rush" project, realized for the "Distributed System" course at the University of Bologna. The project involves the development of a 2D multiplayer platform video game inspired by the classic Donkey Kong . The system is designed around an Entity-Component-System (ECS) architecture written in Java, utilizing JavaFX for rendering. The main focus of the project is the implementation of smooth multiplayer gameplay. The solution combines the host's authority over the deterministic environment with a reactive handling of local inputs, guaranteeing an experience free of blocking lag for the players.}, apice = {DonkeyKongRush}, author = {Foschi, Giacomo and Terenzi, Mirco}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = oct, sort = {game}, supervisor = {Magnini, Matteo and Matteini, Mattia}, title = {Donkey Kong: Rush}, type = {Game Project}, url = {https://github.com/mircoterenzi/donkey-kong}, year = 2026 }
@courseproject{wizardcardgame-ds2526, abstract = {This project details the evolution of a local, single-player "Wizard" card game into a distributed, real-time multiplayer web application designed for 3 to 6 players. The system transitions the game into a modern distributed application utilizing a Next.js web frontend and a reactive, event-driven Scala 3 backend built on Eclipse Vert.x. Built around Hexagonal Architecture and CQRS principles, the backend completely isolates core game rules from external transport mechanisms and infrastructural concerns. To support distributed gameplay across geographically dispersed users, Redis serves as the Single Source of Truth. It provides fast key-value state persistence, Pub/Sub channels for real-time event broadcasting, and Redis Streams with Consumer Groups to distribute AI bot tasks across dedicated worker instances. Real-time client interactions combine HTTP REST APIs for upstream commands with WebSockets for bidirectional event streaming and in-game chat.}, apice = {WizardCardGame}, author = {Mazzoni, Alex and Graziotin, Nicola and Marcatelli, Francesco}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = oct, sort = {game}, supervisor = {Matteini, Mattia and Magnini, Matteo}, title = {Wizard Card Game}, type = {Game Project}, url = {https://github.com/pallax03/WizardCardGame}, year = 2026 }
@courseproject{thunk-dss2526, abstract = {Thunk is a distributed runtime that evaluates pure functional computations on a cluster of peer nodes, without a central coordinator. Computations are expressed in a small functional language whose only parallel construct is a divide-and-conquer primitive, map and reduce are then built on it. Programs travel between nodes as data, so a node needs no prior knowledge of the programs it helps to run. Work is distributed by randomized work stealing and, since computations are pure, a piece lost with a failed node is simply recomputed by the node waiting for it: crashes are tolerated without replication. It was validated with automated tests on real additional nodes and with experiments on one machine and on two machines connected over the Internet.}, apice = {Thunk}, author = {Baro Carbonell, Yosberto}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = oct, sort = {product}, supervisor = {Magnini, Matteo and Matteini, Mattia}, title = {Thunk}, type = {Product Project}, url = {https://github.com/yosbotnet/thunk}, year = 2026 }
@courseproject{tictactoe-ds2425, abstract = {This report describes the project developed for the 2024-2025 Distributed Systems course called Tic-Tac-Toe. The project consists on a distributed implementation of a variant of the classic multiplayer game Tic-Tac-Toe, in which two players can play against each other, creating a game or joining an existing one. The game consists in the two players placing alternatively their marks on a 3x3 grid; the first player who succeeds in placing three marks in an horizontal, vertical, or diagonal row wins the game. The variant consists in removing a random mark from the grid at each turn, after the third mark of the player has been placed, meaning that every player can have at most three marks on the grid at any time. In this way, there is no possibility of a draw, because the game can potentially last forever.}, apice = {TicTacToe}, author = {Pracucci, Filippo}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = oct, sort = {game}, supervisor = {Magnini, Matteo and Matteini, Mattia}, title = {Tic-Tac-Toe}, type = {Game Project}, url = {https://github.com/FilippoPracucci/Tic-Tac-Toe.git}, year = 2026 }
@courseproject{smartroundaboutorchestrator-dss2526, abstract = {The project consists in a simulation of a CyberPhysical System, wheresome autonomous cars have to coordinate with each other to cross a roundabout, each from its starting point to its destination. Moreover, a centralcontroller is available to give them more efficient commands, trying to maximize the intersection’s throughput while always maintaining safety as thefirst priority. In fact, the main distributed systems challenge concerns thereliability and fault tolerance of the system as a whole: network and performance stability are also important, but failures, assumed to be inevitable,should never result into car accidents. Several measures have been implemented or just theorized in order to prevent deadlocks and starvation, toguarantee liveness, to coordinate together healthy vehicles with unreachableones and to improve controller’s predictions and evaluations in general.An application has also been produced to visualize the simulation in realtime and control it through some commands.}, apice = {SmartRoundaboutOrchestrator}, author = {D'Ugo, Daniele}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = oct, sort = {simulation}, supervisor = {Matteini, Mattia}, title = {Smart Roundabout Orchestrator}, type = {Simulation Project}, url = {https://github.com/papum20/unibo__projects__distributed-smart-roundabout}, year = 2026 }
@courseproject{distributedsmb-ds2526, abstract = {This report presents Distributed SMB, a cooperative real-time 2D platform game inspired by Super Mario Bros, developed to explore the fundamental principles of Distributed Systems within an interactive environment. Up to four players, each on their own machine connected to a local network, take part in the same session and share a single game world, cooperating to complete a level. The game mechanics are intentionally kept simple, so that the difficulty of the project lies in the coordination among the nodes rather than in the game itself. From an architectural perspective, the system adopts a hybrid peer-to-peer model with a dynamically assigned authority. One node acts as the authoritative owner of the shared state and resolves the actions that affect it, while the other nodes anticipate the effect of their own actions locally in order to preserve responsiveness. In CAP terms this design is AP-oriented: it favours availability and low latency over immediate consistency, and relies on the convergence of the replicas over time. The project places a strong emphasis on fault tolerance and availability. Since the authority resides on one of the participating machines, it constitutes a single point of failure: the system therefore detects its failure, elects a successor among the surviving nodes without resorting to any central coordinator, and allows the session to continue, while a node that has failed can later rejoin the session in progress. 1 This report describes the requirements of the system, the architectural decisions and the consistency model adopted, the implementation and deployment choices, the validation carried out, and the limitations that remain open.}, apice = {DistributedSMB}, author = {Badioli, Filippo and Flamigni, Mattia and Nollino, Ludovico}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = oct, sort = {game}, supervisor = {Magnini, Matteo and Matteini, Mattia}, title = {Distributed SMB: a Co-Op Online Platform Game}, type = {Game Project}, url = {https://github.com/LudovicoNollino/Distributed-SMB}, year = 2026 }
@courseproject{dvcsbasedoncvrdt-ds2425, abstract = {This work presents the design and evaluation of a decentralized Distributed Version Control System (DVCS) based on State based Conflict-free Replicated Data Type (CvRDT). The project provides a proof-of-concept about how distributed collaborative approaches can be integrated along DVCS into a peer-to-peer version control environment while preserving eventual consistency and minimizing coordination overhead. Traditional distributed version control systems rely on explicit synchronization and merge procedures to reconcile concurrent modifications performed by multiple users. While these mechanisms provide strong traceability and deterministic history management, they often require manual conflict resolution and assume intermittent coordination between replicas (this is sometime an intended and desiderable behavior, expecially when human control is necessary). In contrast CRDT-based systems are designed to garantee weak-consistency (eventual consistency) automatically, to enable replicas to evolve independently while reaching a single consistent global state. Through ConverGO, we want to demonstrate how CRDT technicques can be successfully used to improve decentralized DVCS systems while also exposing challenge and tradeoff about event causal relations, history management, semantic delivery and system scalability. The resulting software is not to be intended as a real-world production ready library but as a proof-of-concept prototype to provide insight about the applicability of CRDT models in the DVCS context along discussion about its inner limitation and necessary improvoment to make it a working product}, apice = {DvcsBasedOnCvrdt}, author = {Guidi, Stefano}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = oct, sort = {classic}, supervisor = {Magnini, Matteo and Matteini, Mattia}, title = {ConverGO — A DVCS based on CvRDT updates}, type = {Standard Project}, url = {https://github.com/desabuh/ConverGO}, year = 2026 }
@courseproject{aresmascostantini2026-ise2526, abstract = {ARES-MAS is a simulated, grid-based orchestrator designed to manage collaborative planetary exploration through a hybrid symbolic AI architecture. The project addresses the complex challenges of autonomous multi-agent coordination, specifically focusing on dynamic hazard avoidance, spatial pathfinding, and safety-critical resource management. To achieve this, the system enforces a strict architectural separation of concerns. The physical layer, implemented in Kotlin, provides a discretetime 2D spatial simulator that manages environmental state, battery consumption, and mutually exclusive resource locks. The deliberative logical layer encapsulates the system’s intelligence utilizing BDI (Belief-Desire-Intention) agents (Scouts and Harvesters) programmed in Jason and AgentSpeak(L). These autonomous agents communicate via the FIPA Agent Communication Language (ACL). By leveraging the Contract Net Protocol (CNP) for task negotiation, the agents evaluate real-time spatial heuristics (Manhattan distance) to effectively orchestrate task assignment. Crucially, a logic-based safety layer utilizing tuProlog acts as a runtime guardrail, preventing fatal collisions and ensuring fail-safe operations when agents make overoptimistic economic decisions.}, apice = {AresMasCostantini2026}, author = {Costantini, Marco}, howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026}, month = oct, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {ARES-MAS}, type = {Standard Project}, url = {https://github.com/MarcoCostantini26/ARES-MAS}, year = 2026 }
@courseproject{mednet-ise2526, abstract = {MedNet is a two-tier multi-agent system that simulates a medical emergency network: a control centre, a fleet of ambulances and several hospitals that negotiate the admission of each patient among themselves and, internally, the assignment of a doctor. The system integrates BDI agents written in Jason/AgentSpeak, FIPA ACL communication, a generic Contract Net Protocol reused across two levels of negotiation, a tuProlog knowledge base shared between the Java side and the agent side, a STRIPS planner that derives care plans and role-based access control enforced on every environment action. The result is a system in which admissions are arbitrated by the control centre, a critical case can preempt a less urgent treatment and then be replanned while preserving the exams already performed, an ambulance can be rerouted during transport, and mutually exclusive equipment is coordinated by an arbiter with a priority queue and watchdogs.}, apice = {MedNet}, author = {Babini, Pier Costante and Morelli, Marco}, howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026}, month = oct, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {MedNet}, type = {Standard Project}, url = {https://github.com/piertv21/ISE-MedNet}, year = 2026 }
@courseproject{parkingmas-ise2526, abstract = {The goal is to develop a distributed Multi-Agent System using Jason/AgentSpeak for the development and execution of BDI agents, and JADE as the framework for agent communication and distributed deployment. The MAS represents a parking system, in which three roles of BDI agents are present: Driver Agents: autonomously search for a parking spot with specific characteristics, evaluate the proposed alternatives according to their goals and preferences, and decide which parking facility to use; Area Agents: each one is responsible for an area of the city, maintains beliefs about the parking facilities in its area, and provides information to Driver Agents; Parking Agents: represent parking facilities, intended as sets of parking spots, maintain beliefs about their resources (occupied / available spots), and autonomously manage parking requests. The behavior of the MAS is demonstrated through a simulation based on a simplified grid representing a city, in which the aforementioned agents are placed. The environment models the physical aspects of the system, such as the city map, agent positions, and movement, while the decision-making and coordination logic is contained within the agents. Particular attention will be given to the modelling of autonomous behavior in the agents, including the representation of beliefs, goals and plans, agent reasoning and decision-making, and inter-agent communication and coordination. The different agent roles will be designed to exhibit distinct goals, knowledge, and behaviors within the parking system.}, apice = {ParkingMAS}, author = {Bedeschi, Federica}, howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026}, month = oct, sort = {simulation}, supervisor = {Ciatto, Giovanni}, title = {ParkingMAS}, type = {Simulation Project}, url = {https://github.com/BedeschiFederica/ds-ise-parking-mas}, year = 2026 }
@courseproject{bomberman-ds2425, abstract = {Distributed Bomberman is a real-time, fault-tolerant, multiplayer game inspired by the classic Bomberman arcade title, developed as a project for the Distributed Systems course at the University of Bologna (A.Y. 2024/25). Up to four players compete simultaneously on a shared grid, placing bombs to eliminate opponents. An unlimited number of spectators can observe the match and may request to join as a player when a slot becomes available. The system is built on an authoritative client-server architecture fronted by a session-aware TCP proxy, which hides a primary/backup server pair from clients. State is continuously replicated from the primary to the backup; on primary failure, the backup promotes itself automatically, re-binds the game port, and client sessions are restored transparently by the proxy; a second, independent retry loop on the client covers the failure of the proxy itself. The entire system is implemented in Python 3 using the standard library for networking and Pygame for the graphical client.}, apice = {Bomberman}, author = {Rinchiuso, Giovanni and Santi, Gioele}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = sep, sort = {game}, supervisor = {Magnini, Matteo and Matteini, Mattia}, title = {Distributed Bomberman}, type = {Game Project}, url = {https://github.com/Saint138/Distributed-Bomberman}, year = 2026 }
@courseproject{distributedmultiplayerpacman-dss2526, abstract = {This project presents the design and implementation of a multiplayer adaptation of the classic arcade game Pac-Man. At its core, the system adopts a client-server architecture to manage real-time game state synchronization and player inputs. Around this foundation, additional services such as authentication, matchmaking and match results persistence were integrated. Beyond these aspects, the project addresses common distributed systems issues. Specifically, it implements horizontal game server scaling to handle fluctuating player demand, periodic game state checkpointing for match recovery and robust disconnection and reconnection handling.}, apice = {DistributedMultiplayerPacman}, author = {Carpi, Simone and Ronchi, Alessandro and Sun, Jiekai}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = sep, sort = {game}, supervisor = {Magnini, Matteo and Matteini, Mattia}, title = {Distributed Multiplayer Pacman}, type = {Game Project}, url = {https://github.com/MrDorby/distributed-multiplayer-pacman}, year = 2026 }
@courseproject{dsinventorymanager-ds2526, abstract = {This report presents the design, implementation, and validation of a distributed, multi-warehouse inventory management system. Built to operate across a simulated Wide Area Network, the system uses a masterless, peer-to-peer architecture that prioritizes Availability and Partition Tolerance over strict consistency. The core objective is to ensure that local warehouse operators can continuously read and modify stock levels without blocking, even during severe network outages. The backend nodes are implemented in Go and communicate asynchronously via gRPC, utilizing embedded SQLite databases for serverless, lightweight data persistence. In order to guarantee eventual consistency and prevent data loss during split-brain scenarios, the system employs vector clocks for causality tracking and an additive state reconciliation protocol. The infrastructure is containerized using Docker and orchestrated via a local Kubernetes cluster (Minikube). Furthermore, Project Calico is integrated as the Container Network Interface (CNI) to enforce network policies, allowing for rigorous testing of simulated network partitions. The final system successfully demonstrates fault tolerance, automatic state recovery, and mathematical conflict resolution without relying on a central authoritative database.}, apice = {DsInventoryManager}, author = {Cornacchia, Enrico}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = sep, sort = {classic}, supervisor = {Magnini, Matteo and Matteini, Mattia}, title = {Distributed Multi-Warehouse Inventory Manager}, type = {Standard Project}, url = {https://github.com/Icobart/ds-inventory-manager}, year = 2026 }
@courseproject{fractaldistributedfilesystem-ds2425, abstract = {Fractal is a distributed file system designed for large-scale, data-intensive workloads, drawing architectural inspiration from systems like the Hadoop Distributed File System (HDFS) and Google File System (GFS). Fractal adopts a CP (Consistency and Partition Tolerance) model, deliberately prioritizing data integrity and strong consistency over availability by rejecting operations whenever the required quorum or replica counts cannot be safely satisfied. The entire ecosystem is operated via a standalone CLI that exposes commands for file management (create, read, update, and burn) alongside diagnostic utilities such as list and status to monitor cluster health. A centralized NameNode maintains the cluster namespace and replica locations, persisting its state to a lightweight filesystem image, while raw data blocks are distributed across the physical disks of worker DataNodes. Rather than routing payload bytes through the master, Fractal utilizes a distributed pull model: clients query the NameNode solely for a chunk location blueprint, after which all heavy chunk streaming occurs concurrently and directly with the DataNodes to maximize bandwidth utilization. Incoming files are split into fixed-size chunks and distributed using a rack-aware allocation strategy that guarantees multi-rack fault isolation. The system operates under an immutable storage paradigm where file updates generate a timestamped replica set before executing an atomic metadata swap, rather than modifying bytes in place. Continuous heartbeat exchanges and quorum consensus protocols allow Fractal to safely coordinate multi-client concurrency, actively detect dead workers, and transparently repair stale or missing replicas on routine failure.}, apice = {FractalDistributedFileSystem}, author = {Zaccarini, Matteo}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = sep, sort = {classic}, supervisor = {Magnini, Matteo and Matteini, Mattia}, title = {Fractal - Distributed File System}, type = {Standard Project}, url = {https://github.com/MatteoZacca/Fractal}, year = 2026 }
@courseproject{syncnotes-dss2526, abstract = {SyncNotes is a collaborative note-taking system built around a three-tier client-gateway-cluster architecture. A set of shared plain-text notes lives on a cluster of three interchangeable server replicas, the sole source of truth; a lightweight, stateless gateway is the cluster’s single logical entry point, so clients never learn how many replicas exist, which one is serving them, or that a failover happened. The client itself is a full-screen terminal UI requiring no knowledge of commands, note names or file paths, so a non-technical user can browse, edit, create and delete notes with nothing but the arrow keys. The system is deliberately CP in CAP terms. Writes are ordered by a Raft replicated log and applied identically on every replica, so all clients see the same version of every note, and a replica that loses quorum during a network partition refuses writes rather than diverging. Concurrent edits are reconciled by a three-way merge that runs inside the replicated operation itself: disjoint edits are combined automatically, and a directly conflicting line is resolved deterministically in the server’s favour, with the losing client told exactly what happened. On top of consensus, a background reconciliation loop lets a lagging or corrupted replica repair itself from a healthy peer, closing the one gap consensus cannot see: storage-level corruption that never went through the log. The whole cluster, plus the gateway, runs as Docker containers wired by a single compose file; the client runs on the host. Validation combines an automated pytest suite, an end-to-end merge demo against a real cluster, and chaos scripts that kill the leader, partition the network, corrupt a replica’s storage and restart a node, asserting the system recovers exactly as the requirements demand.}, apice = {SyncNotes}, author = {De Maina, Marzia}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = sep, sort = {classic}, supervisor = {Matteini, Mattia}, title = {SyncNotes: A Consistency-Oriented Replicated Store for Collaborative Notes}, type = {Standard Project}, url = {https://github.com/marziademaina/SyncNotes}, year = 2026 }
@courseproject{monopoly-dss2526, abstract = {DS-Monopoly is a distributed clone of the Monopoly board game. It is a simplified version of the game where a centralized server acts as the bank, it coordinates the game and keeps the game state, validates actions, prevents cheating and broadcasts the updates to all the connected clients. The clients are players that can join a game by connecting to the central server (2 to 4 players per game). Players can buy properties or houses, roll dice and see the board and the players information from a GUI. Disconnections from both sides, clients and server, are handled in order to keep the game running. Features like checkpointing, authentication and timeouts, are used to enhance fault tolerance and ensure more reliability and availability.}, apice = {Monopoly}, author = {Loverre, Daniele}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = sep, sort = {game}, supervisor = {Magnini, Matteo and Matteini, Mattia}, title = {DS-Monopoly}, type = {Game Project}, url = {https://github.com/22Daniele/DS-monopoly-clone}, year = 2026 }
@courseproject{dspracticecourt-ds2526, abstract = {DS-PracticeCourt is a distributed web-based platform designed to manage sports facility reservations (such as soccer, tennis, and basketball) and associated services (like lighting, heating, or the possibility of renting equipment). The project focuses on solving the core challenges of distributed environments, such as data consistency, synchronization, high availability, and concurrency in a multi-node environment. The system uses a distributed client-server architecture consisting of a Field Node, acting as the Two-Phase Commit (2PC) coordinator, and a Utility Node serving as a participant. A responsive web client provides real-time interaction through WebSockets, ensuring global state transparency for all users. To ensure a robust and reliable system, several advanced distributed concepts are implemented: Concurrency & Distributed Locking: Exploiting Redis to implement distributed locks, ensuring that a single time slot cannot be double-booked by simultaneous requests. Atomic Transactions (2PC): A Two-Phase Commit protocol coordinates Field and Utility nodes. This ensures that a booking that includes both a field and a service is treated as an atomic unit. Temporary Slot Locking: Selected slots are temporarily reserved with a timeout mechanism, releasing the resource if the user does not confirm the booking. Real-Time Synchronization: Using WebSockets to push instant availability updates to all connected users, maintaining a consistent global state.}, apice = {DSPracticeCourt}, author = {Brighi, Federico}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = sep, sort = {application}, supervisor = {Matteini, Mattia and Magnini, Matteo}, title = {DS-PracticeCourt}, type = {Application Project}, url = {https://github.com/fedebrighi/DS-PracticeCourt}, year = 2026 }
@courseproject{cotype-ds2526, abstract = {CO-Type is a distributed client server cooperative typing game. The main idea of the project is to build a robust and scalable system, with error recovery and state reconstruction from partial and potentially inconsistent data. The system is composed of a broker, which is the only endpoint known by the clients at startup, and multiple servers. There is no upper limit for the number of servers that can be used. The number of servers does not have to be defined, and new servers can be created at any moment. The game is designed to recover from client, server or broker crashes while having near zero downtime. If a client crashes during game, then the session is paused. If the broker crashes, then all the knowledge it had is reconstructed. If a server crashes, all the lobbies are transferred to a different server.}, apice = {CoType}, author = {Ceredi, Simone}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = aug, sort = {game}, supervisor = {Matteini, Mattia}, title = {Co-Type}, type = {Game Project}, url = {https://github.com/sceredi/co-type}, year = 2026 }
@courseproject{ecoshield-ise2526, abstract = {EcoShield-MAS is a lightweight hybrid intelligent system for coordinating Scout and Fighter unmanned aerial vehicles in a discrete forest-fire environment. The system combines a collaborative Belief-Desire-Intention (BDI) loop, Prolog-style declarative policy guardrails, and STRIPS-inspired logistics planning. Fire evolves through a wind-influenced cellular automaton, while environmental policy prohibits chemical action in protected habitat and under high-wind conditions. A Streamlit dashboard exposes the operational map, agent cognition, policy proofs, and causal event traces. Four deterministic experiments evaluate baseline response, high-wind safety, protected-zone safety, and low-resource return-to-base planning. The final traces confirm 26 extinguishing actions in the baseline mission, correct blocking of all tested unsafe chemical actions, and successful STRIPS return with full resource restoration at tick 13.}, apice = {EcoShield}, author = {Kuang, Yi}, howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026}, month = aug, sort = {simulation}, supervisor = {Ciatto, Giovanni}, title = {EcoShield}, type = {Simulation Project}, url = {https://github.com/leahkuang/EcoShield-MAS}, year = 2026 }
@courseproject{kompozer-ds2425, abstract = {Kompo is a company that produces customizable modular furniture. Its catalog is organized into four product categories—Tondo, Quadro, Intelligente and Kube—which are not compatible with one another but share similar features, so that the logic for composing components stays homogeneous within each category. In the current purchasing process, customers must select the individual components on their own, already having a clear idea of the final result; this is complex and requires the knowledge of the product, forcing them to rely on the support of the company. KompozeR wants to make this process easier by letting customers interactively design and purchase modular shelving units through a visual configurator (CAD) that composes a product in an intuitive way avoiding incompatible combinations, keeps price and availability aligned with the catalog in real time, and notifies users when a saved configuration is affected by catalog changes. The system is built as a web application using the stack MEVN (MongoDB, Express, Vue.js, Node.js) and is deployed as a hexagonal architecture. Services communicate through synchronous REST for commands and queries, asynchronous Redis pub/sub for domain events (price and availability changes), and Socket.IO for real-time delivery of notifications and chatbot messages. Socket.IO also enables a collaborative configuration mode, where multiple users can work on the same shelving unit at the same time and see each other’s changes in real time. To keep the core configuration workflow available even under failures, the data is stored on a MongoDB replica set that provides replication and automatic failover, so that the loss of a single node does not interrupt the service. The whole system can be deployed both with Docker Compose for local development and on Kubernetes, which handles scaling, health checks and self-healing of the running services.}, apice = {KompozeR}, author = {Giannini, Valerio}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = aug, sort = {application}, supervisor = {Magnini, Matteo}, title = {KompozeR}, type = {Application Project}, url = {https://github.com/VG-University/KompozeR}, year = 2026 }
@courseproject{urbandeliverymas-ise2425, abstract = {This report presents the architectural design, formal cognitive logic, and practical implementation of UrbanDeliveryMAS, a fully decentralized Multi-Agent System (MAS) designed to address dynamic, priority-aware last-mile logistics without reliance on a centralized routing authority or shared global locks. Operating on a discrete 10 ×10 micro-city grid topology, the system coordinates autonomous BDI (Belief-Desire-Intention) agents—comprising a central Distribution Hub and three delivery drones—negotiating task allocation via an extended Contract-Net Protocol (CNP). Agent cognitive architectures are developed in AgentSpeak(L) and executed using the Jason 3.3.0 interpreter running on Java 21. The system’s adaptive capacity is evaluated across three core operational edge cases: (1) proximitydriven spatial task division, (2) belief-triggered intention dropping and re-delegation during critical battery depletion, and (3) real-time task preemption following the mid-transit injection of high-priority Express orders. Experimental validation demonstrates 100% task completion (7/7 orders delivered) with zero unhandled goals or synchronization deadlocks. The results confirm that localized BDI deliberation paired with asynchronous message passing produces robust, self-organizing, and highly adaptive global fleet behavior.}, apice = {UrbanDeliveryMAS}, author = {Lajani, Arvin}, howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025}, month = jul, sort = {simulation}, supervisor = {Ciatto, Giovanni}, title = {Urban Delivery MAS}, type = {Simulation Project}, url = {https://github.com/ArvinLajani/urban-delivery-mas}, year = 2026 }
@courseproject{mapforger-ds2526, abstract = {MapForger is a distributed microservice-based platform designed for realtime 2D tabletop role-playing game (RPG) management. The system is architected to handle complex campaign logic, character persistence, and live session synchronization across multiple players. Unlike a monolithic game server, the application logic is decomposed into specialized services—Core and Gameplay—coordinated via Spring Cloud Eureka for service discovery and routed through a Spring Cloud Gateway. The project focuses on ensuring a consistent and resilient experience during gameplay sessions. The CAP Theorem trade-off is explicitly addressed: the system prioritizes Consistency over Availability within a single session, ensuring that no two actors can occupy the same map tile and that every action is atomically persisted before being broadcast. Fault tolerance is implemented through persistent state: every actor position, attack, and death event is recorded as an immutable row in PostgreSQL 17. Upon reconnection after a crash, the client re-fetches the full game state from the database, enabling seamless session recovery without data loss. Inter-service communication is handled via OpenFeign clients registered through Eureka, allowing the Core service to retrieve live session data from Ga}, apice = {MapForger}, author = {Alexandru, Eduard Toni}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jul, sort = {game}, supervisor = {Magnini, Matteo}, title = {MapForger}, type = {Game Project}, url = {https://github.com/eduardalexandrut/MapForger}, year = 2026 }
@courseproject{chefsync-ise2526, abstract = {ChefSync is a simulated, grid-based orchestrator designed to manage highly concurrent culinary environments through decentralized multi-agent coordination. The project addresses the complex challenges of modern restaurant kitchens, specifically focusing on dynamic workload balancing, spatial pathfinding, and the resolution of physical resource conflicts. To achieve this, the system enforces a strict architectural dichotomy. The physical layer, implemented in Java, provides a discrete-time 2D spatial simulator that manages environmental state, hardware constraints (workstations), and mutually exclusive resource locks. The logical layer encapsulates the system’s intelligence utilizing BDI (Belief-Desire-Intention) agents programmed in Jason and AgentSpeak(L). These autonomous agents—acting as Waiters, Head Chefs, and Station Chefs—communicate via the FIPA Agent Communication Language (ACL). By leveraging the ContractNet Protocol (CNP) for task negotiation, the agents evaluate real-time spatial heuristics and operational availability to effectively orchestrate the decomposition, assignment, and execution of unpredictable order streams.}, apice = {ChefSync}, author = {Fantilli, Giorgio}, howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026}, month = jul, sort = {simulation}, supervisor = {Ciatto, Giovanni}, title = {ChefSync}, type = {Simulation Project}, url = {https://github.com/GiorgioFantilliUnibo/chefsync-mas}, year = 2026 }
@courseproject{distributedadaptivecitytrafficsystem-ds2526, abstract = {ACTS is an advanced, agent-based smart city simulation focused on decentralized intersection management. Built in Python using the Mesa multiagent framework and NetworkX, the project models dynamic urban traffic flow where intersections operate autonomously without a central command server. At the core of the project is a procedural topology generator that constructs a directed graph representing a realistic road network, complete with external arterial roads and complex internal turning lanes. The simulation features two primary entities: Vehicle Agents that navigate the network, and Smart Traffic Light Agents deployed at intersection nodes. Instead of relying on rigid, pre-programmed timers, the smart traffic lights utilize a distributed consensus algorithm to negotiate the ”GREEN” state. Each agent continuously monitors its local environment, detecting queued vehicles, calculating waiting times, and receiving messages about incoming traffic waves from neighboring nodes. Based on this telemetry, each traffic light calculates a dynamic priority score. To ensure physical safety and prevent collisions, the system implements Signal Phasing (conflict matrices). Traffic lights communicate their scores and intentions through a distributed messaging channel, utilizing Lamport clocks for event synchronization. Agents assigned to non-conflicting trajectories (identical phases) can concurrently grant themselves permission to turn green. Conflicting requests are dynamically resolved by comparing real-time traffic scores and enforcing minimum safety durations. Ultimately, ACTS serves as a robust sandbox for testing distributed systems architectures, agent-based modeling, and modern traffic optimization algorithms in a highly reactive urban environment.}, apice = {DistributedAdaptiveCityTrafficSystem}, author = {Morsucci, Federico and Morbidelli, Cristian}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jul, sort = {simulation}, supervisor = {Magnini, Matteo}, title = {Autonomous City Traffic Simulation}, type = {Simulation Project}, url = {https://github.com/Morsu7/acts-project}, year = 2026 }
@courseproject{distributedlupusinfabula-ds2526, abstract = {Distributed Lupus in Fabula is a real-time multiplayer web application that brings the classic social deduction game Lupus in Fabula online, allowing groups of players to create or join a game lobby from any browser and play a full match together over the internet. The system is composed of a Vue 3 single-page frontend and a FastAPI/Socket.IO backend, communicating via REST for stateless operations and via WebSocket for real-time, low-latency interactions such as votes, phase transitions, and private role actions. Game and lobby state is kept in Redis rather than a traditional database, acting both as a shared source of truth across backend replicas and as a Pub/Sub broker that lets events generated on one instance reach clients connected to any other instance. This design allows the backend to run as multiple concurrent, interchangeable replicas behind a reverse proxy, supporting many simultaneous matches while keeping every player’s view of the game synchronized in real time.}, apice = {DistributedLupusInFabula}, author = {Vorabbi, Leonardo and Bonifazi, Jacopo and Nicolescu, Alexandru Bogdan}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jul, sort = {game}, supervisor = {Magnini, Matteo}, title = {Distributed “Lupus in Fabula”}, type = {Game Project}, url = {https://github.com/AlexandruNicolescu00/distributed-lupus-in-fabula}, year = 2026 }
@courseproject{distributedneuraltrainingsimulation-ds2526, abstract = {Distributed Neural Training Simulation (DNTS) is a software framework designed to simulate, analyze, and visualize the training process of Deep Neural Networks (DNN) in a fully decentralized Peer-to-Peer (P2P) environment. Traditional distributed machine learning typically relies on centralized architectures, such as Parameter Servers, which inherently introduce a Single Point of Failure (SPOF) and potential network bottlenecks. DNTS overcomes these limitations by implementing an asynchronous, leaderless architecture based on the Gossip Learning protocol. Within this framework, autonomous nodes process local data partitions and iteratively exchange model weights with randomly selected peers to achieve global consensus and model convergence. Developed entirely in Scala 3 utilizing the Actor Model (via Akka Cluster) and strict Pure Functional Programming principles.}, apice = {DistributedNeuralTrainingSimulation}, author = {Colletta, Lorenzo and Giacobbi, Francesco Domenico and Fantilli, Giorgio}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jul, sort = {advanced}, supervisor = {Magnini, Matteo}, title = {Distributed Neural Training Simulation}, type = {Advanced Project}, url = {https://github.com/GiorgioFantilliUnibo/DNTS}, year = 2026 }
@courseproject{chameleontable-ds2526, abstract = {Chameleon Table is a distributed multiplayer card game inspired by Coloretto, developed as a final project for the Distributed Systems course. The application allows between 2 and 5 players to join a shared game room from different devices and play in turns, with one active game per authenticated user. The system follows a client-server architecture: a central FastAPI server manages game logic and state, while clients interact through a React single-page application running in the browser. Real-time updates are pushed to all connected clients via WebSocket, ensuring that every player sees the current state of the game without polling. Game state is persisted in a PostgreSQL database, so that active games survive server restarts and players can reconnect within a grace period. The full system is containerised with Docker and starts with a single command. Key distributed systems challenges addressed include crash recovery, real-time state synchronisation across multiple clients, and safe concurrent access to shared game state.}, apice = {ChameleonTable}, author = {La Rosa, Andrea}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jul, sort = {game}, supervisor = {Magnini, Matteo}, title = {Chameleon Table}, type = {Game Project}, url = {https://github.com/AndreaLaRosa1983/chameleon-table}, year = 2026 }
@courseproject{adriabox-ds2526, abstract = {This report details the comprehensive architectural design, theoretical constraints, and operational mechanisms of AdriaBOX, a resilient, decentralized object storage system engineered over a multi-tenant cluster environment. AdriaBOX natively addresses the core challenges of distributed computing by separating high-performance binary transport protocol engines from global metadata orchestration. By employing a customized application-layer framed TCP streaming layer alongside a synchronous pipeline replication cascade, the system isolates fault domains, prevents resource starvation via strict boundary memory footprinting, and implements Zero-Knowledge client-side encryption. Crucially, to validate system behavior under realistic execution stresses, a multi-containerized emulation workspace is leveraged. This environment allows the simulation of concurrent, fully isolated tenant workspaces interacting across a virtualized network plane, proving that horizontal capacity scaling and hardware-level fault tolerance can be sustained without compromising strong sequential data consistency under severe network disruption.}, apice = {AdriaBox}, author = {Buzi, Sajmir and Pupillo, Massimiliano}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jul, sort = {advanced}, supervisor = {Magnini, Matteo}, title = {AdriaBOX}, type = {Advanced Project}, url = {https://github.com/Wearemassive78/AdriaBOX}, year = 2026 }
@courseproject{federatedskillshare-dss2526, abstract = {Skillshare is a peer-to-peer platform in which users exchange knowledge by publishing skill announcements, requesting exchanges, communicating through chat, and reviewing one another. The original application used one server and one MapDB database. This project transforms it into a federated distributed system demonstrated through two local Docker instances, each with independent users and persistent state. Instances exchange domain events through HTTP using JSON representations and identify users as user@instance. Selected data concerning announcements, exchange requests, chat messages, and reviews is replicated asynchronously. Local operations remain available when a peer is unreachable, while a persistent outbox, manual and automatic retries, stable event identiers, and a processed-event inbox ledger support eventual consistency and idempotent handling. Federated chat uses persistent Lamport logical clocks to obtain a causality-compatible deterministic ordering without depending on synchronized physical clocks. Reviews are propagated to the reviewed user's home instance and contribute to local reputation. The prototype therefore provides a concrete study of federation, replication, partial failure, recovery, logical time, and the trade-o between availability and immediate consistency.}, apice = {FederatedSkillshare}, author = {Vigil Bravo, Jorge and González Menéndez, Yeray}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = jul, sort = {classic}, supervisor = {Matteini, Mattia}, title = {Federated Skillshare}, type = {Standard Project}, url = {https://github.com/yerayyay-27/federated-skillshare}, year = 2026 }
@courseproject{aiadmissionagent-, abstract = {This project implements a domain-bounded conversational assistant for prospective students who need practical guidance about applying to Italian universities and handling adjacent study procedures such as student visas, residence permits, scholarships, and admission documents. The system is exposed primarily through Telegram, but its internal design is split into a Go bot layer and a Python retrieval service. The Go layer handles Telegram updates, access control, optional Redis-backed conversation memory, and optional event publication. The Python service performs guardrail checks, intent classification, retrieval-query clarification, document search, grounded answer generation, and attachment-handling logic. The repository shows a deliberate attempt to keep the assistant narrow in scope. Queries related to study abroad in Italy are routed toward retrieval over a curated document corpus, while unrelated or unsafe requests are refused before answer generation. The corpus itself is practical rather than encyclopedic: it contains visa, residence-permit, DSU scholarship, CV, motivation-letter, and recommendation-letter material in English, Russian, and partly Kazakh, which indicates a multilingual support goal for applicants who may not be comfortable using only English or Italian. The main contribution of the project is not a novel model, but an end-to-end engineering design that combines access-controlled messaging, document-grounded assistance, lightweight conversation memory, and operational tooling for dataset refresh and administration. At the same time, the repository also reveals important limits: the corpus is narrow, official procedures are time-sensitive, and the system depends on careful prompt design and retrieval quality to remain reliable. For that reason, the assistant is best understood as an informational support tool rather than a legal or institutional authority.}, apice = {AIAdmissionAgent}, author = {Rakymzhan Zhabagin and Adilet Zhumabay}, month = jul, sort = {advanced}, supervisor = {Ciatto, Giovanni}, title = {AI Admission Agent}, type = {Advanced Project}, url = {https://github.com/qonstant/distributed-agent}, year = 2026 }
@courseproject{haochi-ds2526, abstract = {This project aims to implement a distributed real-time multiplayer game inspired by Family Sytle, where 2 to 8 players cooperate in a shared virtual kitchen to prepare recipes under time constraints. Players join a game session through a room system: one player creates a room and receives a unique code that others use to enter the same match and participate in a synchronized environment.}, apice = {Haochi}, author = {Yan, Elisa and Malagoli, Anna}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jul, sort = {game}, supervisor = {Magnini, Matteo}, title = {Haochi - Cook&Pass}, type = {Game Project}, url = {https://github.com/elisayan/haochi-cook-and-pass}, year = 2026 }
@courseproject{ultimatefightinggame-ds2526, abstract = {UFG is a small distributed 2D fighting game built to explore a hard real-time problem: keeping two machines in agreement while both players expect immediate input response. The project combines a desktop game client, an authentication service, a signaling service, and a direct peer-to-peer gameplay channel. The main contribution is the match architecture. During a fight, there is no authoritative game server. Each client runs the same deterministic simulation and exchanges only player inputs through a WebRTC data channel. Rollback netcode absorbs late inputs by rewinding and replaying local state, while committed-frame hashes detect cases where the two simulations diverge. The backend services are intentionally modest. Authentication stores accounts and issues session tokens. Signaling pairs players and relays WebRTC setup messages, then leaves gameplay traffic to the peers. This keeps the distributed system focused on the central consistency and latency problem rather than on a large online platform. The report first defines the product boundary and requirements, then explains the design, implementation, validation, deployment, and player-facing workflow. It ends with future work and self-evaluation, including the parts intentionally left outside the submitted scope.}, apice = {UltimateFightingGame}, author = {Paradisi, Giovanni and Samite, Mounir}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jul, sort = {game}, supervisor = {Magnini, Matteo}, title = {Ultimate Fighting Game}, type = {Game Project}, url = {https://github.com/giovihey/UFG}, year = 2026 }
@courseproject{veritrace-ise2526, abstract = {Veritrace was built around a practical question: if an LLM can draft useful rules from text, how canthose rules enter a runtime system without becoming hidden, unreviewed behavior? The answer inthis prototype is a gated pipeline. The LLM drafts, the human reviews, the backend promotes andvalidates, and Jason performs the runtime reasoning.The review console supports two small demo areas. The Cardiac path is the main authoring demo:it has a prepared CMR Mass Score source, claim, and candidate rule for the fast walkthrough, andit can also be used through the live LLM pipeline. GDPR is stronger on the runtime side: it hasapproved rules, approved plan artifacts, benchmark cases, and expected traces for compliancescenarios such as missing legal basis, special-category processing, and late breach notification.At runtime, Veritrace returns a trace with the decision, risk, activated rules, evidence, missing data,source identifiers, human-review flags, and planner-generated next steps. The LLM can be usedagain at the end to turn this trace into a readable explanation, but it receives only the trace andselected source snippets. The trace remains the source of truth.The result is not meant to be a production compliance or medical tool. It is an exam prototypeshowing how LLM-assisted authoring, human review, symbolic execution, and trace inspection canbe connected in one reproducible local workflow.}, apice = {Veritrace}, author = {Leoni, Lorenzo}, howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026}, month = jul, sort = {technology}, supervisor = {Ciatto, Giovanni}, title = {Veritrace}, type = {Technology Project}, url = {https://github.com/LoryBug/Veritrace}, year = 2026 }
@courseproject{agentofrivia-ise2425, abstract = {This project is a fantasy creature hunting simulation inspired by The Witcher. The environment consists of a grid-based world where a Hero agent hunts and defeats enemy agents. Battles are triggered when the Hero encounters enemies in neighboring cells, and each victory allows the Hero to improve both health and strength. The simulation includes a health recovery area and tracks the number of Hero deaths. The system is implemented in Java, with agent behaviors programmed in Jason and a graphical interface developed using Java.}, apice = {AgentofRivia}, author = {Alhammadi, Shaikha and Chukarin, Igor}, howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025}, month = jul, sort = {simulation}, supervisor = {Ciatto, Giovanni}, title = {Agent of Rivia}, type = {Simulation Project}, url = {https://github.com/Intelligent-Systems-Engineering-Team/Agent-of-Rivia/}, year = 2026 }
@courseproject{yahrperlika2026-ise2526, abstract = {YAHR is a command-line tool that acts as your personal career co-pilot. It reads your resume, searches for relevant job openings, scores them against your profile, and tells you exactly how to improve your CV to maximize your chances — all from the terminal. Built on the A2A Protocol (an open standard for agent-to-agent communication), YAHR is composed of four specialized agents that work together under a single orchestrator: Job Searcher Agent — queries web search APIs to discover open positions matching your background Matching/Ranker Agent — parses your CV into a structured profile and scores each job against it CV Assistant Agent — analyzes the gaps between your profile and the top-ranked jobs, then gives you concrete suggestions to strengthen your resume Orchestrator Agent — ties everything together and exposes the full workflow through an intuitive CLI interface The whole system is written in Python. The CLI is built with Typer + Rich for colored, structured output. Each agent's reasoning comes from an LLM, accessed through OpenRouter so the system stays model-agnostic. Architecturally, each agent is a standalone HTTP server, not a module inside one program.}, apice = {YahrPerlika2026}, author = {Perlika, Elvis}, howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026}, month = jul, sort = {classic}, supervisor = {Omicini, Andrea}, title = {YAHR -- Yet Another HR}, type = {Standard Project}, url = {https://github.com/elvisperlika/YAHR}, year = 2026 }
@courseproject{aeroguard-ise2526, abstract = {AeroGuard-MAS is a simulated multi-agent airspace conflict management system. Its goal is to model how intelligent agents can detect potential aircraft conflicts, reason about safety constraints, generate resolution plans, apply corrective maneuvers, and explain their decisions. The system addresses a simplified version of a real airspace management problem: multiple aircraft move through a shared sector while maintaining horizontal and vertical separation. When aircraft trajectories create a current or future loss of separation, the system must detect the unsafe situation and select an appropriate corrective action.}, apice = {AeroGuard}, author = {Testa, Alex}, howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026}, month = jun, sort = {simulation}, supervisor = {Ciatto, Giovanni}, title = {AeroGuard-MAS}, type = {Simulation Project}, url = {https://github.com/AlexTesta00/aeroguard-mas}, year = 2026 }
@courseproject{masavpredictivemaintenance2026-ise2425, abstract = {This report presents the design, implementation, and evaluation of a Multi-Agent System (MAS) for autonomous vehicle predictive maintenance that unifies three graduate courses of the University of Bologna’s Master’s programme in Computer Science and Engineering: Machine Learning and Data Mining (Codice 95631), Distributed Systems (Codice 87474), and Embedded Systems and IoT (Codice 77780). The system demonstrates how three seemingly independent technical domains combine to solve a real automotive problem: keeping a distributed fleet healthy while minimising unplanned downtime and emergency repair costs. At the edge, ESP32 telematics devices collect sensor data, derive ECDSA signatures from each vehicle’s VIN, and publish authenticated telemetry over MQTT, with a dedicated Arduino controller acting as a hardware authentication gateway. A permissioned Hyperledger Fabric network of five peer nodes provides Byzantine fault-tolerant, immutable storage for telemetry and service records, sequencing transactions through a Raft ordering service. A Random Forest classifier trained on 50,000 vehicle records predicts maintenance needs with high accuracy and exposes feature-importance reasoning for explainability. Above these three layers, a Jason AgentSpeak multi-agent system coordinates vehicles, service centres, and a fleet coordinator through stigmergy-based signalling and consensus-validated agreements. The integrated system targets an 80% reduction in unplanned downtime and an estimated saving of €165,800 per 10,000 vehicles annually (€16.58 per vehicle). This document also details the Service Center Agent contribution, Mary Anne Selirio, framed as a capacity-focused resource manager that tracks technician availability and parts inventory, allocates service slots in response to fleet booking pressure, and logs immutable service records to the blockchain.}, apice = {MasAvPredictiveMaintenance2026}, author = {Katrenov, Dias and Khayatian, Danial and Selirio, Mary Anne}, howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025}, keywords = {Multi-Agent Systems, Predictive Maintenance, Stigmergy, Byzantine Fault Tolerance, Hyperledger Fabric, Raft Consensus, Random Forest, ESP32, ECDSA, MQTT, Jason, AgentSpeak, Intelligent Embedded Systems.}, month = jun, sort = {classic}, supervisor = {Omicini, Andrea}, title = {A Multi-Agent System for Autonomous Vehicle Predictive Maintenance: Integrating Machine Learning, Distributed Ledger Consensus, and Embedded IoT Telematics}, type = {Standard Project}, url = {https://github.com/Dias266/Multi-Agent-System-for-Autonomous-Vehicle-Predictive-Maintenance}, year = 2026 }
@courseproject{distributedbattleshipgame-ds2526, abstract = {The project consists of a simple, distributed battleship game where two users place their ships on a grid, and the first to sink the opponent’s fleet wins. A distributed architecture is employed, utilizing a peer-to-peer model for communication between the two players during the match, and a client-server model to enable both user matchmaking and the registration of backup servers with the primary server. This registration allows backup servers to receive constant state updates from the primary server, ensuring they are ready to take its place if it becomes unreachable.}, apice = {DistributedBattleshipGame}, author = {Viola, Leonardo}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jun, sort = {game}, supervisor = {Magnini, Matteo}, title = {Distributed Battleship}, type = {Game Project}, url = {https://github.com/leonardo284/Distributed-Battleship}, year = 2026 }
@courseproject{scopa2-ds2526, abstract = {Scopa2 is an online two-player card game: a variant of the Italian Scopa Scientifica extended with a card-mutation mechanic based on Santi, playable through a native desktop client. Behind the game there is a deliberately distributed back end: two symmetric regions (Europe and North America)run the same stack on Kubernetes, the client picks the closest region by measuring latency at startup, and every component is replicated so that the death of a pod, of a database node, or even of an entire region does not interrupt a match. The two core ideas of the design are (1) modelling each match as an event-sourced deterministic state machine, so that any server can rebuild any game by replaying its move log, and (2) delegating the hard coordination problems (consensus, leader election, failover) to infrastructure that already solves them: YugabyteDB for Raft-replicated storage, Redis Sentinel for the cache and pub/sub tier, Kubernetes for scheduling and scaling. The report explains the design, the consistency trade-offs we made (CAP/PACELC), and how we validated the system with fault-injection tests on the live deployment.}, apice = {Scopa2}, author = {Coppola, Marco and De Nicola, Valerio Pio}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jun, sort = {game}, supervisor = {Magnini, Matteo}, title = {Scopa2: A Geo-Distributed Multiplayer Game}, type = {Game Project}, url = {https://github.com/Scopa2/scopa2-backend}, year = 2026 }
@courseproject{marafonet-ds2526, abstract = {In this report we document the concept, design and testing of MarafoNet, a digitalised version of Marafone a traditional card game from Italy. The system’s design is focused on distribution as its main aspect, elicitating the benefits that this approach brings and defining requirements to be satisfied both for distribution and user-related. The features of the game are explained and modeled in an architecture coherent with the requirements cited. Security and scalability issues are addressed. Implementation strategies and integration between technologies are shown to achieve requirements and the architecture planned. Finally, tests are displayed to verify the correctness of the system’s operations as well as the insfrastructure components used. A guide will help the user deploy, use the system and understand the rules of the game.}, apice = {MarafoNet}, author = {Bagattoni, Federico and Turchi, Jacopo}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jun, sort = {game}, supervisor = {Magnini, Matteo}, title = {MarafoNet, Marafone on the net}, type = {Game Project}, url = {https://github.com/juturbo/MarafoNet}, year = 2026 }
@courseproject{pixie-ds2526, abstract = {Pixie is a collaborative platform for creating pixel art in real time. Multiple users interact simultaneously on the same digital canvas, cooperating on the creation of a shared drawing through an interactive web interface. The application is designed as a Single Page Application (SPA) whose central element is a grid of pixels whose state is kept consistent and updated for all connected clients, enabling a uniform view of the drawing in progress. The system follows a three-tier architecture comprising a Vue.js frontend, a Node.js/Express backend, and a MongoDB database. Real-time synchronisation relies on Socket.IO for bidirectional communication and Server-Sent Events (SSE) for push notifications. To support horizontal scalability and fault tolerance in a distributed deployment, the architecture integrates Redis as a shared state store and pub/sub message broker, Traefik as a load-balancing reverse proxy, and a coordination service that uses distributed locking to safely persist canvas data from any server instance.}, apice = {Pixie}, author = {Susca, Matteo and Zavatta, Andrea}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jun, sort = {classic}, supervisor = {Magnini, Matteo}, title = {Pixie - Collaborative Pixel Art Platform}, type = {Standard Project}, url = {https://github.com/pixie-git/pixie}, year = 2026 }
@courseproject{faulttolerantdistributedminesweeper-dss2526, abstract = {We built a cooperative, distributed Minesweeper game. But instead of relying on an external database to keep things in sync, we designed an in-memory Replicated State Machine (SMR) from scratch. Using pure Python TCP sockets, the architecture enforces Strong Consistency across a three-node cluster through a two-phase PREPARE/COMMIT chain replication protocol. If the leader dies, the cluster recovers automatically. We fully containerized the entire stack—even the graphical Tkinter client—proving that complex fault tolerance and deterministic state can work without heavy-weight dependencies.}, apice = {FaultTolerantDistributedMinesweeper}, author = {Maire Bravo, Nicolás and López Lamas, Iago}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = jun, sort = {game}, supervisor = {Matteini, Mattia}, title = {Fault-Tolerant Distributed Minesweeper}, type = {Game Project}, url = {https://github.com/nico-maire/distributed-minesweeper}, year = 2026 }
@courseproject{energyconsumptionoptimizer2026-ds2324, abstract = {ECO is a distributed, microservices-based web platform for real-time monitoring and optimization of household utility consumption (electricity, gas, water). The system ingests telemetry from network-connected smart hookups, stores measurements in a time-series database, and exposes live dashboards, historical analytics, consumption forecasts, and configurable threshold alerts. Seven independently deployable services, derived from DDD bounded contexts, communicate through a Kafka-backed event-driven pipeline with transactional outbox, inbox deduplication, and dead-letter queues, achieving effectively—once processing and fault-tolerant data propagation. The Monitoring service maintains a Redis cache of measurement tags, hookup metadata, user existence, and zone mappings, kept consistent via Kafka domain events; on broker unavailability the system falls back to direct inter-service HTTP calls, with hookup ID misses always triggering a re-query to prevent measurement loss. The entire stack is containerized and deployed via Docker Compose on a single machine.}, apice = {EnergyConsumptionOptimizer2026}, author = {Bennici, Salvatore and Vasiliu, Rares}, howpublished = {Distributed Systems, A.Y. 2023/2024}, month = jun, sort = {application}, supervisor = {Magnini, Matteo}, title = {Energy Consumption Optimizer}, type = {Application Project}, url = {https://github.com/orgs/EnergyConsumptionOptimizer/}, year = 2026 }
@courseproject{wineshop2026-ds2526, abstract = {This report describes the design and implementation of an e-commerce platform for wine sales built following a microservices architecture. The system is composed of seven independent services — users, catalog, inventory, cart, orders, and payments — coordinated by an API gateway and communicating via RabbitMQ as a message broker. The main objective of the project is to address two fundamental challenges of distributed systems: managing transactions that span multiple services without global ACID transactions, and maintaining the consistency of a distributed cache. The first challenge is solved through the implementation of the Saga Pattern in choreographed style, where services react to events published on a RabbitMQ topic exchange without a centralized orchestrator. The second is addressed through Redis, used both as a cache layer for the catalog and for temporary persistence of guest user carts, with asynchronous key invalidation when the underlying data changes. User authentication is handled via JSON Web Tokens, while payments are delegated to Stripe with cryptographic verification of incoming webhooks. The entire system is containerized with Docker Compose, which manages the lifecycle of all infrastructure components including six PostgreSQL databases, RabbitMQ, and Redis.}, apice = {WineShop2026}, author = {Savoca, Giovanni Maria and Valentini, Enrico}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jun, sort = {application}, supervisor = {Magnini, Matteo}, title = {WineShop: E-Commerce Platform for Wine Sales with Microservices Architecture and Distributed Transactions}, type = {Application Project}, url = {https://github.com/Giosc4/DSS_wineWebSite}, year = 2026 }
@courseproject{lastbite-ds2425, abstract = {Food waste represents one of the most significant sustainability challenges worldwide, with large quantities of edible products discarded daily across the food supply chain. Restaurants and food service activities contribute substantially to this issue, especially through unsold products remaining at the end of the day. This report details the design and implementation of LastBite, a distributed web application designed to mitigate food waste by enabling restaurants to sell surplus products at the end of the day. The project is built on top of the MEVN (MongoDB, Express.js, Vue.js, Node.js) stack and orchestrated using a Docker-based approach to ensure scalability and isolation. The system comprises multiple containerized services, including two backend instances, a Vue frontend, a MongoDB replica set, a Redis database for distributed locking and an Nginx reverse proxy for load balancing and fault tolerance. Furthermore, LastBite implements several security features required by the application domain, such as secure authentication, password hashing, Role-Based Access Control (RBAC) and distributed locks for handling product purchases and modifications. The system offers dedicated interfaces for restaurants, which manage products and orders, and for customers, who can search for nearby restaurants using geospatial filtering. Finally, the application also includes real-time notifications and an AI-powered “Food Advisor” assistant.}, apice = {LastBite}, author = {Babini, Pier Costante and Morelli, Marco}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = jun, sort = {application}, supervisor = {Magnini, Matteo}, title = {LastBite}, type = {Application Project}, url = {https://github.com/piertv21/LastBite}, year = 2026 }
@courseproject{roddit-ds2526, abstract = {This project consists of a social-network-like web application developed from scratch, taking inspiration from similar products available on the market, such as Reddit, to tackle the usual problems of distributed services. In addition, we containerized the application using Kubernetes to increase its resilience to common runtime problems and added tools such as Grafana and Chaos Mesh to monitor, control, and manage its execution.}, apice = {Roddit}, author = {Babbi, Giovanni and Filippo Di Pietro}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jun, sort = {classic}, supervisor = {Magnini, Matteo}, title = {Roddit}, type = {Standard Project}, url = {https://github.com/dippi9845/roddit}, year = 2026 }
@courseproject{hanabimultiplayer-ds2526, abstract = {Hanabi is a cooperative multiplayer card game for 2--4 players where players score by guessing their own hidden cards based on hints given by other players. This project aims to implement a working version of the game that manages the shared state consistently and reliably, while being able to tolerate disconnects from a client or the server.}, apice = {HanabiMultiplayer}, author = {Savevski, Blagoja and Xu, Pengyue and Santi, Gabriele}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jun, sort = {classic}, supervisor = {Magnini, Matteo}, title = {Distributed Hanabi}, type = {Standard Project}, url = {https://github.com/ajdonker/Hanabi_DS}, year = 2026 }
@courseproject{connectfour-ds2425, abstract = {This report details the architectural design, protocol specifications, and validation framework of a highly available, networked multiplayer implementation of the classic strategy matrix board game Connect Four. Developed using Python, FastAPI, WebSockets, and PyQt6, the system addresses core concerns of modern distributed environments, specifically fault isolation, dynamic session state routing, and state machine replication. Adhering to the principles of the CAP Theorem, the architecture favors an AP (Availability and Partition Tolerance) model to preserve match state permanence across abrupt software failures. By implementing a strict master-slave warm standby synchronization model governed by real-time heartbeat monitors, the system demonstrates an automated, transparent 10-second failover recovery routine. This design ensures seamless user connection migration and prevents data corruption or game session resets when an active cluster coordinator unexpectedly terminates.}, apice = {ConnectFour}, author = {Lajani, Arvin}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = jun, sort = {game}, supervisor = {Magnini, Matteo}, title = {Distributed Connect Four: A Fault-Tolerant Networked Multiplayer Game Architecture}, type = {Game Project}, url = {https://github.com/ArvinLajani/Distributed-Connect-Four}, year = 2026 }
@courseproject{gossipbaseddistributedmonitoringsystem-ds2526, abstract = {This project presents the design and implementation of a fully decentralized monitoring system based on gossip (epidemic) protocols. The system consists of multiple independent nodes that collaboratively maintain cluster membership and detect failures without relying on any centralized coordinator. Each node periodically exchanges partial state information with a subset of randomly selected peers. Through these probabilistic interactions, membership updates propagate across the system, enabling nodes to converge toward a consistent global view even in the presence of network delays, packet loss, and node crashes. Failure detection is achieved through heartbeat mechanisms combined with timeout-based state transitions (ALIVE, SUSPECT, DEAD),following a design inspired by the SWIM protocol. The system is designed to operate in asynchronous and unreliable environments while ensuring eventual consistency. An experimental extension, called Gossip Arena, is introduced to study information dissemination dynamics. Synthetic rumor events are injected into the system to evaluate the impact of different gossip strategies and parameters on dissemination speed and communication overhead. Experimental results show that the system remains robust under moderate network impairments and highlight the trade-offs between convergence speed, communication cost, and accuracy of failure detection.}, apice = {GossipBasedDistributedMonitoringSystem}, author = {Testa, Thomas}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = jun, sort = {advanced}, supervisor = {Magnini, Matteo}, title = {Gossip-Based Distributed Monitoring System}, type = {Advanced Project}, url = {https://github.com/ThomasTesta/gossip-distributed-monitoring.git}, year = 2026 }
@courseproject{distributedminingmonitor2026-ds2526, abstract = {This project presents a Distributed Mining Monitor, a controlled experimental platform designed to study Proof-of-Work (PoW) consensus in a distributed setting. The system includes a coordinator service, a configurable set of CPU and GPU miners, and a monitoring dashboard exposing the behaviour of the system in real time. The goal is not to implement a production-ready blockchain, but rather a reproducible laboratory for observing miner competition, fork creation, stale work, branch persistence, and reorganization events. The final version of the project supports heterogeneous miners, local branch persistence, configurable reorganization thresholds, simulated network delay, and a simplified difficulty-adjustment policy. Instead of re-synchronising to the coordinator before every mining attempt, miners can continue mining on their local branch and switch back to the coordinator only when they fall sufficiently behind. This makes competing branches persist long enough to generate visible reorgs. The coordinator stores the full block DAG, selects the canonical branch according to an explicit policy, and exposes metrics consumed by a dashboard that visualises chain growth, stale branches, accepted blocks by miner, reject rate, difficulty level, and block-DAG evolution.}, apice = {DistributedMiningMonitor2026}, author = {Remedi, Tommaso and Biagioni, Giacomo}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = may, sort = {classic}, supervisor = {Magnini, Matteo}, title = {Distributed Mining Monitor}, type = {Standard Project}, url = {https://github.com/Reme240400/Distributed-System-Project-Remedi-Biagioni}, year = 2026 }
@courseproject{mancalagame2026-ds2425, abstract = {This report presents the design and implementation of a distributed Mancala game system built using Spring Boot and WebSockets. The system enables two players to play the classic Mancala board game over a network in real-time. The primary focus is on handling distributed challenges such as player disconnection, session management, inactivity detection, and state consistency across multiple clients. The implementation demonstrates core distributed systems concepts including asynchronous communication, fault tolerance, and timeout mechanisms. The game is implemented with a clean separation between domain logic (game rules), service layer (business logic), and presentation layer (WebSocket controllers). Key features include automatic room creation, player joining, real-time game state synchronization, graceful disconnection handling with reconnection support, and inactivitybased player forfeit mechanisms.}, apice = {MancalaGame2026}, author = {Sabertehrani, Kasra and Sokuti, Parisa}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = may, sort = {game}, supervisor = {Magnini, Matteo}, title = {Distributed Mancala}, type = {Game Project}, url = {https://github.com/kasrasabertehrani/mancala-game}, year = 2026 }
@courseproject{distributedaudioprocessingpipeline-dss2526, abstract = {This work presents a distributed, event-driven pipeline for asynchronous audio processing, designed as a practical case study for distributed systems principles and operational observability. Users submit audio files through a FastAPI service. The API stores binary objects in MinIO, persists job metadata in PostgreSQL, and publishes processing requests to RabbitMQ. A decoupled worker consumes queued jobs, extracts core audio metadata (duration, sample rate, channels), and writes results back to the database. The same API exposes upload, job tracking, and result retrieval endpoints, enabling a complete end-to-end workflow. The architecture separates ingestion and processing through asynchronous messaging, so API and worker instances can scale independently. Reliability is modeled through durable queue-based communication and explicit jobstate transitions (PENDING, PROCESSING, DONE, FAILED), while observability is supported via Prometheus-compatible metrics for throughput, latency, queue backlog, and worker activity. The stack is containerized with Docker and structured for Kubernetesbased deployment and scaling experiments. The project shows how messagedriven coordination, persistent state management, and monitoring can be combined into a reproducible distributed audio-processing system.}, apice = {DistributedAudioProcessingPipeline}, author = {Cardellini, Matteo}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = may, sort = {classic}, supervisor = {Matteini, Mattia}, title = {Distributed Audio Processing Pipeline with Observability}, type = {Standard Project}, url = {https://github.com/matteo1610/distributed-audio-pipeline}, year = 2026 }
@courseproject{explodingkittens-ds2425, abstract = {The project is a distributed base implementation of the popular card game Exploding Kittens. Exploding Kittens is a card game for 2 to 4 players. On each turn, a player either plays action cards from their hand or draws cards from the deck. Draw an Exploding Kitten and you are out, unless you have a Defuse card to save yourself. The last player standing wins.}, apice = {ExplodingKittens}, author = {Versari, Alessandra and Balzoni, Margherita}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = may, sort = {game}, supervisor = {Magnini, Matteo}, title = {Exploding Kittens}, type = {Game Project}, url = {https://github.com/Aleversari15/DS25-ExplodingKittens}, year = 2026 }
@courseproject{distributedsensorhubsantini2026-ds2526, abstract = {Distributed Sensor Hub is a fully decentralized peer-to-peer platform for smart-city sensor data collection and replication, designed to operate across multiple nodes without any central coordinator. Each node may manage connections to multiple local sensors, ingest their readings through a pluggable sensor interface to support different sensor types, and maintain a local replica of the shared system state. The platform disseminates sensor updates through push-pull gossip and resolves conflicts with deterministic timestamp-based Last-Writer-Wins merging, providing eventual consistency across replicas. To remain operational in realistic distributed environments, the system combines gossip-based membership, phi-accrual failure detection, and antientropy recovery after crashes or temporary network partitions. In CAP terms, the project prioritizes availability and partition tolerance over strong consistency, while still guaranteeing convergence once communication is restored.}, apice = {DistributedSensorHubSantini2026}, author = {Santini, Alex}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = may, sort = {classic}, supervisor = {Magnini, Matteo}, title = {P2P Distributed Sensor Hub for Smart City Monitoring}, type = {Standard Project}, url = {https://github.com/AlexSantini10/distributed-sensor-hub}, year = 2026 }
@courseproject{dok-ds2526, abstract = {Dok is a distributed, real-time collaborative document editing platform implemented as a web application. It allows multiple users to create, share, and simultaneously edit text documents. The system is built on a client--server architecture in which the backend is horizontally scaled across two Node.js/Express server instances, load-balanced by an Nginx reverse proxy. Real-time collaboration is achieved through Yjs Conflict-free Replicated Data Types (CRDTs) transported over Socket.io WebSocket connections; cross-instance event propagation is coordinated via a shared Redis Pub/Sub adapter, which also enables cluster-wide user-presence tracking. Persistent state is stored in a MongoDB document database. Documents are organised in folders and can be made public or private, with sharing policies (viewer, commenter, editor) enforced through JWT-based authentication and role-based access control. An administrative dashboard provides real-time platform-wide statistics, audit trails, user presence information, and site-access logs. The entire infrastructure is containerised with Docker Compose, making deployment reproducible with a single command.}, apice = {Dok}, author = {Stefani, Alessandro and Tosi, Lorenzo}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = may, sort = {classic}, supervisor = {Magnini, Matteo}, title = {Dok}, type = {Standard Project}, url = {https://github.com/lorenzotosi/Dok}, year = 2026 }
@courseproject{votingpollingsystem2026-ds2526, abstract = {This project presents a distributed voting and polling system designed to operate in a decentralized and fault-tolerant environment. The system allows users to create polls and cast votes through a REST-based web service, while maintaining replicated application state across multiple nodes. The core challenge addressed is maintaining replicated poll state in the presence of concurrent updates, node crashes, and network partitions. To address this, the system adopts a Conflict-free Replicated Data Type (CRDT) model, allowing nodes to process updates independently while guaranteeing eventual convergence of replicas. Update dissemination is implemented through a best-effort replication strategy combined with periodic anti-entropy synchronization, ensuring that updates missed during temporary disconnections are eventually propagated. To improve dependability, each node persists updates using a write-ahead log (Write-Ahead Log (WAL)) and periodically creates checkpoints, allowing recovery after crashes with no loss of locally persisted updates. A heartbeatbased failure suspicion mechanism is also included to monitor node reachability and identify potentially failed or disconnected peers. The system prioritizes availability and partition tolerance over strong consistency, making it suitable for distributed environments where network reliability cannot be guaranteed. The final implementation demonstrates how fundamental distributed systems concepts such as replication, consistency trade-offs, and fault tolerance can be applied in a practical application.}, apice = {VotingPollingSystem2026}, author = {Pisu, Roberto}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = apr, sort = {classic}, supervisor = {Magnini, Matteo}, title = {Distributed Voting and Polling System}, type = {Standard Project}, url = {https://github.com/robertop03/Distributed-Voting-and-Polling-System}, year = 2026 }
@courseproject{showdownbaldazzi2026-ds2526, abstract = {The project presents a simple distributed real-time game based on the showdown mode of Supercell’s Brawl Stars. The players are forced to combat inside an arena and the last one standing is considered the winner. The only way to survive is to eliminate all the other players by shooting at them. The game features a distributed architecture that uses a peer-to-peer communication model between players and client-server model to enable the presence of a lobby server. To overcome unstable networks, the game implements client-side prediction mechanisms.}, apice = {ShowdownBaldazzi2026}, author = {Baldazzi, Andrea}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = apr, sort = {game}, supervisor = {Magnini, Matteo}, title = {Showdown}, type = {Game Project}, url = {https://github.com/baldo3000/showdown}, year = 2026 }
@courseproject{taskflow-dss2526, abstract = {Effective coordination between centralized command centers and distributed field operatives requires strict state synchronization across unpredictable network topologies. TaskFlow is a distributed workforce management platform utilizing a microservices architecture that separates rigid HTTP REST data operations from real-time WebSocket streams. This report outlines the system requirements, architectural design choices, distribution aspects, and fully containerized deployment strategies. By implementing an event-driven messaging layer via RabbitMQ, the system prioritizes high availability and graceful fault tolerance, ensuring deterministic data consistency for distributed mobile clients operating in volatile environments.}, apice = {TaskFlow}, author = {Trabelsi, Ahmed and Toumi, Lotfi}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = apr, sort = {classic}, supervisor = {Matteini, Mattia}, title = {TaskFlow: A Distributed Tactical Mission Control System}, type = {Standard Project}, url = {https://github.com/toumilotfi/fullstack-project/}, year = 2026 }
@courseproject{minidynamo2026-dss2526, abstract = {The goal of this project is to design and implement a simple distributed key-value store inspired by real-world systems such as Amazon Dynamo. The system will consist of multiple independent nodes that cooperate to store and retrieve key-value pairs while tolerating node failures. Each node will run as a separate process and communicate with other nodes over the network. The system will provide a basic client interface that supports storing and retrieving data in a distributed environment.}, apice = {MiniDynamo2026}, author = {Dominykas Arnauskas}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = apr, sort = {classic}, supervisor = {Matteini, Mattia}, title = {Mini-Dynamo: A Distributed Key-Value Store in Python}, type = {Standard Project}, url = {https://github.com/DominykasAr/Distributed-systems-project}, year = 2026 }
@courseproject{eventonight-ds2324, abstract = {The project consists of the design and development of a distributed digital platform called EvenToNight, aimed at connecting organizations that promote socialevents with users interested in discovering and participating in them. The platform, accessible at EvenToNight, can be used either as a guest or through a registered account that provides additional functionalities. From a technical perspective, EvenToNight has been designed as a distributedsystem based on a microservices architecture, supporting modularity, scalability andthe independent management of application components. This architectural choice enables horizontal and autonomous scaling of the various system components, allowing the platform to handle a large number of usersconcurrently. Furthermore, the distributed architecture ensures reliable data persistence, availability and openness, thereby facilitating future extensions and adaptation to evolving requirements. Overall, the project represents a practical application of distributed systemsprinciples within the context of a realistic web-based platform.}, apice = {EvenToNight}, author = {Alice Alfonsi and Bravetti, Federico and Tommaso Brini}, howpublished = {Distributed Systems, A.Y. 2023/2024}, month = apr, sort = {classic}, supervisor = {Magnini, Matteo}, title = {EvenToNight}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-alfonsi-bravetti-brini-ay2324}, year = 2026 }
@courseproject{nomicosecitta2026-ds2425, abstract = {This project presents a real-time, distributed implementation of the classic italian word game Nomi, Cose, Citt`a. It transforms the traditional pen-and-paper format into a modern multiplayer experience, where players compete in real time to find words that match given categories and starting letters. At the end of each round, participants collaboratively validate each other’s answers through an integrated voting and chat system. The game features a distributed architecture that combines client--server and peer-to-peer communication models, ensuring consistent gameplay with fault tolerance and synchronized state across all nodes.}, apice = {NomiCoseCitta2026}, author = {Chiara Giangiulli and Pisoni, Giovanni and Dilaver Shtini}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = apr, sort = {game}, supervisor = {Magnini, Matteo}, title = {Nomi, Cose Citt\`{a}}, type = {Game Project}, url = {https://github.com/DilaverShtini/nomi-cose-citta}, year = 2026 }
@courseproject{unop2p2026-ds2526, abstract = {When it comes to playing games online, cheaters represent a major problem. Especially, peer-to-peer architectures are vulnerable to cheating as the game state and logic are handled purely by untrusted peers, rather than a single trusted server. However, using P2P approaches can increase scalability as this usually implies smaller bandwith requirements for the service provider. In this project, we develop and design a system that provides a (mostly) cheating-proof method for implementing a card game in a P2P fashion. As a proof-of-concept, we develop a card game, similar to the game ‘UNO’. Further, we design a distributed architecture that integrates this approach into a more complex system that additionally provides functionality for a leaderboard that tracks the win statistics of the players.}, apice = {UNOP2P2026}, author = {Luka Finn Born}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = mar, sort = {game}, supervisor = {Magnini, Matteo}, title = {UNO-P2P: A Cheater-proof Peer-to-Peer implementation of a simple card game}, type = {Game Project}, url = {https://github.com/IchbinLuka/p2p-uno}, year = 2026 }
@courseproject{opcuaindustrialplanthub-ds2526, abstract = {This report illustrates OPCUA Industrial Plant Hub, a software developed to demonstrate the fundamental principles of Distributed Systems by integrating them with the world of industrial automation. In the world of industrial automation, the issue of data collection from machines and machine lines is becoming increasingly important. Therefore, this project aims to provide a distributed data collection system for different production lines, which may also be distributed across the territory. The project is based on the use of IoT devices, which are connected to the production line and collect data on the production process. The data collected is then sent to a central server, which stores it and allows it to be analysed. The data can also be sent to the machines themselves, allowing them to be controlled and optimised. The underlying idea is that data is collected from the machine line using the OPC UA protocol, widely used in industry, saved and then retrieved via HTTP API. Unlike traditional data collection architectures based on a single physical node that reads data, the architecture of this project consists of three HUB nodes that collect OPC UA data, synchronised via Anti-Entropy and Gossip protocols, with an nginx load balancer that distributes client requests and implements data encryption via the TLS protocol. The project emphasises the AP behaviour of the CAP Theorem, i.e. it focuses on the aspects of Partition Tolerance and High Availability, thus ensuring that clients can always access data even in the presence of network partitions or individual node failures. The Strong Consistency concept is therefore not guaranteed, promoting data that is not updated to the latest possible value over a longer wait time that would result from the application of Strong Consistency itself. The system allows OPC UA sources to be added dynamically, by implementing an on the fly automation line connection mode, allowing individual machines or entire lines to be connected and added without the system needing to be restarted.}, apice = {OPCUAindustrialPlantHub}, author = {Federico Capitanio}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = mar, sort = {classic}, supervisor = {Magnini, Matteo}, title = {OPC UA Industrial Plant HUB}, type = {Standard Project}, url = {https://github.com/FedericoCapitanio-Unibo/DISI-DS-OPCUA-Industrial-HUB}, year = 2026 }
@courseproject{distributedbomberman-dss2526, abstract = {We present a distributed, real-time Bomberman system designed for multi-player gameplay with scalability and fault tolerance. The architecture is split into two layers: a hub layer responsible for matchmaking and cluster coordination, and a room layer that executes the authoritative game loop. The hub server adopts an AP-oriented design, using UDP-based gossip to disseminate room availability and peer liveness without centralized coordination. The room server is CP-oriented, running a deterministic tick loop over a TCP and Protocol Buffers protocol to ensure consistent state across clients. The client is protocol-driven and renders the game as an ASCII interface. The system supports transient failure handling through bounded reconnection windows and state snapshotting, keeping matches stable under brief network interruptions. A Kubernetes-based deployment is used for hub scalability and room provisioning. The result is a coherent distributed design that balances availability with strong consistency at the game engine.}, apice = {DistributedBomberman}, author = {Enrico Ferraiolo and Daniele Romanella}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = mar, sort = {game}, supervisor = {Matteini, Mattia}, title = {Distributed Bomberman Game}, type = {Game Project}, url = {https://github.com/Distributed-System-AA-2025-2026/Bomberman}, year = 2026 }
@courseproject{distributedconsistencyrtcollab-ds2425, abstract = {A comparative Analysis of Operational Transformation (OT) and Conflict Free Replicated Data Types (CRDTs)}, apice = {DistributedConsistencyRTCollab}, author = {Keith Barnes}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = feb, sort = {survey}, supervisor = {Omicini, Andrea}, title = {Distributed Consistency in Real-time Collaboration}, type = {Survey Project}, year = 2026 }
@courseproject{pddlevolution-ise2425, abstract = {Foundations, Standardization, and Comparative Analysis of Planning Technologies}, apice = {PDDLEvolution}, author = {Keith Barnes}, howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025}, month = feb, sort = {survey}, supervisor = {Omicini, Andrea}, title = {Classical Logic to Modern Solvers: The Evolution of PDDL}, type = {Survey Project}, year = 2026 }
@courseproject{townofsaviom-ds2526, abstract = {“Town of Saviom” is a web application developed as a joint project for the Distributed Systems and Applicazioni and Servizi Web courses. The application implements an online version of the party game “Lupus in fabula”, drawing inspiration from the mechanics of the video game Town of Salem. The game architecture centers on user interaction through a realtime shared chat, a crucial tool for discussion and deduction phases. Two game modes are provided: Classic (roles limited to Werewolf and Villager) and Advanced (introducing new roles such as Doctor and Seer). The gameplay is structured into three distinct phases that regulate chat reading and writing permissions: Day (global discussion and voting), Defense (only the accused player can defend themselves), and Night (Werewolves’ and special roles’ actions). The application offers a complete user management system, including registration, login, profile customization, and game statistics viewing. The main features of this web application allow users to create new games (acting as the lobby’s Host), search for existing lobbies via filters or unique codes, and handle automatic reconnection in case of disconnection. Additionally, a System Admin has global spectator privileges to monitor the proper conduct of matches (by viewing all players’ roles and exchanged messages).}, apice = {TownofSaviom}, author = {Fabio Pedrini and Lorenzo Zanetti and Alessandro Zanzi}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = feb, sort = {game}, supervisor = {Magnini, Matteo}, title = {Town of Saviom}, type = {Game Project}, url = {https://github.com/zanetti33/town-of-saviom-wrapper.}, year = 2026 }
@courseproject{caboonline-ds2425, abstract = {The goal of this project is to develop a desktop application that allows users to play the online version of “Cabo”, a turn-based card game. Details about the game itself and how it works can be found in the report. The application runs on PC and provides a GUI to allow user interaction in every step of the system, from creating or joining a game, to the single actions performed during a turn. Games can be private or public: in the first case, other players can join only by using a unique code; in the second case, the game is shared through a lobby server and becomes visible to all players in the system. The server does not work as a dispatcher of messages between players; it is only used to obtain a reference to the host to start the communication. Therefore, the application is structured as a peer-to-peer (P2P) system, meaning that the players participating in a game are connected directly to each other. Without a centralized server, it is necessary that the information and data shared between players are always consistent and up to date. In particular, during a match, the game state (which includes the players’ hands and the table situation) must always be the same for every player at every turn, to ensure that the actions chosen by a player are coherent and correct with respect to the current situation.}, apice = {CaboOnline}, author = {Bachetti, Michele and Marcantognini, Elia and Tinti, Angelo}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = feb, sort = {classic}, supervisor = {Magnini, Matteo}, title = {Cabo Online}, type = {Standard Project}, url = {https://github.com/angelo-will/cabo-online-distributed-systems-project}, year = 2026 }
@courseproject{tinykeyvaluestore-dss2526, abstract = {TinyKV is a high performance distributed Key-Value store implementation. It is written in modern c++ (C++20) and uses grpc, multithreading and fine-grained locking to achieve up to 5000 Operations Per Second. TinyKV implements features like Tunable Consistency, Consistent Hashing, LWW Conflict resolution and asynchronous Heartbeats.}, apice = {TinyKeyValueStore}, author = {Emil Rafael Solberg}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = feb, sort = {classic}, supervisor = {Matteini, Mattia}, title = {TinyKV: A High Performance Distributed Key-Value Store}, type = {Standard Project}, url = {https://github.com/emsoraffa/TinyKV}, year = 2026 }
@courseproject{distributedcollaborativestorytelling-ds2425, abstract = {Context: We propose the development of a Distributed Collaborative Storytelling Engine, a real-time platform where multiple users co-author a narrative under the guidance of a rotating narrator. Methodology: The system architecture implements a High Availability Master-Slave cluster. Key features include a dynamic role-rotation mechanism for the narrator and automated theme generation to ensure narrative flow. Robustness is guaranteed through a dual-layer strategy: active state replication for immediate failover and persistent storage for data durability.}, apice = {DistributedCollaborativeStorytelling}, author = {Arcese, Gabriele and Costantini, Marco}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = feb, sort = {classic}, supervisor = {Magnini, Matteo}, title = {Distributed Collaborative Storytelling}, type = {Standard Project}, url = {https://github.com/MarcoCostantini26/DistributedStorytelling}, year = 2026 }
@courseproject{robotsonmars-ise2425, abstract = {This project aims to create a Jason MAS simulating the behaviour of multiple robots exploring and collecting samples on Mars.}, apice = {RobotsOnMars}, author = {Venturini, Alessandro}, howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025}, month = feb, sort = {simulation}, supervisor = {Ciatto, Giovanni}, title = {Robots on Mars}, type = {Simulation Project}, url = {https://github.com/Ventus218/robots-on-mars}, year = 2026 }
@courseproject{distributedhoneypot-ds2425, abstract = {The proposed project involves the development of a distributed web application designed to monitor and analyze suspicious network activity through the use of Honeypots. Honeypots are specialized nodes configured to simulate vulnerable services, with the goal of attracting potential cyber threats and collecting valuable security data. The application features a centralized Dashboard that enables users to: Monitor the status of Honeypot nodes in real time. View detailed data on detected attacks. Manage the nodes directly from the interface. The collected data includes information on attacks, such as unauthorized access attempts, malicious file uploads, and other suspicious activities, all categorized by severity levels to prioritize responses. The system is designed to be distributed, allowing Honeypot nodes to operate on machines separate from the central server (in this case, within distinct containers). This architecture promotes scalability, isolation, and flexibility, making it suitable for dynamic and complex network environments.}, apice = {DistributedHoneypot}, author = {Diego Colì}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = feb, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Distributed Honeypot}, type = {Standard Project}, url = {https://github.com/floyddc/Distributed-Honeypot}, year = 2026 }
@courseproject{dscinema-ds2526, abstract = {DS-Cinema is a distributed peer-to-peer system for cinema seat reservation. There is no central server managing the application logic or storing data: everything is distributed across the nodes in the network. The goal of the project is to implement from scratch the distributed coordination algorithms studied in class. In particular, I used the Ricart-Agrawala algorithm together with Lamport Clocks to guarantee mutual exclusion: if two users click at the same instant, they won’t have problems, but one of them will get the seat as booked, while for the other it will appear as occupied. The system also handles failures: if a node crashes during a reservation, the others detect it via timeouts and continue to work normally. New nodes can dynamically join the network and synchronize with the current state.}, apice = {DSCinema}, author = {Luca Cantagallo}, howpublished = {Distributed Systems, A.Y. 2025/2026}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {DS-Cinema: Distributed P2P Seat Reservation System}, type = {Standard Project}, url = {https://github.com/LucaCantagallo/DS-Cinema}, year = 2026 }
@courseproject{distributedchessteambattle-dss2526, abstract = {This report presents ‘Distributed Team Chess’, a cooperative version of Chess designed to demonstrate fundamental principles of Distributed Systems within an interactive environment. Unlike traditional turn-based games, this system introduces a new gameplay mechanic based on Role Sharding and Distributed Consensus. Players are organized into teams where each node holds exclusive write permissions over a specific subset of game resources (specific chess pieces). To execute a state transition (a move), the team must reach a consensus through a voting protocol, transforming the game into a distributed coordination challenge. This way to play chess encourages collaboration, communication, and strategic planning among team members, giving the game a new dynamic and engaging dimension. From an architectural perspective, the system adopts a Broker-Based Hybrid Peer-to-Peer model. A scalable .NET backend, orchestrating communication via SignalR and persisting state on Redis, acts as a coordination bus and transaction log. This design choice prioritizes Strong Consistency and Partition Tolerance (CP in CAP terms), ensuring a single source of truth while offloading preliminary move validation logic to client nodes to simulate P2P filtering. The project places a strong emphasis on Fault Tolerance and High Availability. It implements automatic failure detection: in the event of a node crash or disconnection, a failover mechanism triggers a dynamic Rebalancing of the shards, transferring control of the ‘orphaned’ pieces to surviving teammates to ensure system liveness. Furthermore, a timeout-based supervisor prevents distributed deadlocks during the voting phase. This report details the architectural decisions, the consistency models adopted, and the resilience strategies implemented to guarantee a seamless user experience in a volatile distributed environment.}, apice = {DistributedChessTeamBattle}, author = {Matteo Raggi}, howpublished = {Distributed Software Systems, A.Y. 2025/2026}, month = feb, sort = {game}, supervisor = {Matteini, Mattia}, title = {Distributed Chess Team Battle}, type = {Game Project}, url = {https://github.com/matteraggi/DistributedChess}, year = 2026 }
@courseproject{smartassistantdrive-ise2223, abstract = {From July 2024, all newly produced cars must have a camera to read speed signs (Intelligent Speed Assist), but this technology has yet to be ready as we expect it to be. As shown in this Quattroruote test , only some signs can be read correctly. This is because street signs are a human concept for human comprehension; in our opinion, cars should use a digitalized version of them. This also expands to other road-related concepts, such as traffic lights. The idea is to simulate a road and apply MAS to cars and traffic lights, rep}, apice = {SmartAssistantDrive}, author = {Brighi, Andrea and Di Lillo, Daniele}, howpublished = {Intelligent Systems Engineering, A.Y. 2022/2023}, month = jan, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Smart Assistant Drive}, type = {Standard Project}, url = {https://github.com/orgs/Smart-Assistant-Drive/}, year = 2026 }
@courseproject{mentalpoker-ds2425, abstract = {This project implements a decentralized poker game (Texas Hold’em) without requiring a trusted third party. The implementation guarantees fairness even when k−1 out of k players form a malicious coalition attempting to rig the game. The system consists of three main components: a cryptographic deck library implementing the Wei & Wang mental poker protocol[15], a poker game engine managing game logic and state, and a blockchain-based distributed ledger ensuring non-repudiation of player actions. The architecture follows a peer-to-peer design with broadcast-based communication primitives, enabling fully distributed gameplay over local area networks. The delivered artifacts include a Go library with all the core functionalities and a command-line interface that exposes this library as a usable application, allowing end-to-end experimentation and gameplay while deliberately minimizing effort on user interface concerns so that the project work could focus more on the distributed and cryptographic aspects.}, apice = {MentalPoker}, author = {Marco Galeri and Luca Patrignani}, howpublished = {Distributed Systems, A.Y. 2024/2025}, month = jan, sort = {game}, supervisor = {Magnini, Matteo}, title = {Mental Poker: A Decentralized Implementation}, type = {Game Project}, url = {https://github.com/luca-patrignani/mental-poker}, year = 2026 }
@courseproject{onlinerlslr2026-ise2425, abstract = {Online reinforcement learning (RL) enables autonomous agents to adapt their policies in real time, responding to dynamic and uncertain environments. This systematic literature review (SLR) examines high-impact studies from 2004 to 2026 on online RL methods for decision-making and explicit policy learning in autonomous agents, excluding approaches that do not adapt during execution. We analyze algorithmic strategies for handling non-stationarity, exploration-exploitation trade-offs, and multi-agent interactions. The review highlights emerging trends, practical implementations, and remaining challenges, offering actionable insights for designing adaptive and efficient online RL controllers in robotics, UAVs, and intelligent systems.}, apice = {OnlineRLSlr2026}, author = {Vargas Grateron, Pablo Sebastian}, howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025}, month = jan, sort = {survey}, supervisor = {Omicini, Andrea}, title = {Online Reinforcement Learning for Decision-Making and Explicit Policy Learning in Autonomous Agents: A Systematic Literature Review}, type = {Survey Project}, url = {https://github.com/Zettaiki/ISE-SLR-online-rl-for-decision-making-and-policy-learning}, year = 2026 }