Computer Science

System Software

Master's Theses

Available Topics | Theses in Progress | Finished Theses

Available Topics

See also our projects, which can be adapted in scale to fit the workload of a Master's thesis

Theses in Progress

Caputure & Replay of JavaWiz Applications (Alexander Do, , Supervisor: Prof. Prähofer)
Graal Support for Valhalla (Michael Haas, Supervisor: Prof. Mössenböck, Doug Simon, Dr. D. Leopoldseder)
A Data-flow Analysis Framework for Graal IR (Christoph Aigner, Supervisor: Prof. Mössenböck, Dr. G. Barany)
Supporting Multiple Garbage Collectors in a Single GraalVM Native Executable (Thomas Schrott, Supervisor: Prof. Mössenböck, Dr. Ch. Häubl)
A Generic Machine Code Instrumentation Library (Alexander Voglsperger, Supervisor: Prof. Mössenböck, P.Feichtinger, M.Obermüller)
Web-Based Bytecode Interpreter Visualization (Tobias Herber, Supervisor: Dr. Markus Weninger)
Floating Point Compression of Time Series (Konstantin Urbanides, Supervisor: Dr. Markus Weninger)
Advanced Debugging of Native Images in GDB (Dominik Mascherbauer, Supervisor: Prof. Mössenböck, P. Wögerer, Ch. Wirth)
A Comparative Analysis of Interactive Coding Platforms and a Prototype of a New Environment based on Recording and Replaying User Interactions (Khlil, Supervisor: Prof. Prähofer)
A Tool for Creating Personalized Semester Schedules (Adrian Vinojcic, Supervisor: Prof. Mössenböck)
An Android App for Tagging Music Collections (Milan Sandor, Supervisor: Prof. Mössenböck)
A Vue.js-based image editor for ad-hoc graphics on the web (Marindo Beka, Supervisor: Dr. Markus Weninger)
Adding multi-tenancy and a flexible permission system to the online examination tool Xaminer (Gabriel Guldner, Supervisor: Dr. Markus Weninger)
Visualization of Complex Object Structures in Java (Valentin Jochinger, Supervisor: Prof. Prähofer)
Generation of Java Interfaces for Accessing Foreign Objects (Julian Garn, Supervisor: Prof. Mössenböck, Dr. Angerer)

Finished Theses

2024: Workflow Enhancements for the Online Examination Tool Xaminer (Alexander Kainzinger, Supervisor: Dr. Markus Weninger) - Thesis
2024: Development of a Java Debugger Framework Based on the Espresso VM and Its Compilation to JavaScript (Felix Schenk, Supervisor: Prof. Prähofer) - Thesis
2024: A new Mark-and-Copy GC for GraalVM Native Image (Christian Aistleitner, Supervisor: Prof. Mössenböck, Dr. Hofer) - Thesis
2024: A Profiler for Java Programs (Mathias Wöß, Supervisor: Prof. Mössenböck) - Thesis

2023: Analyzing Collection Staleness and Collection Anti-Patterns that Lead to Memory Problems (Markus Hirth, Supervisor: Markus Weninger) - Thesis
2023: ECMAScript's Pipeline operator for Graal.js (Alexander Stummer, Supervisor: Prof. Mössenböck, Dr. Wirth) - Thesis
2023: JavaWiz - A Visualization Tool for Software Development Education (Katrin Kern, Supervisor: Prof. Prähofer) - Thesis
2023: Throughput Barrier Exploration for the Garbage-First Collector (Protopopovs) - Thesis
2023: Ein Prototyp eines Simulationssystems zur Lageroptimierung (Nikola Radic) - gesperrt bis Mai 2028
2023: Fallstudie zur Korrelation von eingemeldeten SW-Fehlern zu Daten aus statischer Code-Analyse (Martin Schütz) - Thesis
2023: Full WASM Support for GraalVM Node.js Applications (Florian Huemer) - Thesis

2022: Exam Analytics - Visualisierung von Prüfungsergebnissen (Oktay Akgül) - Thesis
2022: Daas: Debugging as a Service (Markus Mülleder, Supervisor: Markus Weninger) - Thesis
2022: Running Swift-compiled LLVM IR code on Sulong (Christoph Pichler) - Thesis
2022: Domain-Specific Languages in Kotlin and Scala - A comparison (Clemens Bartl)
2022: On-the-fly Analysis of Just-in-time Compiled Code to Identify Anti-Patterns (Simon Schuster)
2022: A Comparison of Thread-based and Reactive Server Programming Models and Technologies (Marcel Homolka)
2022: Ahead-of-time Optimizations in a Java to JavaScript Compiler (Christoph Schobesberger)

2021: Memory Profiling Analysis for .NET (Daniel Schneider)
2021: Analysing Raw Process Dumps as Managed Java and .NET Dumps (Lukas Androsch)
2021: A Persistency Layer for the ECCO Variation Control System based on JPA and JDO (Philipp Schörkhuber)
2021: Work Stealing in the Hotspot VM (Johannes Scheibl)
2021: Unittest-Generator (cooperation with Software Quality Lab) (Jakob Faschinger).
2021: Visualizing System Architectures with Time Series and Event Metadata (Ante Dilber)

2020: Symbolic Execution on GraalVM (Thomas Pointhuber)
2020: Reactive und Non-blocking E-Mail Processing based on ReactiveX (Christoph Gerstberger)
2020: A Truffle CIL Interpreter (Patrick Hagmüller)
2020: Using Tree Visualizations to Investigate Heap Evolution Over Time (Lukas Makor)
2020: Symbolic Execution for Compiler Optimizations on the GraalVM (Sebastian Kloibhofer)
2020: Unification and Automation of Time-Based Heap Analysis Methods (Elias Gander)
2020: Memory Leak Investigation using Graph-based Visualization (Alexander Lang)
2020: Allocation Profiling Analysis (Simon Eilmsteiner)
2020: A Truffle-based Compiler for IEC Languages (Michael Jäger)

2019: Event Prediction in Multi-System Monitoring through Deep Learning (Mario Kahlhofer)
2019: Reactive Conversion Server (Sanel Badic)
2019: A Truffle-based Interpreter for x86 Binary Code (Daniel Pekarek)
2019: Integration of Feature Modeling and Static Code Analysis in the FORCE Tool Environment (Kevin Feichtinger)

2018: On-stack Replacement for Sulong (Raphael Mosaner)
2018: Implementation of a Register Allocation Verifier for the Graal Compiler (Gabriel Schörghuber)
2018: An ECMAScript 2015-Compliant Automata-based Regular Expression Engine for Graal.js (Josef Haider)
2018: Playground Environment for Solving Traveling Salesman Problems (Simon Woisetschläger)
2018: A Framework for Teaching Programming with Gamification (Lukas Ehrenfellner)
2018: Live Queries in the CELUM Reactive Server Platform (Florian Latifi)
2018: Fork/Join Work-Stealing for Truffle without Sequential Overhead (Vaishali Dhanoa)
2018: Analysis and Model Abstraction of C Programs based on the Frama-C Tool (Thomas Böhm)
2018: Low-Overhead Debugging Support for an LLVM IR Interpreter (Jacob Kreindl)
2018: Analysis and Visualization of Linux Core Dumps (Dominik Steinbinder)

2017: A Monitoring Agent for Go (Michael Obermüller)
2017: Assigning Precise Allocation Events to a Sampled Call Context Tree (Stefan Wurzinger)
2017: A Dependency Browser for Program Comprehension and Change Impact Analysis of PLC Programs (Peter Feichtinger)
2017: Heap and Lifetime Visualization in a Memory Monitoring System (Christina Rammerstorfer)
2017: Efficient Tracing of Actor Programs with Minimal Program Interference (Dominik Aumayr)
2017: Distributed and Feature-oriented Version Control within FORCE (Daniel Hinterreiter)
2017: Implementation of a Graph Coloring Register Allocator for the Graal Compiler (Florian Schröckeneder)
2017: User-defined Visualizations for AntTracks(Markus Weninger)
2017: Lightweight Memory Allocation Tracing for Java(Stefan Fitzek)
2017: Portable Tracing of Lock Contention in Java Applications (Andreas Schörgenhumer)
2017: Techniques for Measuring the Loading Speed of Web Pages (Markus Wagner)

2016: SPARC Backend for Graal (Stefan Anzinger)
2016: jSpyder - ein Profiling API für Java (Martin Lettner)
2016: App Store for Massive Scale Software Diversity (Dominik Lichtenauer)
2016: Entwurf und Entwicklung einer interaktiven Programmiersprache (Rainer Gutkas) [Diplomschrift | Software auf GitHub]
2016: Realisierung eines Systems für die statische Analyse von SPS-Programmen der CoDeSys-Sprachfamilie (Christian Huber)
2016: Runtime Analysis of High-Level Java Synchronization Mechanisms on the Virtual Machine Level (David Gnedt)
2016: A DSL for Specializing AST Interpreters (Christian Humer)
2016: Einbettung des Capture/Replay-Verfahrens in das Keba-Laufzeitsystem (Armin Weidinger)
2016: Java X86 Structured Disassembler (Reinhard Umgeher)
2016: Smalltalk Interpreter in Java (Helmut Rohregger)
2016: Graal Inspect (Stefan Rumzucker)
2016: Chancen und Risiken beim Einsatz von Technologien im Unterricht (Daniel Mitgutsch)

2015: JavaScript Backend for Graal (David Leopoldseder)
2015: Online-Sammlung von Algorithmen (Wolfgang Küllinger)
2015: Analysis of PLC Programs Using the Program Analysis Framework SOOT (Andreas Grimmer)
2015: Interactive System for Live Voting (Elozino Ofualagba)
2015: Dynamic Visualization of Compiler Graphs (Ingomar Wesp)
2015: Profile-driven Source Code Highlighting (Thomas Feichtinger)
2015: Instrumentation of Ruby Web Applications (Martin Ennemoser)
2015: Dokumentenzentrierte Architektur auf Basis von Plux (Dominik Zaunrieth)
2015: Post-Mortem Memory Profiling for Java Applications (Verena Bitto)

2014: String Optimizations for Graal (Robert Ebetsberger)
2014: ARMv8 Backend for Graal (Daniel Sturm)
2014: Rapid Experimentation for High-Performance Computing (Franz Schickermüller)
2014: Lernsequenz zum experimentellen Einstieg in die imperative Programmierung (Günter Öller)
2014: Truffle/C Interpreter (Manuel Rigger)
2014: Komponentenbasierte Spieleentwicklung (Hannes Bachmayr)

2013: Truffle/C Runtime Environment (Matthias Grimmer)
2013: Ein komponentenbasierter Taschenrechner auf Basis von Plux (Bernhard Schenkermayr)
2013: Instrumentation of Dynamically Generated .NET Code for Performance Analysis (Bernhard Prügl)
2013: JavaScript AST Interpreter in Java (Andreas Wöß)
2013: Programmieraufgabben für Pidgets und den Raspberry Pi im Informatikunterricht (Klaus Rabeder)
2013: Portierung der Plugin-Plattform Plux nach Java Nikolai Spasov)
2013: Editor für die einfache Erstellung und Bearbeitung von Vektorgrafiken (Philipp Hörtler) [Diplomschrift | Software]
2013: Real-Time Automatic Detection of Stuck Transactions (Peter Hofer)
2013: Ein mobiles System zur Trainings-Verwaltung für Fuß;ballspiele (Michael Herceg)
2013: Monitoring Performance and User Experience of HTML5 based Web Applications (Simon Schatka)
2013: Profiling von Java-Anwendungen durch Bytecode-Instrumentierung (Erich Georg Hochmuth)
2013: Parameter Mining (Andreas Bespaletz)
2013: Grammar-based Editor With Syntax Highlighting and Code Completion (Andreas Greilinger)
2013: Customer Relationship Management System für BlackBerry (Seifriedsberger Roland)
2012: Retrofitting Security in Component-based Applications (Thomas Hribernig)
2012: Vergleich einführender Programmiersprachen im Informatikunterricht (Sonja Reinisch)
2012: Trace-based Debugger for Dynamically Composed Applications (Philipp Lengauer)
2012: Deployment Assistant for Plux (Thomas Reinthaler)
2012: GUI Library for the Mokka Framework and its Implementation for Windows (Ralf Reiterer)
2012: Dynamic Mixins for Java (Kerstin Breiteneder)
2012: Source to Source Translator from C# to Java and ActionScript (Christoph Wimberger)
2012: Statische Analyse von SPS-Programmen nach IEC 61131 (Florian Angerer)
2012: Time Travelling Debugger für SPS-Programme (Richard Berger)
2012: Automatic Dependency Reduction between Java Classes and Packages (Andreas Müller)
2012: Installation und Update von Softwarekomponenten und Datenbankschemata (Rainer Pichler)

2011: User interface design of an agriculture-related application (Bernhard Pflug)
2011:State-Model-Viewer in C#/WPF (Martin Hehl)
2011: Ein LR-Parser-Generator für EBNF-basierte-Grammatiken (Richard Uttenthaler)
2011: Model zur Platformunabhängigen Softwareanalyse (Erhard Pointl)
2011: Serializable Coroutines for the HotSpot Java Virtual Machine (Lukas Stadler)

2010: Werkzeug zur Verwaltung von Bookmarks in Web-Browsern (Thomas Reichenberger)
2010: Rosenbauer Identity Management (Franz Rechberger)
2010: Source Code Analysis for Checking Java Access Modifiers (Lin Jinxiang)
2010: General Purpose Dependency Viewer (Andreas Demuth)
2010: Eine Skriptsprache samt Interpreter für mobile Anwenungen (Michael Siegel)
2010: Kundenbeziehungsmanagement Plux-CRM für Plux.NET (Sabine Weiss)
2010: Visualisierung Genealogischer Daten (Christof Höll)
2010: Werkzeug zur Verwaltung von Internet-Domainnamen (Armin Elbs)
2010: Umstrukturierung eines monolithischen Softwaresystems in ein Plug-In-basiertes Komponentensystems (Christian Mittermair)
2010: Java Bytecode Editor für Eclipse (Markus Burchhart)
2010: Instrumentation of Distributed .NET Applications for Performance Analysis under Load (Christian Schwarzbauer)

2009: Coco/R Grammar Version Management Tools (Alexander Leitner)
2009: Active Text Elements in Eclipse (Manfred Waldl)
2009: Entwicklung eines Eclipse-Plugins für Regressionstests von serverbasierten Webanwendungen (Günter Öller)
2009: Monaco und Statecharts im Vergleich (Johannes Straßmayr)
2009: Ein erweiterbarer Dateimanager für hierachische Inhalte. (Josef El-Rayes)
2009: Analyse von .Net Bytecode (Thomas Pollak)
2009: Tail Calls for the Java HotSpot VM (Arnold Schwaighofer)
2009: Entwurf und Implementierung eines Cross-Compilers von Delphi nach C# (Markus Jahn)
2009: Konzeption einer RPC-Lösung für das Universal Terminal API bei Mobiltelefonen (David Lösch)

2008: A Framework for Multi-platform Compilation of Real-Time Reactive Control Programs (Roland Schatz)
2008: Model-Based Generation of End-User Programming Environments (Christian Wirth)
2008: Cross-Platform IL manipulation Library (Markus Gaisbauer)
2008: Optimized Strings for the Java HotSpot VM (Christian Häubl)
2008: Eine Spielumgebung samt Editor für das chinesische Brettspiel Go (SHI Qi)
2008: Ein Plugin-basiertes Werkzeug zur Überwachung von Web-Inhalten (Mario Eder)
2008: Vergleich neuer .Net 3.0 Features mit bekannten Technologien (George-Mihai Homorozeanu)

2007: Eine erweiterbare Persistenz-Schicht für JavaTM und relationale Datenbanken (Michael Manner)
2007: Analyse von Java-Programmen mittels Coco/R (Wolfgang Ahorner)
2007: Ein Internet-basiertes Evaluierungssystem für Lehrveranstaltungen (Philip Grasböck)
2007: Automatische Codeerzeugung in Compilern mit Hilfe dynamischer Programmierung (Igor Böhm)
2007: Visualization of Program Dependence Graphs (Thomas Würthinger)
2007: "Elektronisches Kehrbuch" (Gernot Innthaler, in Kooperation mit Fa. WinChim)
2007: Compiler Data Flow Visualization (Stefan Loidl)
2007: Entwicklung eines Kollaborationswerkzeugs für Präsentationen in Lehrveranstaltungen (Gerald Pohn)
2007: A Change Framework based on the Low Level Virtual Machine Compiler Infrastructure (Jakob Praher)
2007: Entwicklung einer Domain-spezifischen Sprache samt Laufzeitumgebung für Steuerungsaufgaben (Stefan Preuer)

2006: Modellierung von Architekturvariabilität in Softwaresystemen (Reinhard Stoiber)
2006: Das Komponentenframework OSGi (Martin Luksch)
2006: Eine neue Notation zur Darstellung von XML-Texten samt Entwicklung eines Editors für sie (Christian Danner)
2006: Entwicklung einer auf Python basierenden Rich Client Platform für Linux (Hermann Lacheiner)
2006: Model Based System Test (Franz Hochrainer)
2006: Eclipse Plugin zum Testen von Java Dateien (Andreas Jagersberger)
2006: Ein Dateivergleichswerkzeug für Microsoft Powerpoint (Gerald Wintersberger)
2006: An Environment for the Programming Language Scheme (Peter Feigl)
2006: Entwurf und Implementierung eines Use-Case-Editors (Werner Putschögl)
2006: CAP.NET - Rich-Client-Plattform für .NET Komponentenmanagement und User-Interface-Integration (Deepak Dhungana)

2005:Interoperatbility between Unmanaged and Managed Programs (Friedrich Priewasser)
2005: Ein Online-Trainingssystem für das Rechnungswesen (Brigitte Rafael)
2005: Programm zur Erstellung persönlicher Stundenpläne (Christian Fröller)
2005: Eine generische Middlewareschicht für die Interprozessorkommunikation auf mobilen Systemen (Thomas Schatzl)
2005: Ein Framework zur kontaktlosen Benutzung der Keplercard (Daniel Hofer)
2005: Internetbasierte Gruppenkoordination "WebAgenda" (Gerald Schnepf)
2005: Entwicklung einer Web-Service-Schnittstelle sowie einer Benutzeroberfläche für HeuristicLab Grid (August Steinbacher)
2005: Systematische Testfallgenerierung für den Black-Box-Test (Thomas Wetzlmaier)
2005: Synchronisation mittels Portabler Speichermedien (Rene Löschl)
2005: Verwaltung von Literatursammlungen mittels semantischer Informationen (Elmar Habelsberger)

2004: Sicherheit in Webanwendungen (Grininger Hubert)
2004: Profiler (Lehner Klaus)
2004: Registerallokation nach dem Linear-Scan-Verfahren für einen Java Just-in-Time-Compiler (Christian Wimmer)
2004: Multiuser Awareness Environment: "CyberStudent" (Michael Schrank)
2004: Optimisation-Hint Tool (Karl-Heinz Steineder)
2004: Report-Generator für ODBC-Datenbanken (Gammer Herbert)
2004: ProjectCoordinator (Lackner Bernhard)

2003: Eine vergleichende Literaturstudie über Compilergeneratoren (Christian Mansky)
2003: Eine visuelle Entwicklungsumgebung für Testtreiber (Koblbauer Markus)
2003: Automatische Generierung von XML-Schemata und UML-Klassendiagrammen (Jochinger Dominik)
2003: XML Editor (Hametner Dieter)
2003: Ein Werkzeug für den White-Box-Test (Löberbauer Markus)

2002: Dynamisch generierte Flash-Applikationen (Edlmair Christof)
2002: Steuerung eines Ultraschallkopfes (Mayr Martin)
2002: Component Tools (Girlinger Franz)
2002: Überwachungstool für Internet-Server, Router und Firewalls (Heigl Harald)
2002: Implementation of a Java-Script Interpreter (Pfeiffer Michael)
2002: Just-in-Time-Compiler für Java (Thomas Kotzmann)
2002: HTML Browser/Editor (Andreas Krumenacker)
2002: Ein Framework zur Erzeugung von Dokumentationen für Softwareschnittstellen (Christian Wohlfahrtstätter)

2001: Automatische Verhandlungsprozesse im E-Commerce (Manfred Steinlechner)
2001: Dynashop: XSL Editor und WebShop (Kriegner)
2001: Einsatz von Handheld-Computern im betrieblichen Umfeld (Schwaiger Gerhard)
2001: Distributed UML Editor (Schumacher Martin)
2000: 3D-Visualization of Object Interactions (Wöß; Albrecht)

2000: Flexible Visualisierung von Walzstraßen (Ertl Chris)
2000: Visual Builder Tool for JavaBeans (Beer Wolfgang)

1999: Distributed File System (Robert Lichtenberger)
1999: Schnelle Textsuche mittels regulärer Ausdrücke in umfangreichen Softwareprojekten (Rammerstorfer Martin)
1999: J-- A Development Environment for Java (Pühringer Edgar)
1999: Distributed Editor with Java RMI (Prenninger Christof)

1998: An Object-Oriented Interpreter Framework for the Oberon-2 Programming Language (Oblitschnig Günter)
1998: OLE Textelemente (Sabine Wimmer)
1998: Distributed Whiteboard with Java RMI (Aufischer Stefan)
1998: Distributed Text Editor in Oberon (Wimmer Markus)
1998: Werkzeug für den White-Box-Test (Meindl Felix)

1997: Implementation of an Exception Mechanism (Pirklbauer Peter)
1997: Postscript-Interpreter (Gehrer Gerhard)
1997: Liftsteuerung mit einem Mikrocontroller (Wismayr Stefan)
1997: Entwicklung einer Programmierumgebung für Blinde (Pöcksteiner Christian)

1996: Hierarchical File Manager for Oberon (Mayrhofer Christian)
1996: 80386-Assembler für Oberon (Leitner Herbert)
1996: A Graphical User Interface for the Oberon System (Knasmüller Markus)
1996: Literate Programming (Lehner J.)
1996: Ein objektorientiertes Framework zur Compiler-Generierung unter Oberon-2 (Fellmayr Rainer)

1995: Spreadsheet Elements in Oberon Texts (Kogler Manfred)
1995: Bitmap-Editor (Chiettini Stefan)
1995: Datenbankanbindung für Oberon mit ODBC (Steindl Christoph)