Computer Science
System Software

Open Projects

For Master's theses, Bachelor's theses or for Software Engineering projects in the Master's program

(Most topics can be adapted in scale to fit any of the above categories)

  • AI-Enhanced Visual Debugging: Integrating Contextual Learning Support in JavaWiz (HTML + CSS + Javascript / Typescript + a lot of experimental prompt engineering)
    Extend JavaWiz, a graphical debugger, with an intelligent AI-powered tutoring view that addresses the gap between classroom and independent learning experiences. This new component will analyze students' code in real-time, providing contextual suggestions across multiple dimensions including code correctness, readability, style conventions, and performance optimization. The system will function as a virtual programming mentor, offering personalized feedback and adaptive learning recommendations based on the student's coding patterns and common programming challenges. By combining JavaWiz's existing visual debugging features with AI-driven tutoring, this enhancement will create a comprehensive learning environment that supports students during independent study sessions with the same level of guidance they would receive in a classroom setting.
    Contact: Dr. Markus Weninger

  • Tools for Visual Teaching and Visual Learning (e.g., HTML + CSS + Javascript / Typescript)
    Interactive visualizations to help lecturers to teach content in a more engaging way and to help students to learn easier. For examples, have a look at finished theses supervised by me in the past. I do not have a predefined list of visualizations that need to be implemented, but I am open to student suggestions whether they have ideas on how their own study experience could have been improved if interactive visualizations existed in their classes. Feel free to contanct me if you have an idea for such a thesis.
    Contact: Dr. Markus Weninger

  • New JavaScript Language Features - ECMAScript proposals (Java, some JavaScript)
    JavaScript is specified in the ECMAScript language specification. It is an evolving language, and is extended by a "proposal" process. Each new or improved feature is specified by one proposal. Current open proposals include Realms, Pipeline operator, In-Place Resizable and Growable ArrayBuffers, Array find-from-last, Array grouping, and several more. As the different proposals vastly differ in effort to implement them, we have topics for projects (project in software engineering), bachelor theses and master theses. The task is to fully implement the current state of the proposal in the GraalVM/Graal.js JavaScript engine.
    Contact: Fabio Niephaus (Oracle Labs)

  • Windows Support for GraalPy (Java, Python, C, Windows APIs)
    Python on Windows provides some additional modules to access Windows-specific APIs including the MSVCRT, the registry, and the win32 API. GraalPy currently does not offer these. These modules could be implemented in pure Python using the built-in cffi or ctypes bindings, ported from CPython as a C extension library, or implemented in Java to call into the Windows APIs via Truffle NFI. The task is to weigh the implementation strategies and choose one to implement enough features to pass the standard library tests.
    Contact: Fabio Niephaus (Oracle Labs)

  • Automatic Dynamic Optimization of Remembered Sets (HotSpot JVM, C++)
    Summary: Let the G1 collector automatically determine remembered set container options for either reduced memory usage or improved performance.
    The G1 garbage collector is the current default garbage collector in the OpenJDK Hotspot VM. It uses remembered sets to store locations of incoming references to a particular region of the heap. This data structure is basically an implementation of a sparse set of integers: the entire range of possible values is split into evenly sized areas. A top level concurrent hash table stores values in areas that are "in" the set in a so-called remembered set container. Such a container is represented, depending on the number of values to be stored in that area it covers, by different kinds of data structures, e.g. arrays, bitmaps, or even single special integers.
    The remembered set implementation switches between containers on the fly depending on current remembered set entry occupancy of an area.
    G1 currently sizes these containers statically, i.e. independent of actual distribution of values in a given remembered set. So a particular container has a fixed size being able to hold a fixed amount of values, eg. an "array" remembered set container always has 128 entries, regardless of what the typical occupancy of such an array container is. This wastes memory, because different types of applications (and remembered sets for different areas of the heap) exhibit different occupancy characteristics.
    The task is to change G1 to let it reconfigure the remembered set containers based on statistics that need to be gathered while an application is running to optimize for the particular goal, and evaluate the effectiveness of these optimizations on several benchmarks.
    Contact: DI Thomas Schatzl (Oracle Java)

  • Memory Aware Liveness Analysis for G1 (HotSpot JVM, C++)
    Summary: Implement a marking algorithm that attempts to be more memory aware.
    The G1 garbage collector is the current default garbage collector in the OpenJDK Hotspot VM. Its algorithm to determine reachable objects is a straightforward implementation of the Tri-Color abstraction. One drawback of this algorithm is that memory access is very random, which is not optimal for current microarchitectures with regards to to memory accesses.
    There is an old algorithm that tends to linearize memory accesses for large object graphs, potentially reducing the amount of random memory accesses, and so improving performance. Recently, a similar approach has been implemented in Go's Green Tea garbage collector with interesting, but maybe mixed, results.
    The task for this work comprises:
    - Implement a more memory access conscious algorithm (based on these precedents) in the G1 garbage collector
    - Compare its performance, memory access behavior and memory consumption to the existing algorithm on benchmarks.
    Contact: DI Thomas Schatzl (Oracle Java)

  • Improve the JVMTI Support in GraalVM Native Image (GraalVM Native Image)
    The Java Virtual Machine Tool Interface (JVMTI) [1] enables tools that are written in languages like C or C++ to inspect and control the execution of Java applications. Currently, GraalVM [2] Native Image only supports basic JVMTI functions [3], while more complex functions are not implemented and throw runtime errors instead. The main prerequisite for implementing more advanced JVMTI functionality is to fundamentally change how JNI [4] object handles [5] are implemented in GraalVM Native Image. The current implementation allocates Java heap memory, which is a fundamental problem for non-trivial JVMTI functions. The scope of this project includes:
    • Modifying the existing JNI object handle implementation so that native memory is used instead of Java heap memory.
    • Implementing several non-trivial JVMTI functions.
    • Testing and benchmarking the changes.
    • Contributing the approach to the open-source repository [6] (requires signing the OCA [7]).
    GraalVM Native Image is primarily implemented in Java, so Java is also the main programming language that will be used in this project. However, basic C or C++ knowledge is recommended, as there is an existing C/C++ JVMTI implementation in the OpenJDK [8] that can be used as a reference.
    • [1] https://docs.oracle.com/en/java/javase/23/docs/specs/jvmti.html
    • [2] https://www.graalvm.org/
    • [3] https://github.com/oracle/graal/blob/master/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jvmti/JvmtiFunctions.java
    • [4] https://docs.oracle.com/en/java/javase/23/docs/specs/jni/index.html
    • [5] https://github.com/oracle/graal/blob/master/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/handles/ObjectHandlesImpl.java
    • [6] https://github.com/oracle/graal
    • [7] https://oca.opensource.oracle.com
    • [8] https://github.com/openjdk/jdk
    Contact: Dr. Christian Häubl

  • Add a Validation Mechanism to the GraalVM Native Image JNI implementation (GraalVM Native Image)
    The Java Native Interface (JNI) [1] enables interaction between Java code and applications/libraries written in other languages such as C and C++. Due to the lack of comprehensive argument validation, JNI code is prone to errors, often resulting in hard-to-diagnose crashes and undefined behavior. The goal of this project is to improve the JNI implementation [2] in GraalVM [3] Native Image by incorporating basic validation mechanisms (similar to the -Xcheck:jni option [4] in OpenJDK [5]), thus improving the robustness and debugability of JNI interactions. The scope of this project includes:
    • Adding a validation mechanism to the existing JNI implementation.
    • Testing and benchmarking the changes.
    • Contributing the approach to the open-source repository [6] (requires signing the OCA [7]).
    GraalVM Native Image is primarily implemented in Java, so Java is also the main programming language that will be used in this project. However, basic C or C++ knowledge is recommended, as there is an existing C/C++ JNI implementation in the OpenJDK that can be used as a reference.
    • [1] https://docs.oracle.com/en/java/javase/23/docs/specs/jni/index.html
    • [2] https://github.com/oracle/graal/blob/master/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jni/functions/JNIFunctions.java
    • [3] https://www.graalvm.org/
    • [4] https://docs.oracle.com/en/java/javase/23/troubleshoot/command-line-options1.html#GUID-DE9FAAAF-DCD4-4974-A86F-C6B8907CCE9A__CHDDEGBI
    • [5] https://github.com/openjdk/jdk
    • [6] https://github.com/oracle/graal
    • [7] https://oca.opensource.oracle.com
    Contact: Dr. Christian Häubl

  • Designing a music-based programming language
    Contact: DI Christoph Pichler
    While most programming languages are text-based (i.e. the source code is written in textual form), some so-called esoteric programming languages [1] use different representations such as images [2] or theatre plays [3]. This offers the possibility to "hide" programs in media.
    The goal of this master thesis is to develop a programming language based on music: Programs of that language are not represented as text, but represent some kind of music (e.g. audio stored in the MIDI file format [4]) and can thus be listened to as well. Writing programs could be possible e.g. in a piano roll editor [5] or any notation software (e.g. MuseScore [6]). Valid programs should be "nice to listen to".
    Besides basic knowledge in compiler construction, this thesis therefore also requires background in music theory − "chords" and "harmonies" should be familiar terms.
    The tasks are (a) to design a simple programming language which is based on music/audio information, and (b) to implement a simple (e.g. stack-based) interpreter for such a language.
    Contact: DI Christoph Pichler