This project presents an open-source polling platform addressing limitations in existing commercial solutions. Current platforms lock core functionality behind expensive subscriptions, provide no self-hosting options, and offer limited scalability transparency. Educational institutions and organizations requiring data sovereignty cannot deploy these systems locally, forcing cloud provider dependence.

Key features include authenticated and anonymous participation with duplicate vote prevention, poll scheduling, reusable templates, and configurable privacy controls. Poll creators can restrict voting to authenticated users, control results visibility, and manage vote editing. The system maintains low latency, ensuring participants see results update immediately.

The architecture supports horizontal scaling across multiple server instances through message synchronization, enabling vote updates to propagate across distributed backends whilst maintaining data consistency. This work provides an open-source, self-hostable alternative to commercial platforms for education and organizational use.

StudyWeave is an AI-powered productivity platform supporting the organisation of study material and task management, while also promoting healthy study habits and student wellbeing.

Users can upload academic material, which the system automatically groups by topic. The dashboard offers different view modes to browse documents individually or within their topic group. Structured summaries can be generated for both individual documents and entire topics, and downloaded as PDFs. The platform also generates exportable mind maps in SVG format. Each uploaded document generates a list of small, actionable tasks organised in a kanban-style workflow, encouraging active engagement with study material. A journalling feature allows users to track their thoughts and emotional state through sentiment analysis, fostering mental well-being awareness during study periods.

The system is implemented using React.js, FastAPI and SQLAlchemy. Natural Language Processing tasks are performed through Ollama. Firebase is employed for authentication.

Overall, StudyWeave demonstrates how AI can be leveraged to create a balanced system that enhances both academic performance and personal well-being.

Project Overview

This project was about how we can make local history discovery easier with an interactive, map-based web application...

Features

• Interactive map interface
• Nearby landmark discovery
• Context-based question answering
• Caching and fallback mechanisms
• Live demo support

Why This Project Matters

This project is interesting because it brings together three different concepts that are generally separate: location intelligence, cultural heritage, and artificial intelligence-based learning. This project offers a faster and more exciting way of understanding a location, as opposed to reading long, static text-based information about a location.

Artificial intelligence coding tools are rapidly transforming how software is built, but a fundamental question remains: can they fully replace software engineers? This project investigates this by having four AI tools, ChatGPT, Claude Code, Cursor, and Firebase Studio, each independently build the same retail web application across 17 standardised tasks, evaluated using identical automated test suites.

Each tool was used according to its natural interaction model, some working conversationally, others self-testing and self-correcting between prompts. Results were measured across structural correctness, runtime behaviour, time taken, and human intervention required.

The findings suggest AI tools can produce functionally complete applications but differ in reliability and autonomy. The most capable tool completed all 17 tasks in under three hours with zero manual intervention, a pace hard for a human to match. The gap between passing tests and producing working software remained a persistent challenge. AI appears to be redefining the role rather than replacing the software engineer, shifting human effort from writing code to reviewing, directing, and correcting it.

University College Cork is a large campus with many buildings, services and facilities distributed across a wide area. Information on locations, opening hours, and amenities is currently spread across maps, signage and multiple web pages, making it difficult for students, staff and visitors to find what they need. This project introduces a mobile-first web application that consolidates information. Unlike general-purpose mapping tools, which lack detail needed for campus navigation, this application is purpose-built for UCC and accessible on all devices without installation.

The application features an interactive map built with Leaflet.js, a tool for displaying maps on web pages. Users can search for buildings, filter facilities such as cafés, and view opening hours that adapt to term-time and out-of-term periods. Walking routes are generated in real time using OSRM, an open-source routing system, while geolocation shows the user's position. The system includes a front end built using Next.js and TypeScript, and a back end that manages data using a SQLite database. An admin panel allows authorised staff to update data, and users can report issues to keep the system accurate.

AI EcoSound Tutor is a highly visual, interactive web platform built with Flask that teaches how AI processes wildlife audio. It guides users through a 7-step ML pipeline: (1) Load Data via drag-and-drop or microphone with waveform/spectrogram previews, (2) Extract Features using MFCC with optional chroma and spectral extras, (3) Reduce Dimensions via PCA, t-SNE, or UMAP with A/B comparison, (4) Cluster segments using KMeans, GMM, or HDBSCAN, (5) Explore interactively with lasso selection, audio playback, and spectrograms, (6) Train Classifiers — Random Forest, SVM, Gradient Boosting, and more — with confusion matrices, feature importance charts, and model comparison, and (7) Export as CSV or HTML reports. Every step prioritises visual feedback through interactive Plotly charts and heatmaps. A Beginner's Guide, context-aware AI chatbot, and teaching tooltips support learning throughout. Built for students, researchers, and educators in bioacoustics.

This project presents a flexible, user-focused software application for controlling a Raman camera, developed in collaboration with Tyndall National Institute. While existing tools such as Andor Solis are reliable, they often lack flexibility and require repetitive manual steps, slowing down experimentation.

The system is built around strong state management and controlled operation flow to protect expensive hardware from misuse. It prevents conflicting actions—such as starting a new acquisition during an active one or applying invalid parameters—by handling them in real time. The application follows a Model–View–Controller architecture in Python and integrates with the Andor SDK2 via pylablib, ensuring safe and consistent communication between the interface and the hardware.

Key features include real-time image preview with interactive ROI control, multiple acquisition modes, responsive multi-threading, and reliable data export with metadata. Overall, the project delivers a fail-safe and user-friendly system that improves efficiency while ensuring safe camera operation.

Recent developments in Agentic AI allow large language models to act as orchestrators, solving complex tasks through multi-step reasoning and tool use. Most existing benchmarking solutions focus on final outcomes, overlooking the reliability of decisions at each step. This project introduces a benchmarking framework to compare LLMs on their reliability and performance as autonomous orchestrators. We evaluate multiple LLMs on grid-based pathfinding tasks, where LLMs must compute shortest paths using tools and autonomous reasoning, with Dijkstra’s algorithm as ground truth. The benchmark offers various task complexity, prompting strategies, and levels of autonomy, including configurations with and without validation tools. Reliability is measured through path correctness, optimality, tool usage, runtime, and hallucination rates with increasing graph sizes. By isolating a single-LLM architecture, this work provides a clearer analysis of orchestration capabilities and failures, offering insights into how well LLMs can plan, execute, and backtrack in structured, controlled environments.

A k-d tree is a data structure for organising points in multi-dimensional space, first introduced by Jon Louis Bentley in 1975. Rather than scanning every record to answer a query, it recursively partitions space using splitting hyperplanes, allowing large portions of the dataset to be eliminated without ever being examined. This project involved a full self-study and implementation of the k-d tree from Bentley's original paper.

The implementation, written in Python, covers insertion, exact search, partial search, region queries, nearest neighbour search, deletion, and rebalancing. Two nearest neighbour algorithms were implemented and compared: Bentley's original approach, and an improved version using bounding box pruning. Benchmarking against a brute-force baseline revealed a 1900x speedup at two dimensions, collapsing to below brute-force performance by fifteen dimension. A clear example of the curse of dimensionality. An interactive web visualiser was also built, allowing users to insert points, watch the space get partitioned in real time, and see which branches of the tree get explored versus pruned. Come find the demo on open day.

The application which I like to call Thereabouts is an Android app that uses Pedestrian Dead Reckoning (PDR) techniques to estimate a user’s position within a building.

Common use cases are where GPS is unavailable or inaccurate such as underground parking or metros. The app is designed with the intention of crowdsourcing map data, independent of building owners, to encourage a community of users. Users perform calibration of their stride to determine their stride length and step sensitivity.

When a user approaches a building, they are notified and can load that building’s map, currently including the Western Gateway Building. Their position is displayed on the map and they can move about. Movement is detected using steps, and direction is inferred by Compass and Gyroscope readings. An uncertainty model is implemented to show the user a confident radius around them to account for errors. Some accuracy improvement techniques are deployed, such as scrutinizing GPS readings and updates based on Bluetooth location advertisements from peers. Users are also provided detailed instructions and a range of settings.

This project explores the efficiency of string processing by implementing and analyzing several core algorithms in Python. It focuses on five string matching methods—including Knuth-Morris-Pratt and Boyer-Moore—alongside Booth’s algorithm for lexicographically minimal rotations. The primary objective was to validate theoretical complexity claims through experimentation, identifying how data patterns influence performance.

The results confirm the predicted linear and quadratic behaviors, highlighting the importance of intelligent preprocessing. While naive approaches struggle with larger datasets, Booth’s algorithm maintained a consistent linear bound, proving essential for circular sequence analysis. Notably, Boyer-Moore demonstrated superior speed on average inputs by skipping text, even though it shares the same theoretical complexity as KMP.

Ultimately, this study shows that while Big-O notation provides good information, the optimal algorithm choice depends on specific data distributions.

Traditional Cyber-Physical System (CPS) security relies on static defense mechanisms that fail to adapt to sophisticated cyber-attacks. We investigate the application of adaptive learning algorithms to model the interaction between attackers and defenders. We also simulate a network environment where an attacker learns to exploit vulnerabilities of the system while a defender applies self-learning techniques to protect the network and prevent from future attack by patching the system.

Preliminary findings show that a defender capable of analyzing past attacks and learn their patterns can significantly increase the "Mean Time to Compromise" (MTTC). This research provides a robust framework for transitioning from reactive response to predictive cyber-defense. Specifically, the implementation of a Self-Learning Defender (SLD) utilizing meta-learning and Dijkstra path-prediction algorithms resulted in a 93% reduction in attacker success rates.

By identifying and pre-emptively blocking preferred lateral movement paths, the framework delayed initial system breaches by over seven-fold, effectively neutralizing the co-evolutionary advantages of AI-driven threats.

The Project

This project focuses on simulating and analysing traffic flow at the Bandon Road Roundabout in Cork, with the aim of identifying congestion patterns and reducing driver waiting times. The roundabout is modelled using SUMO (Simulation Of Urban MObility), with real world traffic demand data sourced from the Transport Infrastructure Ireland data portal. Key performance indicators such as travel time, delay, and waiting time are used to evaluate traffic conditions and show congestion under different scenarios.

The Aim

The overall goal is to reduce waiting times and improve traffic flow through the intersection. To achieve this, three traffic signal control approaches are evaluated: a fixed time sequence, an actuated system, and a genetic algorithm optimised to reduce waiting times by exploiting the roundabout's shape and structure. Each strategy is assessed using the simulation results, allowing comparison on their effectiveness. The findings aim to demonstrate how intelligent traffic control can enhance efficiency at complex urban junctions, and influence future transport planning decisions.

This project was developed as a Serious Game which aims to help teach and practice Python programming with engaging mechanics.

The game incorporates Pedagocial Approaches such as Retrieval practice, Elaboration, Concrete examples, Dual-coding, Interleaving and Spaced practice.

All of the educational content is generated using a Large Langauge Model (LLM). This approach allows for diversity in problems for players of similar skill level, allowing replayability. This also removes the limit for how difficult problems can be.

An adaptive skill algorithm is used to effectively generate problems suitable for the skill level of the player. This allows for the generated problems to not be too difficult or too easy for a player.

Players can view a history of all problems they have answered, allowing for the user to learn from their mistakes. If assistance is required, the player can request a detailed AI explanation regarding the solution to a previous problem.

The game also includes player incentives such as daily challenges and a shop where players can purchase crates which contain items, providing in-game boosts.

This project aims to develop a multimodal AI system for the early detection of lung diseases, with a particular focus on conditions increasingly prevalent among young adults. The system is designed to identify potential lung abnormalities from medical imaging data and provide users with interpretable, personalised insights into their lung health through a conversational interface.

The implemented system integrates a convolutional neural network for image classification, trained using transfer learning on lung datasets. A large language model is employed to combine imaging results with patient-reported symptoms, delivering clinical explanations through a multi-turn conversational interface.

The frontend is built with React Native, enabling cross-platform access across web and mobile devices, supported by a FastAPI backend with MongoDB for storage of user records and conversation histories. This project demonstrates the feasibility of combining CNN models and large language models to make early lung disease screening more accessible to everyday users.

TraceBrain is an open-source platform for monitoring, debugging, and improving AI agent systems. At its foundation is a centralized TraceStore which stores and manages all trace information, capturing agent execution traces at runtime and visualizing them as interactive, hierarchical trees, making it easy to see exactly what an agent did, which tools it called, and where it went wrong.

TraceBrain features an AI Librarian which allows users to query the TraceStore using natural language, and AI-generated trace assessments of agent behaviour through a human-in-the-loop labelling interface. Agents can escalate uncertainty at runtime, triggering alerts that surface directly in the dashboard for review.

Beyond observability, TraceBrain allows operators to retrieve past execution traces as references for trace improvement, and automatically generates targeted training tasks from recurring trace failures, turning past execution failures into actionable improvement material. Together, these capabilities form a closed loop where agent execution can be converted into structured learning that drives continuous agent evolution.

Teaching with a digital whiteboard should feel as natural as teaching with a physical one. In practice, digital tools demand that teachers slow down, switch modes, and fight with interfaces not designed for a classroom. This project set out to change that by building a browser-based smart whiteboard where freehand drawing is the primary input and AI handles the rest.

Whatever the teacher draws or describes — an equation, a diagram, a labelled figure, a formal notation — the system interprets it and produces clean, professional output automatically, adjusted to the subject being taught. Subject-aware presets for Mathematics, Chemistry, Physics, Biology, and Computer Science bias the output towards the conventions of each discipline.

The system also learns from use. Instructions typed by users are anonymously pooled and periodically analysed by AI, which distils recurring preferences into style guidelines applied to every session.

The final implementation is a fully working browser application with Google Drive persistence, a configurable AI backend, and a conversation memory that allows teachers to refine and extend previous outputs interactively.

Healthcare practitioners in high-pressure clinical environments face significant cognitive and administrative burdens, as they must divide their attention between patient interaction, information retrieval, and documentation across multiple systems. Tasks such as drafting referral letters and issuing prescriptions after consultations further increase this workload. This fragmentation disrupts workflow and can negatively affect doctor–patient engagement.

This project addresses these challenges through the design and development of a Medical AI-based Assistant (MAIA) platform. The proof-of-concept system integrates real-time speech-to-text transcription with a medical Large Language Model (LLM) to provide context-aware processing, recommendations, and support for clinical workflows. It enables practitioners to capture and analyse consultations, summarise patient medical history, and generate structured clinical documentation, such as referral letters and consultation reports, within a single interface. By consolidating these functions, the system aims to reduce administrative cognitive load, support more focused patient care, and may assist clinicians in identifying rare diseases.

"Ghost Buses" - scheduled buses that appear on the digital displays at bus stops but never actually arrive - are a frequent frustration for commuters in Ireland. GhostBUSter is a machine learning powered solution designed to eliminate this uncertainty by providing realistic predictions of when the bus will arrive.

The primary objective of the project was to develop an application that leverages National Transport Authority data to forecast bus arrivals around Cork. At its core, the system uses a neural network trained on historical real-time data to generate predictions. By filtering out buses that have been cancelled, deviated from their official route or lost tracking mid-transit, the application ensures that predictions are only made for buses likely to reach the user. The data is served via a Progressive Web App, offering the seamless experience of both a website and a dedicated mobile application. Ultimately, GhostBUSter gives regular commuters a simple, fast, and reliable way to check their bus arrival times without the usual uncertainty or hassle.

Modern software development operates at a speed that has become too much for traditional manual security audits. As teams push code multiple times daily, the risk of overlooking vulnerabilities in Pull Requests increases significantly. This project introduces an automated analysis tool designed to identify security flaws early in the development lifecycle. Built with a Go backend and a Vue.js frontend, the system scans source code for vulnerabilities categorized across a custom framework, ranging from deterministic patterns like SQL injection to complex heuristic-based risks.

The tool implements a scoring algorithm that turns technical findings into an intuitive A–F security grade. By assigning weighted penalties to vulnerabilities, the system provides developers with a clear understanding of their code’s overall health. To bridge the knowledge gap, the tool provides a hybrid remediation strategy: offering immediate fix recommendations while integrating future context-aware, AI-driven suggestions. By integrating security into the CI/CD pipeline, this project allows developers to catch and fix costly mistakes before they ever reach production.

Online communities produce more discussion than any researcher could manually read through. This project is an attempt to make that volume of data actually useful, it is a web-based tool that helps social scientists and digital ethnographers analyse large-scale online conversations without drowning in them.

The system can pull discussion data from Reddit, YouTube, and Boards.ie, processes it through a set of NLP techniques including emotion detection, named entity recognition, and topic clustering, and presents the results through an interactive dashboard. Researchers can explore linguistic patterns, emotional tone, participation habits, and how users interact with each other over time.

The goal was not to replace digital ethnography, but to give researchers a better starting point. A Cork-based dataset drawn from r/Cork, r/Ireland, YouTube, and Boards.ie was used to test and develop the system throughout. It turns out Cork people have a lot to say online.

This project discusses the current weaknesses in modern tools used in vulnerability assessments for industrial control systems. Oftentimes, IT and OT are not considered as a unit which leads to many possible threats being overlooked, which can cause issues ranging from serious financial loss to humanitarian costs.

This project proposes a new method of evaluating ICS that will hopefully be more accurate and manageable for sites, which combines the MITRE ATT&CK framework designed for ICS, and a Bayesian Network.

This approach will ideally combine the legibility of a graph and the information in the MITRE ATT&CK framework, and allow the Bayesian Network to add the dynamism that the previous two lack, and return a score for the vulnerability of each component as well as a score for the likelihood of an attack.

Navigating large museums can be overwhelming, especially during crowded periods when finding specific exhibits becomes a challenge. This project explores how Bluetooth beacon technology can solve this problem by creating a location-aware mobile application that guides visitors through museum spaces.

The project objective was to explore Bluetooth as a method for estimating location, relay information to a cloud-based server and explore routing and path planning under a museum setting. The result is a full-stack application consisting of an Android mobile app, a backend server with a database, and a web-based content management portal.

The mobile app tracks visitor location using Bluetooth beacons and provides navigation to selected exhibits. The backend processes data and provides routes, while the web portal enables museum staff to update content and view information on visitor movement based on beacon data.

The project successfully demonstrates that Bluetooth beacons are a viable solution for indoor positioning and that location-aware systems can enhance visitor experience while providing museums with valuable data on visitor behaviour and exhibit engagement.

This project develops a lightweight, two-stage machine learning portfolio for optimal #SAT solver selection. While model counting is #P-complete, no single solver dominates all structures. This system utilizes Recursive Feature Elimination (RFE) to identify a minimal 48-feature subset, significantly reducing pre-execution overhead compared to traditional 75-feature suites.

The architecture consists of an ExtraTrees "Hardness Predictor" to filter unsolvable instances and a RandomForest "Counter Selector" to route solvable formulas. In final 5-fold cross-validation, the optimized pipeline achieved 1,390 exact counts, strictly outperforming the Single Best Solver (GPMC).

By closing 50.21% of the performance gap to the theoretical Oracle, the portfolio achieved a PAR-2 score of 6,342,331 and saved 550,000 seconds (6.37 days) of wall-clock CPU time. These results demonstrate that a mathematically optimized, dual-model approach effectively mitigates catastrophic timeouts and improves resource utility in real-world model counting environments.

AutoLab is designed to simplify the setup, delivery, and management of programming labs, hackathons, and practical assessments. The project objective was to create a platform where students can start coding immediately, while instructors retain clear control over access, environment consistency and operational visibility.

To achieve this, I built a container-based system with a lightweight web frontend, a Python backend, and Docker-orchestrated VS Code environments. Users can launch preconfigured development environments in seconds, and administrators can monitor running instances, resource usage, and health status through a dedicated dashboard. Authentication protects administrative actions without adding significant complexity.

AutoLab demonstrates that an automation tool can deliver scalable labs with reduced troubleshooting, faster onboarding, and improved reliability. By combining automation, Docker-based development environments, and secure remote access, the project turns lab delivery from a recurring setup burden into a repeatable, student-friendly service that can be adapted to various contexts such as hackathons and assessments.

Vehicular communication is essential for autonomous driving, but malicious actors can broadcast false warnings, hide genuine hazards, or spoof their location. This project explores how autonomous vehicles can intelligently decide which other vehicles and messages it can trust. I built an ETSI‑standard simulation where vehicles exchange Cooperative Awareness Messages (CAMs) and Decentralized Environmental Notification Messages (DENMs). A portion of vehicles execute attacks such as false positives, false negatives, position spoofing, and replay.

Six trust models were developed, each adding sophistication. No Trust accepts all messages as a baseline. Simple Memory maintains trust scores via sensor verification. DST uses Dempster‑Shafer theory to represent belief, disbelief, and uncertainty. Basic Plausibility adds physics‑based checks. Cross‑Validation enables vehicles to share evidence and penalise unconfirmed reports. Organisational‑Social incorporates fleet reputation while ensuring direct distrust overrides.

This project looks at how wearable data can be used to improve the user's work life balance. Stress is a common problem, especially with long working hours, commuting and household responsibilities. While devices like Fitbits can track health data and calendars help organise tasks, they do not work together.

In this project, data from a Fitbit device is combined with tasks entered by the user and their own stress ratings. A machine learning model is used to predict how stressful a task might be based on things like time of day, duration, heart rate, and task type. These predictions are then used to suggest small changes to a user’s schedule.

The system is built as a web application using Flask, with scikit-learn used for the model. The aim is to help users plan their day in a more balanced way and reduce stress.

Managing a chronic health condition is a daily challenge for millions of people. Medications go untracked, appointments are forgotten, and medical documents are scattered across emails, folders, and scraps of paper. Existing apps fail to address this. They are either too complex, too narrowly focused, or lock essential features behind paywalls.

HedgeCare is a cross-platform mobile application designed to solve this problem. Built using React Native and Expo, it runs natively on iOS, Android, and web from a single codebase. It gives users one simple, unified place to track medications, manage appointments, and store medical documents securely.

Privacy is a core principle of the application. All data is stored in compliance with GDPR on EU-based infrastructure. Usability was prioritised throughout development. Every key action was designed to be completed in under three taps, with a calm and accessible interface that avoids overwhelming the user. The app also features a personalised AI-powered greeting, creating a more engaging experience for people managing long-term health conditions.

There are many areas of work involving shift work for which work rotas need to be created. The creation of these work rotas is done either manually by hand or automated using applications. In both of these cases workers often feel unfairly treated with the shift pattern they have been assigned. This project uses constraint programming to explore the automatic creation of work rotas.
In order to take into account for peoples preferences, the system takes in staff preferences, regarding desired days off. These preferences are then handled, along with other constraints restricting the shifts, staff, days worked and requirements, by using constraints implemented with the Java Choco-Solver library, a library used for constraint programming.
The system focuses on fairness over time, attempting to treat staff fairly over a series of weeks. The research involving a questioner examining the impact of the schedules created with this tool could lay the ground work for a system which not only reduces the manual labor but allows improves peoples acceptance of the created work rotas schedules.

This project is a serverless scheduler that is hosted on AWS created to aid in the scheduling and execution of tasks. The frontend uses React and offers two different modes for creating and scheduling tasks. The first mode is a straightforward approach to allow users to create tasks. The second uses a workflow approach where users can arrange nodes and connect their edges to create a workflow.

The backend is a FastAPI service, and Primary data is stored in a PostgreSQL database this data includes titles, scheduling, status and notification emails. The detailed task execution data is stored seperately in a MongoDB as append-only event logs which are keyed using their job ID.

On AWS the API is accessed through an application load balancer that runs on Amazon ECS. The background worker was created using an AWS Lambda function that uses a recurring Eventbridge schedule that periodically selects the due rows in the PostgreSQL database and then selects them to be executed. The notifications uses Amazon SNS for topic notifications and Amazon SES system to send emails about the task execution to the email address that the user provides.

This project aims to design and implement a web-based collaborative LaTeX text editor inspired by the functionality of Overleaf. Primarily, its’ objective is to provide users with a free platform where they can create, edit and compile LaTeX documents and projects. Moreover, it seeks o provide selected features locked behind Overleaf’s subscription model for free, making these features including multi-user collaboration more accessible.

The application is a browser-based code editor with backend services that handle project management, user authentication and LaTeX compilation. Real-time collaboration is achieved using Conflict Free Replicated Data Types (CRDTs) through Yjs and a WebSocket-based server. This is done with the aim of providing conflict-free collaboration for multiple users working on a project at once. The app also utilises role-based permissions to allow users to securely share their projects with others and control access as needed.

Overall, the project builds upon existing tools to achieve its functionality, such as Monaco Editor for file editing, Yjs for distributed synchronisation, external tools such as latexmk for compilation and more.

This project investigates whether machine learning can improve the efficiency of SAT solvers by predicting which variables are most important to branch on early in the solving process. The objective was to design and evaluate a Graph Neural Network (GNN) capable of learning meaningful variable rankings directly from the structure of Boolean formulas expressed in Conjunctive Normal Form (CNF).

An end-to-end pipeline was developed, beginning with parsing CNF instances and representing them as Variable Incidence Graphs. Structural features were extracted for each variable. A lightweight Multi-Layer Perceptron was first implemented as a baseline, followed by a GNN model that leverages graph structure to improve predictions.

Results show that the GNN achieves a strong correlation with true variable importance, demonstrating its ability to learn useful heuristics. These predicted rankings can be integrated into SAT solvers to reduce conflicts and decisions, offering potential speed improvements. The project highlights the promise of combining graph-based learning with combinatorial optimisation to enhance solver performance in real-world applications.

The objective of this project was to develop a reliable, accessible and cost effective communication app for late stage MND patients to interact and communicate with their caregivers and families.

Motor Neuron Disease (MND) is a progressive neurodegenerative disorder that leads to progressive muscle weakness gradually removing a persons ability to move, speak and interact with the world.

Patients generally use Augmentative and Alternative Communication (AAC) devices but they typically have a steep learning curve, unnecessary complexity and a high cost point. This system provides a clear and easy to use communication interface to reduce the stress and cognitive load for the user as their disease progresses whilst also keeping their family connected through real time features.

The system is implemented as a mobile application integrated with a Raspberry Pi, using eye gaze input for hands free interaction. An adaptive ranking algorithm prioritises user needs based on context, while real time notifications keep family members and caregivers informed.

This project investigates the effectiveness of Generative Artificial Intelligence (GenAI) in supporting software engineering tasks across different phases of the Software Development Life Cycle. It examines whether GenAI performs differently for structured tasks with clear solutions, such as debugging or test generation, compared to judgment-based tasks requiring reasoning, prioritisation and trade-off analysis.

A quantitative experimental design is used, where participants complete software engineering activities with ChatGPT assistance. Tasks range from coding activities to higher-level design evaluation and decision-making. Performance is measured using objective criteria such as correctness, along with human-centred measures including confidence, trust and perceived difficulty.

The study aims to identify where GenAI provides reliable support and where human expertise remains essential, contributing to understanding how GenAI can be responsibly integrated into software engineering practice.

This project investigates whether quantum machine learning can contribute to deepfake detection. Deepfakes are synthetic media generated using deep learning techniques and are becoming increasingly realistic, raising concerns around misinformation, fraud, and digital trust. The objective of this project is to evaluate whether a quantum model could be integrated into a modern deep learning pipeline to increase performance.

A hybrid quantum–classical approach was developed in which a pretrained ResNet18 model extracts features from face images. These features are compressed to a low-dimensional space and encoded into a 4-qubit variational quantum circuit, which performs the final classification between real and fake images. The quantum model leverages an exponentially large state space and quantum feature interactions to represent complex relationships between image features.

Results show that the model achieves strong performance on a held-out dataset, reaching 95% accuracy. The findings show that near-term quantum models can be successfully applied to realistic machine learning tasks and highlight the potential of hybrid architectures as quantum hardware continues to develop.

This project investigates whether structure-based code plagiarism detection methods can be applied to identify AI-generated source code submissions in academic settings. The motivation is that advances in AI have made traditional plagiarism far harder to detect, undermining academic integrity in computer science courses.

The research compares three categories of detection algorithm: fingerprinting (MOSS), string/token matching (JPLAG), and structural analysis (ASTK and its weighted variant, WASTK) and a combined algorithm utilising both MOSS and WASTK. Structural approaches are of particular interest as they analyse Abstract Syntax Trees, making them robust against superficial obfuscation like variable renaming or reordered declarations. To generate a testing dataset, a study was conducted with ten final-year computer science students completing Python programming tasks across three rounds, original submissions, low-level plagiarism, and unrestricted plagiarism adapted from prior Java-based research.

Experimentation has been completed to investigate the similarity of AI generated code, using all 5 algorithms in a suite of tests to investigate the hypothesis.

In the digital humanities, encoding historical manuscripts using the Text Encoding Initiative (TEI) XML standard is a notoriously steep learning curve for researchers. The objective of this project was to professionalize and drastically simplify this process by developing a modern, intelligent, and highly accessible TEI Annotation Web Application.

This project bridges the gap between historical text analysis and modern web technologies. The core deliverable is an interactive tagging environment that allows researchers to dynamically load custom ODD schemas and seamlessly apply complex TEI elements, attributes, and relationships directly to raw text without writing manual XML.

A unique and defining feature of this application is its integration with Google's Gemini AI. The system features a schema-aware AI Assistant that acts as an educational co-pilot. It automatically scans raw manuscript text to suggest contextually accurate TEI tags based strictly on the user's localized schema definitions, and provides real-time, plain-English validation and feedback on their XML structures. This radically lowers the technical barrier to entry for digital preservation.

This project researches, designs, and implements a reusable Python package for an approximate dictionary — a data structure supporting non-exact key lookups that return values whose keys are "similar" to the provided input.

Similarity is measured via a configurable distance function suited to the key type: a numeric range for integers, or Levenshtein distance for strings (the minimum number of operations to transform one string into another).

The package implements all standard Python dictionary operations, adapted to accommodate key imprecision. The project also explores extending this concept to other approximate data structures, such as various tree structures.

The demonstration will include the project in action, using the Enron email corpus as a dataset of keys and values to provide a potential use case for the data structure. The names of senders and dates of emails being sent will be intentionally mistaken to show the structures ability to retrieve information despite the error in the input data.

This project has practical applications across any domain involving imperfect or noisy data, such as genetic sequence alignment and geospatial coordinate matching.

Introduction Graph algorithms are fundamental to applications such as networking, social analysis, and optimization. NetworkX is a widely used Python library due to its flexibility and ease of use, but Python’s dynamic typing and interpreted nature can limit performance on large graphs.

Rust offers memory safety without garbage collection and performance comparable to C/C++. This project investigates whether re-implementing key NetworkX algorithms in Rust can improve efficiency while maintaining correctness.

Objectives Analyse NetworkX implementations Re-implement algorithms in Rust Benchmark performance Evaluate trade-offs

NetworkX supports directed, undirected, and weighted graphs using nested dictionaries (G._adj[node][neighbor]). While flexible, this introduces overhead from hashing, object allocation, and dynamic typing.

Algorithms The project focuses on BFS, DFS, and Dijkstra’s algorithm due to their fundamental importance.

Findings NetworkX relies on dict, set, and deque, using iterative designs. However, performance is impacted by hashing, object overhead, interpreter cost, and poor data locality, suggesting advantages for lower-level implementations.

People with Multiple Sclerosis (MS) often experience combined motor, cognitive, and fatigue-related impairments that limit engagement with conventional rehabilitation. Dual-task training, practising motor and cognitive activities simultaneously, is a promising approach, but existing tools rarely adapt to how the user is feeling in real time.

This project develops a augmented-reality rehabilitation prototype using the Meta Quest 3 headset. Users complete kitchen-based tasks such as sorting ingredients, stirring pots, and answering verbal prompts, while the system monitors heart rate and skin conductance through a wearable Shimmer 3 GSR+ sensor. A machine-learning model estimates user stress from these signals and automatically adjusts task difficulty within a closed feedback loop.

The prototype supports three training modes across three difficulty levels, gamification elements, and an in-headset progress dashboard. Feasibility testing with healthy participants evaluates system stability, responsiveness, and usability to determine whether real-time physiological adaptation in mixed-reality rehabilitation is practically viable.

This project developed IVenn, a Python API for the visualisation of Venn diagrams based on a popular tool, InteractiVenn’s, approach to set exploration. Understanding the similarity of sets is common in data analysis, yet interactive set exploration is often separate from the code that produces the sets. This explains the aim of the project, which is to bring InteractiVenn-style exploration into Python, so that users can define or load up to six sets in code and analyse their overlap all in the same place. A main requirement for the project was that the visual model should be maintained under set union operations, so regrouping sets changes the values shown in the diagram without collapsing it into a different layout.

The finished package supports both interactive exploration and script-based analysis of set overlap. It renders fixed-template SVG diagrams, allows regions to be opened and inspected, and supports exporting. Its interactive use is provided through a Qt viewer, and the same overlap structure can also be queried from code too. The project therefore produced a working Python API that makes InteractiVenn-style set exploration available directly from Python.

This project involves the development of a novel framework for splitting large Quantum AI Algorithms over a Distributed Quantum Network. Quantum hardware experiences many challenges including scaling in terms of the number of qubits (quantum bits) and  presence of noise. This project combines the benefits of both DQC (Distributed Quantum Computing) and Heterogenous Hardware. It uses a constraint based framework with entanglement aware cutting to split the different qubits involved in the algorithm across multiple Quantum Processing Units (QPUs). 

The framework was built from a series of performance tests done on a simulated quantum network benchmarked based on execution time, fidelity and resource usage. The framework allocates each qubit to a QPU while minimising inter-QPU communication and ensures efficient use of each QPU's strength. A full simulation to run the proposed solution is also included within this project The novel framework that was developed as part of this project now enables the execution of large and otherwise complicated AI algorithms using DQC combined with Heterogenous QPUs. This overcomes a major challenge observed in Quantum Computing.

Evolving applications, such as augmented reality and Industry 5 rely on demanding workloads. These workloads are typically offloaded to distributed computing continuum tiers to meet their strict latency requirements. Scalable performance evaluation of these systems is beyond the reach of analysis and experimentation, leaving simulations as the key approach to test the performance of these applications. However, existing simulation tools focus on either the network dynamics, computing operation, or lack features required by complex workloads and advanced computing platforms.

ns3-Continuum extends ns3, a widely used network simulator, to enable simulating distributed computing systems supporting advanced workloads, task offloading and state-of-the-art accelerators. Specifically, ns3-Continuum models offloaded tasks as directed acyclic graphs that capture the dependency of processing pipelines. Additionally, ns3-Continuum GPU accelerators support vertical scaling that can be leveraged for energy-efficient computing resource scheduling. The implementation is designed to facilitate extending end-device behavior, accelerator operation, and control plane decision engines.

LLMs have demonstrated remarkable capabilities in natural language understanding, but their substantial computational requirements restrict deployment to those with specialised infrastructure. Quantization addresses this by reducing the numerical precision of model weights, enabling deployment on consumer hardware, but reducing accuracy. RAG offers a potential remedy by supplying external knowledge at inference time, reducing reliance on parametric memory. This project investigates whether RAG can compensate for accuracy loss caused by aggressive two-bit post-training quantization.

An evaluation pipeline supporting both lexical (exact) and semantic (meaning) retrieval was evaluated against the AI2 ARC benchmark (1,172 questions). A no-RAG baseline established a 5.29pp gap between FP16 and Q2_K models. Neither retrieval strategy improved upon this baseline; however, FAISS RAG narrowed the gap to 4.87 points while TF-IDF widened it to 6.57 points. Results revealed that quantized models are disproportionately sensitive to retrieval quality, suffering greater accuracy loss than their full-precision counterparts when retrieved context is noisy or irrelevant.

In this project, the idea of using machine learning on dense wifi networks is explored with the goal of dynamically allocating channels based on reward signals calculated based on changes made by our machine learning agents. This project was based on a prior research article with the goal of replicating its results. Reinforcement Learning (RL) lets agents observe environments and make changes based on reward signals. This project focuses on Proximal Policy Optimisation (PPO) and Deep Q Network (DQN) algorithms, using NS3 for network simulation.

With three distinct scenarios outlined, low, medium and high density with set numbers of stations, access points and users. The simulator runs with one of the density scenarios configured and the agent observes this space. After a set time interval the agent recieves a reward signal, which is a calculation using key performance indicators from the access points, and changes channel allocation based off results. The result shows how these algorithms can be implemented in this way and properly gather and calculate the necessary data and show real change in the simulation.

re write this to support the github markdown style sheet "Final year project allocation is often a manual and time-consuming process involving endless email chains and spreadsheets, This project presents a web-based Academic Project Allocation System designed to automate and streamline this process while ensuring fairness and transparency.

The system provides a centralised platform where students can browse available projects, submit ranked preferences with supporting comments, receive and track their allocation status and upload their project deliverables. Supervisors can keep track of students who bid on their projects, rank them, manage their projects and more. Administrators have full control over the allocation cycle, including deadline configuration, tie-breaking rule configuration and the choice between three allocation modes: centralised, hybrid, and distributed.

Overall, the developed system provides a practical and flexible solution to the challenges of project allocation and it is designed to support all stages of the lifecycles, from project creation to the uploading of the final project.

Stress is increasingly recognised as a serious health concern, yet most detection methods rely on self reporting which is slow, subjective and impractical in real world settings. This project replicates and extends existing research by Campanella et al., developing a machine learning pipeline that classifies stress from wristband sensor data (heart rate and skin conductance) collected from 29 participants, opening the door further to real-time stress detection.

Three main methodological extensions are introduced. First, the set of meaningful pieces of information extracted from the raw signals was increased from 27 features to 39. Second, the model is calibrated to each individual’s own resting baseline, rather than treating every individual's relaxed to stressed thresholds the same. Third, data from the same person never appears in both training and testing, eliminating a false inflation of results.

Using different sliding window configurations, the extended pipeline consistently improved performance, achieving accuracy of up to 89%, a 12.5 percentage point improvement over the original pipeline, suggesting that a reliable stress detection wearable is within reach.

This project develops a secure smart lock for an HonourBox: a community drop-off and retrieval box for local deliveries and shared access. The aim was to investigate whether post-quantum cryptography could be made practical on low-cost embedded hardware while still supporting real physical access control. A classical ECDSA baseline and a post-quantum ML-DSA implementation were developed and compared on Raspberry Pi hardware to study both security and performance.

The final prototype combines an Android app, a local Flask backend, a Raspberry Pi lock controller, a servo-actuated latch, and a reed-switch lid sensor. Lightweight optimisations, including CBOR encoding, challenge batching, caching, and pre-warming, reduced payload size and unlock latency significantly. The system now supports authenticated unlock, lid-open detection, lid-close detection, and automatic relocking. The result is a practical working quantum-safe access-control prototype that shows post-quantum security can be integrated with real embedded hardware for future community delivery and unattended access systems.

This project investigates the performance of large language models (LLMs) in deterministic problem-solving. The problem type is constraint-based calendar scheduling. LLMs have strong abilities in natural language interpretation and reasoning, but they are still probabilistic in nature as they generate text based on likely next tokens. This means that they can struggle with complex tasks requiring reliable decision making or strict constraint satisfaction.

To evaluate LLM performance in scheduling tasks, an LLM agent was developed that can understand users' scheduling requests, break them down into constraint satisfaction problems, gather any additional information that may be required, and update relevant Google Calendars. The system also includes a constraint solving program that must verify all scheduling solutions before any action is taken to implement them.

Using this system, tests were carried out with increasingly difficult problems on a variety of LLMs. These evaluated the problem-solving capabilities of each model and explored the increase in performance with schedule verification. The project's resulted in a functional AI-driven Google Calendar management system.

Reliable mobile connectivity on moving trains remains a challenge due to frequent cellular handovers caused by rapidly changing network conditions. This project explores if machine learning can be used to predict future handover events, with the aim of improving on-board internet connectivity for passengers by facilitating more intelligent network management.

A dataset was created using real world measurements collected on the Dublin Area Rapid Transport (DART). Cellular network signal metrics were combined with spatial and temporal features derived from GPS data. A Mixture-of-Experts (MoE) model was chosen for its suitability to the heterogeneous nature of rail routes, capturing varying network behaviour across different locations and conditions. This allowed the system to specialise in distinct connectivity patterns observed along this route.

The current results indicate that handover events and link quality exhibit strong spatial structure, and that predictive models could leverage this to anticipate future network conditions. This work provides a foundation for more reliable and intelligent connectivity in high-mobility environments.

RISC-V is an open-standard, royalty-free ISA whose modular design enables custom, domain-specific implementations. While this flexibility is a key strength of the RISC-V ecosystem, it has resulted in most open-source drivers and testing frameworks being tightly coupled to specific implementations, limiting portability and reuse. This project develops a bare-metal driver library and testing framework targeting core RISC-V components, including the CLINT, PLIC, CLIC, PMP, and core CSRs. Supporting both 32-bit and 64-bit architectures, register base addresses are resolved at compile time via a user-provided configuration file, enabling retargeting without modifying driver code. The targeted components configure local and external interrupts, define protected physical memory regions, and manage system trap handling and memory access control. A test API sits above the driver layer, decoupling hardware tests from implementation-specific details. By wrapping driver functions, tests can be written and reused across different RISC-V platforms without requiring detailed hardware knowledge.

Stock market forecasting typically relies on black-box neural networks that offer no insight into their predictions. This project investigates whether symbolic regression can discover interpretable, closed-form mathematical equations from financial data, giving stakeholders formulas they can inspect and audit.

Two complementary approaches were implemented: a Symbolic Neural Network, whose hidden units apply named mathematical functions such as sin, multiply, and square, trained with dynamic L1 regularisation and genetic programming via gplearn, which evolves expression trees through crossover and mutation.

Both methods were validated on physics benchmarks. The Symbolic Neural Network recovered the simplified projectile motion equation exactly, and genetic programming recovered the full physical form. Applied to stock data with enriched technical indicators, the Symbolic Neural Network found no valid equation across all regularisation strengths; a result consistent with the efficient market hypothesis and itself a meaningful finding.

Dunkettle Interchange in Cork City is one of the country's most busy road networks. It has recently had a large redesign which opened in February 2024 with the aim to reduce traffic congestion and improve safety. Despite an over €200 million investment in the redesign, delays and queuing still occur during peak hours. This project aims to analyse Dunkettle Interchange using SUMO traffic simulator and find the causes of the congestion.

A model of the interchange was developed based on real world road geometry and hourly traffic data from Transport Infrastructure Ireland. Python tools were created to distribute traffic demand and flows across the network. Dynamic routing techniques were used to allow vehicles to find the best path in changing traffic conditions.

So far, the model can visually suggest important areas that could cause the delays at Dunkettle, such as driver behaviour, road capacity and road merges. The next steps are to implement traffic measuring strategies to verify and prove using measured values and definitions, what is causing congestion, where the sources are and how busy the interchange must be for a traffic breakdown to occur.

This project focuses primarily on running optical object detection and classification models on a Raspberry Pi Model 4 for use in quality assurance in manufacturing.

For object detection, the project explored several different model frameworks which could be used such as Ultralytics YOLO and ResNet within the PyTorch ecosystem. The model that was chosen in the end was the Ultralytics YOLOv8s. This model had a good balance between speed and accuracy, maintaining over 90% confidence on the required labels as well as being able to complete analysis in less than 3 seconds. The YOLOv8n and YOLO26 models were also examined but were unsatisfactory when compared to the YOLOv8s Model.

The classification model that was chosen is a custom-built Convolutional Neural Network developed within the PyTorch ecosystem. It was able to complete inference within 0.2 seconds while maintaining good accuracy.

This project also includes a mobile app written in React Native which can connect via BlueTooth to the device for real-time updates, As well as a server allowing the app to view data from the device and allows users to make changes to the device wirelessly from the mobile app.

This project develops an automated tool to analyze algorithm performance by instrumenting Python code at runtime. While traditional algorithm analysis relies on a theoretical "bean counting" approach to estimate worst-case complexity, this system provides a practical alternative by collecting operation-level counts during execution.

The tool uses Python's Abstract Syntax Tree (AST) to automatically modify code and insert counters without altering the original structure, allowing it to make syntax-aware modifications. It supports common algorithm categories such as:

• Sorting
• Searching
• Graph algorithms
• Matrix algorithms
  The system is designed to be easily extensible.

It includes:

• A command-line interface
• An interactive web app built with Streamlit

Overall, the project bridges the gap between theoretical complexity analysis and real-world execution, offering an educational platform for students to explore how algorithms behave in practice.

Door-to-door and street-based charity fundraising are widely used, but fraudulent collectors reduce public trust and make verification difficult. This project presents a web-based system for real-time verification of charity collectors using QR codes.

Authorised collectors receive time-limited, cryptographically signed QR tokens linked to specific campaigns. When scanned, the system validates the token, checks expiry and revocation status and confirms campaign and collector details, providing a clear result to users.

To strengthen fraud detection, the system includes curated fraud alerts and a community reporting feature. Users can report suspicious activity or confirm legitimate collectors, with submissions reviewed via an administrative interface before publication.

By combining secure token verification, campaign validation and community-driven reporting, the system offers a practical and user-friendly approach to improving transparency and trust in charitable fundraising.

Modern social media platforms rely on centralised cloud infrastructure to distribute video content, raising concerns around privacy, data ownership, and internet dependency. This project explores an alternative approach: a mobile application enabling users to create and share short-form video content entirely offline, on a peer-to-peer basis.

The app allows users to record video snippets of up to ten seconds, splice them into a single highlight video, and distribute it to nearby devices. Discovery is handled via Bluetooth Low Energy, with connections automatically upgraded to WiFi Direct for fast video transfer. Epidemic routing with Summary Vectors ensures videos propagate efficiently across the network without redundant transfers, while a 24-hour TTL automatically purges content from each device.

The system is implemented in Kotlin for Android, leveraging CameraX for recording, FFmpeg for splicing, and Room for local persistence. Evaluation combines physical device testing with OMNeT++ network simulation to measure delivery ratio, latency, and routing overhead at scale.

The agrep_rust tool is a Python package that brings agrep string matching capabilities to Python users. Unlike traditional command-line tools that only display results, agrep_rust returns match offsets directly to Python, enabling further programmatic processing.

Implemented in Rust, the library achieves C-level performance with Rust's inherent safety guarantees. The tool operates as a smart dispatcher: an engine builder analyzes user input (patterns, edit distance, case sensitivity etc.) and selects the optimal algorithm from implementations like fuzzy Bitap, Wu-Manber, Boyer-Moore, and wrappers for highly optimized Aho-Corasick, Regex, and Two-way matchers. Once preprocessed and constructed, engines can be used multiple times.

Currently supporting ASCII input for maximum performance, agrep_rust prioritizes throughput and speed of search. By combining Rust's speed with Python's flexibility, agrep_rust gives Python developers efficient, programmatic access string matching tool.

This project is a household energy simulation platform built for Irish residents, which are facing one of the EU's highest electricity costs. Before committing to solar panels, a home battery, or a dynamic tariff, users can model their specific setup and see exactly what they'd save under different configurations.

The web application pairs a React interactive dashboard with a Python backend built around constraint programming. Given a household's assets, that is, PV generation capacity, battery size, and flexible loads like washing machines or EV charging, the optimizer finds the optimal schedule against Irish electricity prices. Users can explore trade-offs visually: when to charge the battery versus export to the grid, how much a larger panel array changes the economics, whether a dynamic tariff beats a flat rate for their usage pattern.

The technical core is a CP-SAT constraint model that respects physical and preference constraints while minimising costs. Results feed into dashboards designed for interpretation without any prior energy expertise.

Clanware: A Decentralized Social Media Platform

Clanware is a decentralized social media application that combines the community-focused features of platforms like Discord and Twitter without relying on centralized infrastructure. Built on Ethereum Swarm for decentralized storage, Fair OS DFS for distributed file management, and the Nostr protocol for peer-to-peer communication, Clanware allows users to create and join clans — community groups with dedicated media channels for sharing and discussion. Each clan functions as an independent, self-governed space where members can post updates, share media, and interact in across multiple channels. By leveraging these decentralized technologies, Clanware gives users full ownership of their data and communities, free from the control of any single platform provider, while ensuring censorship resistance and improved privacy.

Malspect is a container-based malware analysis sandbox that executes untrusted binaries in an isolated environment, and produces behavioural risk assessments from syscall-level telemetry. The project investigates whether containerization, combined with a user-space kernel, can provide a viable alternative to traditional VM sandboxes for lightweight dynamic analysis.

The system uses Podman with gVisor (runsc) as the container runtime. gVisor intercepts every syscall in the user space, providing both strengthened isolation and complete observability without exposing the host kernel to malware. Captured syscall traces are parsed and evaluated by a rule-based heuristics engine that maps observed behaviours to the MITRE ATT&CK framework, assigns severity tiers based on kill-chain position, and computes a composite risk score classifying samples as benign, suspicious, or malicious.

This project presents a QR-code-based restaurant ordering system designed to enhance customer experience and improve operational efficiency. Customers scan a QR code at their table to access a digital menu, browse items, place orders, and complete payments through an integrated online payment system.

The application is built using a web-based architecture with a Python (Flask) backend, a MySQL database, and a responsive frontend developed with HTML, CSS, and JavaScript. It supports real-time order processing and status tracking, reducing waiting times and minimising staff workload.

The system is also designed to support analytics by collecting transactional data such as orders, timestamps, and payments. This enables insights into menu performance, peak hours, and overall restaurant operations.

Overall, the solution demonstrates how digital technologies can modernise restaurant workflows and support data-driven decision-making.

Large language models perform strongly across many tasks, yet their reasoning abilities remains largely unevaluated. As deployment in decision critical settings grows, evaluations still prioritise answer accuracy over the validity and coherence of reasoning. This project introduces a reasoning benchmark and a dual evaluation framework measuring both answer correctness and reasoning quality.

Eighty open-ended questions were developed across four subcategories: number series, arithmetic word problems, verbal analogies, and syllogisms. To limit memorisation, items were adapted from aptitude tests with varied values, wording, and patterns. Three Ministral models were evaluated under answer-only and chain-of-thought prompting, with reasoning quality assessed using the ROSCOE framework.

CoT prompting improved answer accuracy across all models, though gains varied by difficulty and category. ROSCOE results showed reasoning was generally grounded and informative but often redundant with weak step-level coherence. These findings indicate that CoT driven accuracy gains do not fully reflect reasoning quality, highlighting the need to evaluate reasoning processes alongside final answers.

Traffic congestion and vehicle emissions are major problems in urban traffic management. This study focuses on traffic congestion in Dublin city centre and the related carbon dioxide emissions. It examines how different traffic signal control methods affect traffic efficiency and environmental performance. Using the SUMO simulation platform, the study compares fixed-time signal control, Q-learning, and three DQN methods with different reward functions. The adaptive controller changes signal phases in real time to improve traffic flow and reduce emissions. The results show that reinforcement learning-based control performs better than fixed-time signals in several aspects. The best DQN reward model reduced carbon dioxide emissions by 25.7%, increased vehicle throughput by 5%, and reduced average waiting time by 16.5%. The comparison of different DQN reward functions also shows that reward design affects the balance between traffic efficiency and emission reduction. This study shows the potential of machine learning in intelligent traffic signal control and offers a useful reference for future low-carbon urban traffic optimisation.

GrocerARy is an Android application that brings augmented reality and real-time machine learning to the everyday task of grocery shopping, overlaying product information directly onto the live camera view without disrupting the user experience.

At its core, the app supports two inference modes: on-device detection using a custom-trained YOLOv8 model exported to TensorFlow Lite, and server-side inference via a FastAPI backend with GPU acceleration. This dual-mode architecture enables a structured evaluation of the trade-offs between portability and raw performance, with optimisation strategies including frame skipping, resolution scaling, and confidence thresholding applied across both modes.

Beyond object detection, the app integrates barcode scanning through Google ML Kit, real-time nutritional data retrieval from the Open Food Facts API, and a persistent shopping list that visually highlights matching products in the camera view.

The project demonstrates that capable, low-latency AR inference is achievable on consumer Android hardware, while server-side processing offers a meaningful performance ceiling for environments where connectivity is reliable.

Abstract

This project investigates the use of Deep Neural Networks to classify malicious network traffic and improve the detection of suspicious behaviour within modern networks.

The system is integrated into an open-source Intrusion Detection System, allowing network traffic to be analysed and classified in a more intelligent and automated way. To make the results easier to understand, a frontend dashboard is used to display the model’s predictions in a clear and accessible format.

In addition, the project applies the SHAP explainable AI framework to provide insight into how the model reaches its decisions. This increases transparency, helps users understand why traffic is flagged as suspicious, and makes the overall system more trustworthy for practical cybersecurity use.

This project set out to build a real-time, reusable framework for analysing a single user's pose from a standard camera and turning noisy 2D pose landmarks into clear, interpretable feedback. The main objective was to avoid hard-coded, domain-specific logic by using configurable templates that define rules, thresholds, and feedback, allowing the same core pipeline to be reused across different applications.

The implemented system uses MediaPipe Pose Landmarker to detect body landmarks and derives geometric features such as joint angles, orientations, distances, bearings, and key reference points. These features are evaluated by declarative rules to support live on-screen feedback, and the framework is delivered through a browser-based interface with schema validation, hot reload support, and safe template handling.

To make live feedback more stable, the system uses low-latency smoothing together with dwell and cooldown timing so brief jitter does not cause flicker or double counting. The result is a modular template-driven pipeline that supports posture monitoring, exercise feedback, rehabilitation, and ergonomics scenarios without requiring changes to the source code.

The API Gateway for Micro-services is a system that allows developers of distributed systems to aggregate their micro-service API endpoints under a single point of entry. It facilitates consistent application of security policies across groups of endpoints, routes traffic to the correct API endpoints, and gives detailed feedback on the behaviour of changes to a developers gateway configuration.

The gateway provides a suite of core features, including request routing, Basic Auth authentication, rate limiting, logging and observability through a Grafana dashboard. A management UI was developed to allow developers to configure routes and policies associated with their micro-services. A key difference between this API Gateway and existing solutions is how the gateway handles errors using semantics analysis. Changes are analysed by the system and presented to the user as feedback on how the changes are expected to affect the system, as well as what errors are likely to occur.

The objective of this API Gateway is to solve the problems of distributed systems, while also providing an educational environment for developers to learn the core functions of these types of systems.

This project is a full-stack system developed to optimize the daily operation of the billiard hall. Users can log in, book tables online, view the status and location of the tables through the table map, and manage the booking records more clearly and conveniently. The aim is to make the booking process and the operation of the billiard hall more efficient.

This project is not merely a simple booking website. It includes a credit scoring system to reduce no-shows, a community module where users can post and interact, and a notification center for community messages and system notifications. These features make it not only a booking tool, but also a comprehensive user service platform.

In terms of management, this system provides unified management functions for billiard tables, bookings, and users. Additionally, the system includes a dashboard for presenting key data, which helps managers understand the situation and optimize daily arrangements. By integrating user services and operational tools into one platform, this system enhances management efficiency and improves the overall user experience.

This project presents the design and implementation of a multi-tenant blog platform with resource aware autoscaling, while also deployed onto Google Cloud Platform using the load balancer provided by Google. The information of the virtual machine simulation using docker containers are fetched using Docker API.

The system deploys a containerised architecture comprising a React frontend, FastAPI backend instances, a PostgreSQL database, and an Nginx load balancer. Multi-tenancy is enforced at the data layer through tenant-scoped database records, while a dedicated routing service decodes JWT tokens to direct each request to its assigned backend.

The Google Cloud Implementation uses CloudSQL and Google Cloud Bucket (Storage). The platform provides constant uptime for the application.

This project is about further automating troubleshooting problems. The research focuses on combining LLM information extraction with active feature acquisition. In simple words, the system extracts structured information from text records of previously solved problems and then it uses that knowledge to ask users a series of targeted questions to diagnose an unseen problem and suggest a diagnosis if it is confident in it.

The evaluation shows that the system identifies key features from text records with approximately 90% accuracy. Even when working with these automated extractions, the system performs reliably; in a study of simple medical cases with 6 illnesses featured in the diagnoses, it correctly identified the primary diagnosis 73% of the time and included the correct answer in its top two choices 99% of the time.

You can interact with the system yourself at our showcase day. We have a web demo available where you can answer questions and see the system update its findings in real time.

We typically perform a speedtest when our network is constantly failing e.g. video calls drop, downloads slow and video steaming buffers. Yet we have no way to diagnose the problem or predict when it will happen.

Cellular network performance is a critical factor in the quality of user experience for all mobile users. As more bandwidth intensive mobile applications increase, the gap between user expectations and network performance has widened. While solutions exist, they only provide measurements without actionable guidance or insights.

This project tackles this issue by developing a mobile network monitoring system integrating background measurement testing, historical analysis, geolocation mapping, and context aware recommendations.

The system captures comprehensive network metrics through device side measurement and generates contextualised recommendations based on network conditions, device state, and historical trends.

For the first time, users can see when and where their network fails and understand why without having to even open the app.

Parkinson's disease affects over 8.5 million people worldwide, and its severity is typically assessed through clinical rating scales that depend on trained specialists and subjective judgement. This project investigates whether wearable sensors can offer an objective, scalable alternative.

Using data from 20 participants collected by the Tyndall National Institute, the project extracts movement features from just two body-worn sensors, one on the wrist and one on the ankle, during the Timed Up and Go clinical mobility test. Rather than relying on a single stopwatch time, the TUG is segmented into five phases using video annotation, and 238 features are engineered to capture phase-specific movement characteristics such as gait variability, turning dynamics, and transition smoothness.

Machine learning regression models are trained to predict clinical severity scores from these features, with Principal Component Analysis applied to address the high-dimensional, small-sample challenge. Results demonstrate that a minimal sensor configuration combined with phase-aware feature engineering can capture movement patterns meaningfully associated with Parkinson's disease severity.

Switching from Python to Java can often be a frustrating experience for developers, mainly because of the steep learning curve imposed by the strict type system and complex object-oriented programming principles. This project addresses this issue by introducing a standalone, configuration-free desktop educational platform.

The platform is designed with a dual-client architecture and contains a Teacher Studio for lightweight course management and a highly interactive Student Dashboard. The student-side app provides a distraction-free learning environment with gamified progress tracking (XP scores), an interactive Python-to-Java Survival Guide, and dynamically generated quizzes.

In addition, the platform integrates a custom, secure Java Execution Engine equipped with strict timing and output constraints. This securely sandboxes student code against endless loops and system crashes, providing a fluid and easy-to-get-started hands-on learning experience.

Location-based technologies, such as GPS and cellular location on smartphones, are playing an increasingly important role in border control and immigration governance. These technologies support immigrants through navigation, communication, and service access, while also helping to monitor movement, restrict mobility, enforce border control, and support administrative decision-making.

The project provides a systematic literature review and systematic analysis of existing location-tracking technologies used in border and immigration environments. The focus is on the technology itself, the generation and processing of location data, data streams in digital systems, and the risks and limitations associated with these practices.

This project offers a structured overview of location-based systems currently used in immigration governance and examines how the same technologies operate both as auxiliary tools and as monitoring and control mechanisms.

Large language models (LLMs) are increasingly embedded in everyday technology, yet their evaluation remains overwhelmingly English-centric. Low-resource languages such as Irish are routinely excluded from mainstream benchmarking, leaving a critical gap in our understanding of how modern AI systems perform in these linguistic contexts.

This project presents the Irish LLM Leaderboard, a web-based platform that evaluates and ranks large language models across five Irish-focused benchmarks: IRLBench, a Leaving Certificate-derived reasoning dataset; IrishQA, a multiple-choice question answering dataset; Irish-BLiMP, a linguistic minimal pairs benchmark; IrishMultiJail, a safety evaluation dataset; and Irish GDPval, a general language proficiency benchmark.

The platform is built using Python and Gradio, deployed via Docker, and draws live data from a dynamically updated source. It gives researchers and developers a transparent, reproducible, and openly accessible tool for assessing LLM capability in Irish supporting the broader goal of ensuring AI development does not leave minority languages behind.

Large language models have fundamentally changed how we build software. They can reason, search for information, and interact with tools using plain English. But that same flexibility creates a serious security problem. Attackers can slip malicious instructions into a model's input, tricking it into leaking sensitive data or behaving in unintended ways. Standard filters weren't built for this kind of threat because natural language is too flexible to be caught by simple rules.

This project tackles that problem with a layered detection system working together. Obvious attacks are caught early by fast, rule-based filters. Subtler attacks are flagged by a machine-learning classifier trained to detect suspicious patterns. Anything else is escalated to a final LLM-based layer that reasons about intent more carefully.

The result is a system that's both accurate and efficient, catching more attacks with less unnecessary blocking, fast enough for real applications. Its strength comes from combining complementary strategies into one cohesive pipeline, giving developers a practical foundation for building AI-powered tools that are secure against increasingly common adversarial threats.

A study of the Random-to-Top card shuffling scheme, a simple list shuffling scheme wherein an item is selected at random and moved to the top of the list. This often arises as the Move-to-Front rule for cache maintenance in computer science.

Building upon the results of the work done by Persi Diaconis, and others, to produce a Markov Chain that models Random-to-Top shuffling. The Markov Chain can then be used to assess convergence speeds for a number of variations of the shuffle.

The main output of this project is a Python based Dash application that provides a walkthrough of the mathematics behind the Markov Chain, while allowing users to explore the properties of the shuffle in particular. It makes use of Plotly visualisations and Manim animations to create an interactive educational environment.

Non-completion outcomes are a key indicator of safety and welfare in National Hunt racing. This study presents the first cross-jurisdictional analysis of safety-related non-completion across the UK, Ireland, and France during the 2022-2023 jump racing years. An automated scraping pipeline assembled a dataset of 112,367 horse-starts across 12,397 races, which was cleaned and standardised across jurisdictions.

A horse-level logistic regression model and a race-level quasibinomial model were fitted, incorporating country-by-covariate interactions to assess whether risk factors differed across jurisdictions. Substantial jurisdiction-specific differences were observed. Most notably, Fence races carried elevated non-completion odds in all three countries, but the effect was greatest in Ireland. Distance effects were strongest in France and largely absent in the UK, while Weight showed a protective association in France that was absent elsewhere.

These findings demonstrate that non-completion risk reflects jurisdiction-specific differences in race format and course design, supporting the need for tailored welfare and regulatory strategies across European National Hunt racing.

Informal caregivers provide unpaid support to sick, disabled or elderly relatives, often at significant cost to their own health. As populations age, understanding which caregivers face the greatest health risk is increasingly important. Existing research treats caregivers as a homogeneous group, obscuring risk across individuals with different personalities, caregiving intensities and biological profiles.

This project applies six clustering algorithms to identify distinct health risk profiles among informal caregivers using data from the UK Household Longitudinal Study, spanning demographics, caregiving intensity, psychological wellbeing, lifestyle and biomarkers.

Three profiles emerged consistently. A Psychologically Distressed group characterised by high neuroticism and distress, a high-intensity group defined by in-household care, low income and high care hours and a low-risk group. Long-term illness rates differed significantly across profiles.

Cross-method convergence confirms the structure reflects genuine population heterogeneity. Findings support targeted caregiver interventions rather than population-level approaches.

This project combines reinforcement learning with classical control to design and stabilise a simulated quadcopter system. The hybrid approach ensures both adaptability and reliability under varying conditions. Simulation environments such as Gym and PyBullet were used to train and test the system, with a focus on learning control policies for stable flight. Extensive testing was carried out under disturbances including wind, reduced engine power, and increased mass to evaluate robustness. A key finding was the identification of a critical point where performance stops improving and may degrade. This highlights important limitations and challenges when applying these methods to real-world, unpredictable environments.

This project develops an interactive Mathematica notebook designed to improve understanding of Markov chains through visualisation and experimentation. While the theory of Markov chains has been well established, concepts such as convergence, reversibility, and long-term behaviour are often difficult to grasp from the textbook material alone. The objective was to create a tool that allows users to explore these ideas dynamically and build intuition by going through the markov chain process and understanding what happens at each step. The notebook introduces key concepts including transition matrices, graph representations, Spectral Gap, Mixing time and stationary distributions, before examining classical models such as PageRank, random walks, the Bernoulli–Laplace model, Card shuffling and the Ehrenfest urn. These examples are used to investigate important properties including ergodicity, reversibility, spectral gap, and mixing time. The project demonstrates that interactive visualisation can significantly enhance understanding of stochastic processes by linking theoretical results with observable behaviour

Large language models achieve strong performance but are computationally expensive to deploy due to their size and large number of parameters. This project investigates whether compression techniques originally developed Convolutional neural networks transfer to transformer-based models. VGG16 and RegNet were used to evaluate pruning, low-rank compression and quantisation using accuracy and model size. These methods were then applied to FLAN-T5 with LoRA fine-tuning and evaluated using ROUGE-L metrics. Results show that quantisation and low-rank compression remain stable across architectures, while pruning is more sensitive in transformers, highlighting the need for architecture-aware compression strategies.

Musculoskeletal disorders such as knee osteoarthritis (OA) are a major global health burden, causing pain, reduced mobility, and long-term healthcare costs. Traditional diagnostic methods like X-rays and MRI provide useful insights but are limited by high cost, limited accessibility, and their inability to monitor joint function dynamically.

This project investigates acoustic emission (AE) monitoring as a non-invasive, real-time approach for assessing knee health. AE sensors capture sound waves generated during movement, reflecting cartilage condition, joint lubrication, and mechanical interactions within the joint.

The objective is to determine whether unsupervised clustering techniques can classify knee health based on AE signal features. Time- and frequency-domain features were extracted from signals recorded during controlled knee movements and analysed using K-Means and Principal Component Analysis.

The study evaluates the effectiveness of these methods in grouping acoustic patterns and their potential for non-invasive knee joint assessment.

Multi-Agent Pathfinding (MAPF) is the problem of planning collision-free paths for multiple agents simultaneously, with applications in automated warehouses, airport vehicle coordination, and service robotics. Classical MAPF assumes all agents are identical (same size, same speed) which limits its applicability to real-world scenarios.

This project extends two well-known MAPF algorithms, Prioritized Planning and Conflict-Based Search, to support agents with heterogeneous speeds. The extensions handle constant and variable speeds, acceleration and deceleration dynamics, and an additional collision type called the following conflict. Time is discretized into micro time-steps, allowing faster agents to traverse cells at different speeds while preserving MAPF's synchronized discrete time structure. Experimental results show that variable-speed extensions incur moderately higher run-times and expanded search spaces compared with their fixed-speed counterparts, while producing solutions of comparable quality.

Migraine is a recurrent neurological disorder affecting approximately 12% of adults worldwide and ranking as the second leading cause of disability globally. Current treatments are reactive, with triptans losing efficacy within hours of headache onset. This project investigates whether migraine attacks can be predicted from physiological signals recorded before symptom onset, using data from the MigMark study conducted at Tyndall. Laboratory EEG and continuous Empatica E4 wearable data were collected from 16 participants across 72 recording sessions.

Sessions were labelled as pre-ictal or inter-ictal based on self-reported migraine diaries. Spectral band power, relative power and hemispheric asymmetry features were extracted from EEG recordings, while heart rate, electrodermal activity and skin temperature features were derived from wearable data. Three parallel tracks were evaluated: EEG, Empatica and multimodal. All experiments used participant level data splitting with LOSO-CV and a test set to ensure honest generalization estimates.

Modern AI has become increasingly dependent on large language models that demand substantial computational resources, limiting accessibility and raising environmental concerns. This project investigates whether orchestrating multiple small language models (SLMs) can close the performance gap with larger systems, without the associated resource cost.

Two collaborative strategies were developed. The first, a multi-model voting framework, had three SLMs independently generate solutions before collectively selecting the best. The second, a cross-reflection pipeline, assigned each model a distinct role: planning, refinement, and implementation.

Voting consistently underperformed the strongest individual model, DeepSeek Coder, which achieved 56% accuracy. A key finding was a profound positional bias: models systematically avoided middle-positioned candidates regardless of code quality, receiving just 12% of votes compared to 41% and 47% for first and last positions respectively. The cross-reflection pipeline achieved 48% overall, but outperformed all individual models on harder tasks, improving from 30% to 40% on both medium and hard difficulty levels.

This project focuses on the development of a web-based platform for forecasting prices in the Irish Electricity Market. The platform is designed to both store and manage market data and generate future electricity price predictions using a range of predictive models. A key objective of the project is to compare the performance of different models in order to identify which approaches are most effective for forecasting electricity prices.

The website includes an API that provides structured access to all collected data and is documented according to the OpenAPI standard. It also features interactive visualizations that allow users to explore historical time series data in detail. In addition, the platform includes a model comparison page where users can evaluate forecasts made 24 hours ahead against actual Day Ahead Market prices. Performance metrics such as Mean Squared Error (MSE) and Bias are provided to support model evaluation and comparison.

National Hunt racing presents inherent welfare risks, as horses must jump obstacles at speed across the full race distance. Non-completion is a key indicator of safety, and understanding what drives it is essential for evidence-based policy.

This project analyses non-completion rates across Great Britain, Ireland, and France using a dataset of over 11,000 races and 110,000 race entries, scraped from Sporting Life and rigorously cleaned to ensure cross-country consistency. Exploratory analysis examined how factors such as horse age, ground conditions, and race type relate to non-completion risk.

Logistic regression models were built at both the horse and race level to quantify these relationships. The models revealed that France has the highest non-completion risk of the three countries. Younger horses, extreme ground conditions, and steeplechase races were all associated with elevated risk.

These findings offer racing authorities and welfare bodies a clear, interpretable evidence base for targeting the most modifiable risk factors. The project also points toward future work, such as developing tools to flag high-risk race conditions before they occur.

Csikszentmihalyi defines flow as a state of heightened focus in which individuals are fully engaged in an activity, experience a sense of control, lose awareness of time, and tend to perform at their best (Csikszentmihalyi, 1997). The project aims to explore whether dynamic difficulty adjustment helps to induce flow state in a virtual reality gaming environment and if so, does flow state improve a person’s performance in the game. A VR shooting range prototype was developed using Unity, featuring two versions of the same task: an adaptive mode, where difficulty adjusts in real time based on player performance, and a static mode with a fixed level of difficulty. This design allows for direct comparison of how adaptive systems influence user experience. As both a developer and data analyst, I contributed to building the prototype and analyzing user data to generate insights for more engaging VR design. Using a mixed-methods approach, including questionnaires and semi-structured interviews, my project also examines which specific game elements such as challenge-skill balance, feedback and immersion most strongly contribute to perceived flow.

This project investigates the role of Dynamic Difficulty Adjustment (DDA) in facilitating flow state within virtual reality (VR) gaming. Flow, defined as a state of absorption and optimal performance, is closely linked to engagement, yet limited research explores the interaction between flow, VR, and DDA. This study examines whether adaptive difficulty supports flow and whether increased flow correlates with improved performance.

While flow has been widely studied in fields such as sport and education, its application in gaming remains underexplored. VR may enhance immersion and attention, but can also introduce cognitive overload and simulator sickness. DDA aims to maintain the challenge–skill balance central to flow theory, though its effectiveness remains debated.

A mixed-methods approach was used. Interviews and surveys informed UX design, followed by development of a VR game in Unity with an embedded DDA system that adjusts difficulty based on player performance. Data collection using validated questionnaires and in-game metrics is ongoing, with results to be presented at the open day.

Virtual reality (VR) offers unique potential for inducing flow, yet little research has examined whether Dynamic Difficulty Adjustment (DDA) can sustain the challenge-skill balance required. This project investigated that question through a user-centred design (UCD) process. As UX Designer and Developer, I first conducted a survey (n = 50) and semi-structured interviews to establish user needs, using thematic analysis to translate findings into concrete design requirements. I then designed and developed a VR first-person shooter in Unity for the Pimax Crystal Super, where players shot at suspended moving targets across progressive levels. Working alongside a fellow developer, I implemented the GameManager, DDA logic, and all game design and aesthetics, with target movement speed adapting dynamically to player performance in the DDA condition. Finally, a between-subjects experiment compared the DDA build against a static difficulty control, measuring flow via the Flow State Scale (FSS) alongside secondary measures of cognitive load, user experience, and simulator sickness using the NASA-TLX, UEQ-S, and SSQ.

Urban Aesthetics is an Android application developed to support a psychology study examining whether AI-generated photographic feedback can improve users' photographic outcomes. The application enables users to submit a photograph and receive structured, interpretable feedback across five visual dimensions: lighting/exposure, contrast, framing/perspective, visual focus, and visual complexity. Scores are generated using a zero-shot CLIP ViT-B/16 pipeline, in which per-feature deltas derived from cosine similarity comparisons between the image embedding and positive and negative prompt sets are mapped to a calibrated 0–10 scale. A large language model then translates the numeric evidence into plain-English summaries and actionable suggestions for each feature. The backend is implemented as a FastAPI service; the front end is a Jetpack Compose Android application. The system was designed to make photographic feedback decomposable, transparent, and actionable rather than reducible to a single opaque score.

Overall, this project builds upon Nashville P.I., a game designed to encourage critical thinking about conspiracy theories, by adapting it into a microgame format. However, initial observations of the prototype indicated that unclear feedback limited the development of discernment. Therefore, this study examines how feedback explicitness influences players’ discernment and perceived learning within a conspiracy-themed microgame. A qualitative within-participant study was conducted, involving four gameplay tasks incorporating implicit and explicit feedback. Semi-structured interviews were then carried out after each task and analysed using template analysis. Findings revealed explicit feedback promoted engagement by triggering a reflection-recalibration process. Second, learning emerged as rule-based rather than accuracy-based, with explicit feedback supporting the formation of evaluative principles. Third, confidence aligned with learning only under explicit feedback, where it was grounded in articulated reasoning rather than intuition. Ultimately, feedback explicitness is a critical design mechanism supporting reflective, transferable learning and the development of discernment.

Conspiracy theories and online misinformation are a problem in digital spaces, shaping how people interpret events, trust institutions, and make decisions. In response, researchers have explored interactive digital interventions, especially serious games, to help people recognise misleading information and think more critically. However, these interventions can be time-consuming, difficult, and resource-intensive to develop. This project examines whether that complexity is actually necessary. It compares a game-like interactive intervention with a simpler text-based version to see whether both can improve critical thinking to a similar degree. To investigate this, I designed a 14-day longitudinal study with two conditions. One uses an interactive puzzle-based format, while the other uses a text-based scenario task. In both, participants assess claims, interpret evidence, make credibility judgments, and receive feedback through a Reputation Score. At the end, participants complete the CTAC test to measure discernment and compare the effectiveness of both approaches. The aim is to assess whether simpler interventions offer a more practical way to improve misinformation resistance.

Recent news of Meta’s plans to shut down their Metaverse has sparked debate over whether the Metaverse or Virtual Reality (VR) ever really offered a convincing use case for the average person. However, with new input devices such as Logitech’s MX Ink stylus and the emerging field of how affective computing (the study of emotions and human-computer interaction) can be explored in VR, new ideas for how to apply this technology arise.

This project uses a purpose-built program called Inkspire to compare flow state, affective state and cognitive load between two types of input device during an immersive drawing task. The two input devices are the standard Meta Quest 3 controller and the MX Ink stylus. Usability and self-reported flow, affect and cognitive load were collected though in-VR surveys, and EEG data from the Brainlink Pro headband corroborated the emotional measures. A post-task qualitative survey added extra user feedback and context to the survey data.

With research suggesting a link between high productivity increases and flow state in the workplace, the results of this study may inform future design of VR productivity tools and adaptive interfaces.

This project designs and evaluates Spurdle, a bite sized daily educational narrative game that supports critical thinking to help users recognise and resist conspiratorial content. To inform this design, this study explores the lived experiences of individuals who already engage with short-form educational games such as Wordle and Duolingo. It asks: How do daily educational games shift from a task to a valued routine, and what emotional or reflective changes accompany this process? A qualitative study with ten regular players combined seven days of in situ diary entries with follow up interviews, analysed using Reflexive Thematic Analysis. Findings highlight the role of structural features such as streaks and daily resets, and the framing of play as a cognitively productive alternative to passive digital consumption. Emotional engagement was meaningful yet contained, and repeated completion offered micro achievement and personal benchmarking. These insights shaped Spurdle’s continuity cues, micro feedback, and daily closure mechanics, demonstrating the potential of once a day formats as low barrier tools for supporting digital literacy.

The application integrates a multimodal AI model (CLIP) with a neural probe to provide structured feedback on formal image qualities such as lighting, composition, and visual clarity. It is designed as a tool for systematically guiding users’ attention toward objective visual properties, enabling controlled investigation of how such prioritisation influences aesthetic evaluation.

My individual contribution was the development and deployment of the core machine learning model: a CLIP-based neural probe trained on the AVA dataset of 255,508 crowd-rated photographs, incorporating architectural refinements including a residual projection layer, learnable temperature scaling, and a pairwise ranking loss.

Conspiracy theories are associated with harmful behavioural and social outcomes, yet research into effective interventions remains limited. Most existing approaches are administered in single sessions and measure global scepticism rather than genuine discernment — the ability to distinguish plausible from implausible conspiratorial claims. The present study examines whether a repeated, game-based critical thinking (CT) training intervention can improve conspiracy reasoning discernment relative to an untrained control group. Participants played a purpose-built mobile game across seven consecutive daily sessions, evaluating fictional conspiracy scenarios and selecting the most plausible explanation from three options. CT was assessed using the Critical Thinking About Conspiracies Test (CTAC; O'Mahony et al., 2025), a validated instrument assessing both plausible and implausible conspiracy appraisal. It is hypothesised that participants who completed game-based training will demonstrate significantly higher CTAC scores than the control group. Findings will have implications for scalable, theory-driven interventions targeting conspiracy reasoning.

Fingerspitzengefühl, Wu Wei, flow state; when intuition, effortlessness and immersion converge, you stop forcing thought; the goal is to do good work, not to spend less time. You exist in a reality beyond time - a glimpse of harmony, content mirrors form - tool in hand, task in mind. Our ancestors painted cave walls; in this project, we illuminate sketches in a cave perhaps more Platonic than Plato's: an immersive virtual reality (VR).

This project uses the Logitech MX Ink MR stylus, the Meta Quest VR headset and the WebXR framework alongside the BrainLink Pro EEG device to explore how optimal flow state can be achieved, classified and inferred for the purpose of affective computing. The goal is simple: harness the Logitech MX Ink stylus' precision in three-dimensional space to algorithmically predict the user's flow state.

Study participants were equipped with an EEG and introduced to a VR environment purpose-built to elicit and facilitate flow. The VR application sampled the stylus' positional data and various psychometrics were collated via an embedded VR survey interface as the user completed drawing tasks with the stylus.

This study evaluated the development and selection of bite-sized reasoning puzzles for a mobile game designed to support critical thinking about conspiracy theories. The puzzles simulated features of contemporary information environments, presenting short scenarios in which users evaluated competing explanations. Each puzzle targeted reasoning skills relevant to conspiracy belief, including simpler explanations, source evaluation, corroborating evidence, and lateral reading.

An online study with over 200 participants assessed an initial 10-puzzle set. Participants completed the puzzles followed by the Critical Thinking About Conspiracies (CTAC) assessment. Reliability analysis, exploratory factor analysis, and correlational and regression analyses were used to evaluate puzzle performance.

Results indicated that the puzzles did not form a highly homogeneous psychometric scale, reflecting the varied reasoning processes they were designed to capture. However, puzzle performance showed a meaningful positive relationship with CTAC scores. Based on these findings, a refined 7-puzzle set was retained for use in the final intervention.

This project investigates how software developers think and make decisions when using Generative AI (GenAI) tools such as ChatGPT. Using a mixed-methods design that combines experimental and qualitative approaches, participants will complete programming tasks either with or without AI assistance while verbalising their thoughts. The study examines how developers’ cognitive models of GenAI relate to their trust and self-efficacy, reliance, processes and task satisfaction. Findings will contribute to understanding human–AI interaction in software development and guide responsible AI integration. Within this study, my individual contribution focused on the role of self-efficacy in AI-assisted programming. Following collaborative data collection, survey and transcription, I led the qualitative analysis of think-aloud transcripts relating to self-efficacy, applying Verbal Protocol Analysis to identify how developers' beliefs in their own capabilities shaped their engagement with GenAI tools. This analysis explores whether AI assistance supports or undermines developers' confidence in their own coding abilities.

This project investigates how software developers think and make decisions when using Generative AI (GenAI) tools such as ChatGPT. Using a mixed-methods design that combines experimental and qualitative approaches, participants completed programming tasks either with or without AI assistance while verbalising their thoughts. The study examines how developers' cognitive models of GenAI relate to their trust, self-efficacy, reliance, decision-making processes, and task satisfaction.

My individual contribution applies Hackman and Oldham's Job Characteristics Model to examine how AI assistance affects perceived task characteristics and satisfaction across six dimensions: skill variety, task identity, task significance, autonomy, feedback, and task satisfaction. An 18-item JCM survey was administered to all 20 participants, with quantitative comparisons supplemented by directed content analysis of think-aloud data. This contribution moves beyond productivity metrics to explore whether AI tools enhance or diminish the characteristics that make programming intrinsically motivating.

This project designed and evaluated a chatbot for research onboarding, the process by which participants are introduced to research procedures and expectations. It also examined how well the chatbot could onboard research participants in comparison to human researchers across comprehension and experience.

Research studies involving biological sample collection (e.g. stool) face recruitment and retention challenges, with social and emotional barriers such as embarrassment noted. Chatbots offer a scalable solution, but it remains unclear whether they can reduce these barriers and produce a positive experience in a research participation context. Sixty participants aged 18 to 25 completed onboarding with a chatbot or human researcher reporting, affective experience, task self efficacy, embarrassment and perceived agency.

The chatbot condition showed lower embarrassment but higher negative affect, while the human condition showed higher positive affect and relational competence. These findings indicate reducing discomfort alone is not sufficient to improve experience, and highlight the importance of relational processes in participant engagement.

This study examined whether chatbot-led onboarding affects comprehension of psychobiological research procedures compared to human-led onboarding in young adults (18–25), and whether chatbots support autonomy and reduce social evaluation. Informed consent is challenging in complex, sensitive studies, and while young adults are frequently recruited, engagement varies. Sixty participants were assigned to chatbot (n=30) or human-led (n=30) onboarding for a simulated stool sample study. Comprehension was measured immediately and after two weeks using a 13-item questionnaire, with t-tests and content analysis applied. Both groups showed high comprehension, though chatbot interactions were more task-focused. Findings suggest a hybrid chatbot–human approach may best support engagement and ethically robust informed consent.

Psychobiological research often requires participants to collect biological samples at home, without a researcher present. This can be uncomfortable, both practically and emotionally, and that discomfort is a real barrier to participation. The broader project aimed to design and develop a chatbot onboarding system and compare its effectiveness to human researcher onboarding. This dissertation focused specifically on the usability and user experience of that system. Usability was tested with 30 participants using the Chatbot Usability Questionnaire, interaction logs, and open-ended feedback. The system scored 65.1 out of 100, just under the average benchmark of 68. Participants liked the step-by-step layout, progress bar, and scroll-back functionality. Many also noted that talking to a chatbot felt less embarrassing than going through the same process with a researcher, which matters for a sensitive procedure like this. The biggest problem was response speed, averaging 37.4 seconds per reply, which broke the flow and in one case clashed with a time-sensitive instruction. Overall the chatbot showed real promise, but better response quality and faster load times are needed.

This project presents an application that integrates a multimodal AI model (CLIP) with a neural probe to provide structured feedback on formal image qualities such as lighting, composition, and visual clarity. It is designed as a tool for systematically guiding users’ attention toward objective visual properties, enabling controlled investigation of how such prioritisation influences aesthetic evaluation.

As a UX team member, I contributed to user research and evaluation across development stages. I recruited participants for an initial study using a low-fidelity prototype and assisted in analysing the resulting data, which informed the design team in developing the final application. I also supported recruitment for the final field study, which included a control group, an experimental group using the app, and independent raters who evaluated images blind to condition.

Overview This project investigates how software developers think and make decisions when using Generative AI tools such as ChatGPT. Using a mixed-methods design combining experimental and qualitative approaches, participants completed programming tasks either with or without AI assistance while verbalising their thoughts. The study examines how developers' cognitive models of GenAI relate to their trust, self-efficacy, reliance, and task satisfaction, with the aim of determining whether GenAI enhances learning and productivity or fosters overreliance.

My Contribution My individual contribution focuses on how GenAI assistance shapes developer decision-making in real time, with a particular emphasis on verification and evaluation behaviours, specifically, how developers assess, question, and act on AI-generated output during live coding tasks. Using Verbal Protocol Analysis of think-aloud data, this analysis aims to surface patterns in how developers engage critically with AI suggestions, and what this reveals about autonomy and cognitive dependence in AI-assisted programming.

This project examines the merit of using a generative AI chatbot to onboard participants for a biosampling research study. Recruitment and retention for biosampling studies is affected by a variety of psychosocial factors, including participant embarrassment and distrust. Chatbots can reduce feelings of exposure and could thus improve participation rates. A chatbot prototype was developed to guide participants through a stool sampling procedure and answer questions. The chatbot backend uses Node.js and the Hugging Face transformers.js library to run a local instance of SmolLM2, a lightweight text-to-text generative model. Prompt engineering and retrieval-augmented generation are used to improve response relevancy, with content gathered from authoritative healthcare sources. 60 participants in a comparative study were assigned to onboard with either a human researcher, or the chatbot. The chatbot was found to reduce embarrassment and maintain comprehension, but participant experience was negatively impacted by technical limitations such as slow response speed and repetitious dialogue.

This project investigates how software developers think and make decisions when using Generative AI (GenAI) tools such as ChatGPT. Using a mixed-methods design, participants complete programming tasks with or without AI assistance while verbalising their thoughts. The study examines how developers’ cognitive models of GenAI relate to trust, self-efficacy, reliance, and task satisfaction. By integrating quantitative comparisons with qualitative think-aloud data, the research aims to determine whether GenAI enhances learning and productivity or fosters overreliance, contributing to understanding human–AI interaction.

My contribution spans both qualitative and quantitative analysis. I contributed to the transcription and coding of think-aloud data using Verbal Protocol Analysis (VPA) to identify patterns in reasoning, trust, and reliance. I also helped develop post-task survey measures and analyse participants’ responses. Integrating these data supports a triangulated understanding of how cognitive models influence trust, reliance, and decision-making.

The project involved the development of an AI-driven application that integrates a multimodal model (CLIP) with a neural probe to analyse images and provide structured feedback on formal qualities such as lighting, composition, and visual clarity. The system was designed to deliver consistent, objective feedback on measurable visual features, enabling users to refine images through iterative interaction.

The psychological component of the project focused on examining how engagement with such a system influences aesthetic evaluation. A theoretical framework grounded in cognitive and empirical aesthetics was developed to investigate the relationship between formal image properties, emotional response, and holistic judgment. A user experience study was conducted to assess perceptions of the system and inform interface refinement, followed by the design of a controlled experimental methodology. This included the development of photographic tasks, a structured rating framework, and a statistical analysis strategy to test whether prioritising formal image qualities translates into differences in emotional and holistic evaluation.

My project explores how a virtual reality workspace can be designed to better support flow during stylus-based tasks. As part of a group project, we developed a VR drawing application that formed the basis of this study. While VR is often associated with immersion, immersion alone does not guarantee that a user feels focused, comfortable, or in control. Because of this, my project compares two stylus interaction setups in VR: a horizontal drawing surface and a vertical drawing surface, within a carefully designed flow-supportive environment.

The study is informed by Flow Theory, Cognitive Load Theory, and embodied interaction, which highlight the importance of challenge-skill balance, reducing unnecessary mental effort, and considering how posture, movement, and environmental design shape user experience (Csikszentmihalyi, 1990; Sweller, 1988; Dourish, 2001). Using questionnaires, task performance measures, and supportive qualitative data, this project investigates which surface orientation better supports comfort, control, and sustained engagement in VR and explores how the design of the VR environment can affect users.