Explore Projects

<h3>GSOC 2020 - Device Handler Development for the SOURCE Project </h3> <h3>Introduction</h3> <p>I am Robin Mueller, a graduate student in aerospace engineering at the university of Stuttgart. I am interested in developing software for the following ideas:</p> <ul> <li>[gsoc20-k-07] Implementing Device Handlers in the Flight Software</li> </ul> <h3>Proposal</h3> <p>I will develop the various device handlers for the SOURCE project with real hardware. I will communicate with the responsible subsystems and mentors about the requirements and the results. I will also try to implement Fault Detection Isolation Recovery (FDIR) functionalities and unique space software components like the thermal monitoring and controlling as well. I will try to apply the concepts of virtualization to enable quick testing of devices where applicable. The goal is to create code which conforms to the unique space environment and is</p> <ul> <li>Clean</li> <li>Reliable</li> <li>Maintainable</li> </ul>

This project focuses on extending the noWorkflow scientific workflow library by introducing new features that enhance its ability to analyze experiment reproducibility, particularly through the use of Abstract Syntax Trees (ASTs). noWorkflow is a library that tracks the lineage of data from its origin to its current state in experiment trials. While it effectively captures trial data, its existing methods for comparing these trials and evaluating reproducibility are limited. To address these limitations, this project implements a method for generating the trial’s AST from noWorkflow's provenance data, providing a more precise representation of the code structure. This method allows users to gain deeper insights into how code evolves and interacts over time and offers flexibility through command line or visualization tools. Additionally, a new feature is introduced to visualize the definition of a trial, providing a comprehensive view of the trial's code components and their relationships. These enhancements collectively boost noWorkflow’s functionality, making it a more powerful tool for analyzing and ensuring reproducibility in scientific workflows, and strengthening confidence in experimental outcomes.

<p>MacPorts currently uses a legacy version of Buildbot (0.8) as its continuous integration framework and hasn’t upgraded due to certain drawbacks in the Waterfall view of the newer versions. However, the currently deployed version is outdated and fails in several aspects due to the absence of some key features such as:</p> <ul> <li>The ability to write custom JavaScript views (UI components).</li> <li>Triggering a build whenever a pull request is made. Currently, a build can be started only when patches are committed to the master branch.</li> </ul> <p>This has led to some major setbacks with respect to developer productivity. MacPorts also needs some custom views in buildbot to be able to better analyze build history, commits, etc. The legacy version doesn’t allow us to write such custom views. This project will involve upgrading the Macports Buildbot infrastructure to the latest version, developing a plugin for buildbot and writing custom views.</p>

This project aims to improve the robustness and flexibility of topic modeling in the CHAOSS Augur platform by enhancing its clustering_worker component. Currently, Augur relies on a static number of LDA topics, lacks model versioning, and does not support retraining based on data drift. To address these issues, this project will: Introduce dynamic topic number estimation via Gensim’s HDP model. Implement model versioning with model_id and timestamp support. Record model metadata including hyperparameters and coherence scores. Add automatic parameter tuning using coherence-based grid search. Detect data drift and trigger model retraining accordingly. Export rich visual outputs such as pyLDAvis and wordcloud images. Deliverables include upgraded database schema, a refactored topic modeling pipeline, metadata tables, Jupyter demo notebooks, and HTML visualizations for CHAOSS dashboards. These changes will make Augur’s insight engine more adaptive, interpretable, and future-proof.

In the current KubeSlice design, IP address management (IPAM) for slice overlay networks is static and inefficient. A predefined CIDR block (e.g., 10.1.0.0/16) is divided into a fixed number of subnets regardless of how many clusters participate in the slice, leading to significant IP space wastage. This project aims to implement a dynamic IPAM system that allocates IP subnets to clusters on demand and reclaims unused ranges when clusters leave the slice. It will ensure efficient address utilization, synchronization across clusters, and integration with the KubeSlice control plane. Expected Outcome: 1. A dynamic IPAM allocator integrated with the KubeSlice controller or sidecar component. 2. Support for on-demand IP allocation and subnet reclamation when clusters join or leave a slice. 3. Conflict resolution and state synchronization across clusters using CRDs or distributed storage. 4. Documentation on how the system works, configuration options, and edge case behaviour.

<p>The Shogun Toolbox is a well-established machine learning project that provides efficient algorithms implementations that can be used in a wide range of applications and with multi-language support (thanks to SWIG magic). Unfortunately, since it was built by many hands for many years, its code has become not easily maintainable or extendable and it does not use many new programming techniques and components that have appeared since the Shogun foundation. The time has come to blow some fresh air (and some new fresh code) into Shogun's depths. This project aims to correct and update the codebase and to complete the integration of many new features that will make it more modular and easy to use. My efforts will be focused on: integrate the new Tags and serialization frameworks, substitute old-style macros with brand new C++11 smart pointers, enable premature stopping of ML algorithm and, last but not least, implement a useful (and beautiful) progress bar to show a visual representation of algorithm’s execution.</p>

This proposal aims to add support for rectilinear floorplans in OpenROAD, an open-source EDA tool used for digital chip design. Currently, OpenROAD only supports rectangular floorplans, which limits its use in modern designs that often require more complex shapes—especially in advanced packaging, chiplet architectures, and 3D ICs. The project will allow users to define floorplans using arbitrary rectilinear shapes made of 90° corners. It involves three main components: accepting polygonal input during floorplan setup, generating standard cell rows and routing tracks that follow the shape boundaries, and updating the pin placement logic to work with irregular outlines. By enabling these capabilities, OpenROAD will become more flexible and suitable for real-world designs where blocks may need to fit together like puzzle pieces. This can lead to better area utilization and potentially shorter interconnects. The project will also include comprehensive testing, documentation, and example scripts.

HPX, as a framework designed for high performance computing, has various benchmarks for measuring the performance of its various components, which includes parallel algorithms, its runtime system, etc.. But these benchmarks (performance tests) lack a standardized format and a visualization tool that can help in analyzing performance trends over time, in different operating environments. Hence, the goal of this project is to standardize the benchmarks' output formats within HPX, and to also add integration with an external benchmarking framework, i.e., nanobench. Additionally, a visualization tool will also be developed, which will leverage the standardized formats to display the results of the benchmarks in an intuitive manner. Expected results: (1) A unified format for HPX benchmarking using chosen benchmarking framework. (2) Automating the installation of the chosen benchmarking framework in the HPX build system. (3) A visualization tool, developed using python and matplotlib, to display the results. (4) Integration of this plotting tool with CI/CD pipelines, to track and display performance reductions or improvements

This project proposes the integration of Empirical Dynamic Modeling (EDM) into the Fisheries Integrated Modeling System (FIMS), an open-source framework used for fisheries stock assessment. While FIMS currently supports parametric models such as catch-at-age and surplus production models, ecological systems often exhibit nonlinear dynamics that are difficult to capture with predefined equations. EDM offers a data-driven alternative that reconstructs system dynamics directly from time-series observations using delay embedding techniques. The project will implement core EDM components within FIMS, including delay-embedding generation and prediction algorithms such as Simplex projection, S-map, and Gaussian Process EDM. These methods will be integrated with the existing FIMS statistical inference framework to enable empirical forecasting and hybrid modeling approaches. The final outcome will be a modular EDM module, tested using GoogleTest and testthat, along with documentation and example workflows to demonstrate its application in fisheries modeling.

<p>The initial target was to port Qt Labs Calendar to QuickControls2. Due to changes in the structure of the QuickControls2, calendar is now a Marketplace component. The new goal is to update the Calendar extension and make sure that it meets all the QQC2 module standards and supports all features like styling.</p> <p>Modularity and Simplicity is the main target of the Qt Quick Controls 2. QQC2 have a very broad scope, in that they provide a styling system flexible enough to allow the development of applications that have either a platform-dependent or platform-independent style. That is the reason that C++ is responsible for handling events and logic, and thus the performance is increased, allowing the visual QML layer to be a simple, declarative layer on top. This is of course reflected in the structure of the controls project: all visual implementations sit in the imports folder, so that developers who want to create their own complete style can do it easily. Because of the above, updating the Calendar widget to Qt Quick Controls 2 standards is something essential and will have a significant impact for the Qt users.</p>

<p>With GTK 4 around the corner, supporting it in Rust allows more developers to fully utilize Rust in GNOME development with its rich feature and safety guarantees. To support GTK in Rust, the gtk-rs project has provided great tools for creating bindings using the glib object model. This project will utilize the tools from gtk-rs and extend GTK support to its newest version. As the GTK toolkit contains various components, this project will aim to address them in the following order:</p> <ul> <li>gtk4-sys, gdk4-sys, gsk4-sys, and graphene-sys FFI bindings (done prior to this project)</li> <li>graphene-rs (started prior to this project)</li> <li>gtk4-rs</li> <li>gdk4-rs</li> <li>gsk4-rs</li> </ul> <p>In addition, this project will port GTK Rust examples to GTK 4, as a validation to the work done in API bindings.</p>

Jaeger-v1 has its own Kubernetes Operator (https://github.com/jaegertracing/jaeger-operator) which deploys Jaeger components according to the deployment strategy as well as the database or datastore. The goal of this project is to develop a new operator for [Jaeger-v2](https://github.com/jaegertracing/jaeger/issues/4843) that achieves feature parity with the v1 operator while introducing improvements and new capabilities. This new operator will leverage the [OpenTelemetry operator](https://github.com/open-telemetry/opentelemetry-operator) for Jaeger-v2 deployment while maintaining and enhancing the storage management features from the v1 operator. More details in the [upstream issue](https://github.com/jaegertracing/jaeger/issues/5766). Expected Outcome: By the end of this project, we aim to achieve full feature parity between the Jaeger v2 operator and the v1 operator, with the added benefits of OpenTelemetry integration. The new operator will provide a seamless experience for users, maintaining the robustness and flexibility of v1 while introducing the advantages of v2 and OpenTelemetry.

This project aims to extend the functionality of the Eclipse Dash License Tool by adding support for Software Bill of Materials (SBOM) files as input, specifically in CycloneDX and SPDX formats. Currently, the tool can accept and process dependencies from Maven files or NPM package files, but lacks the capability to accept SBOM files as input - a feature that is becoming more standardized in modern licensing software. This proposed solution involves the implementation of specific file parsers for CycloneDX and SPDX formats, extracting and normalizing component data, and then integrating this data into the tool's existing workflow. In addition, this project will support the generation of enriched SBOM outputs that include updated licensing information whilst preserving the initial contents of the file structure and metadata. The final deliverables for this project include SBOM input support via new command-line arguments, file parsing, integration with the rest of the tool's existing workflow, enriched SBOM output generation, extensive testing, and explicit documentation.

<p>Computational models of neural circuitry are increasingly superseding single neuron models for understanding dynamic processes in the brain. Recurrent Neural Networks offer an attractive method for simulating, replicating, and characterizing these circuits. PyDSTool currently supports simulation of neural circuity dynamics and linear methods of dimensionality reduction such as Principle Component Analysis for normalizing complex data; however, such methods are insufficiently tailored to working with non-linearly distributed data. I propose the implementation of a module targeted at providing non-linear dimensionality reduction via Sammon mappings, principal curves, and locally linear embeddings. In addition, I will create tools in Fovea that will allow for the intuitive visualization of datasets resolved by these methods.</p> <p>I also seek to provide a suite of tools to PyDSTool for constructing and training Recurrent Neural Networks and corresponding solutions for visualizing the operation, feedback mechanisms, network structure, and dynamical systems characteristics (e.g. attractors) of these models.</p>

<p>Pathways are created by selecting certain genes and studies then displayed in the PathwayMapper tab in the cBioPortal. However, not every page in cBioPortal has a direct link to PathwayMapper hence making inferences from specific pages and reflecting the outcome to PathwayMapper is not straightforward. In order to overcome the struggle to interact between the pages and pathways, a PathwayMapper tab will be incorporated into Study View, Patient View, and Comparison pages. To test the implementations, I will deploy cBioPortal to Heroku so that I can test the code and ensure that it works in a remote server. PathwayMapper is used to construct pathways however pathways can become very complex and hard to understand as the data mounts. Some features are expected to be implemented in PathwayMapper to decrease the complexity of pathways and make it easy for users to draw conclusions. Features expected to be implemented are Expand-collapse operations, Hide-show operations, Filtering, Highlighting. For PathwayMapper editor features I will use functionalities that are already implemented in the Cytoscape.js. Bugs in Collaborative Mode will be fixed.</p>

<p>The project aims to add three main components to the appleseed render to improve the hair and fur pipeline. Firstly, the addition of per vertex attributes to the curves primitive in order to create a more robust hair fibre curve representation. Secondly, the creation of a hair binary file format to import hair geometry from popular modelling softwares and export the format for ease of data flow in production. It will also support conversion from different binary hair file formats to the new native format. Finally, the addition of an advanced hair shading model that is tuned for production rendering. It is a physically based hair shader that captures the effects of the light scattering through hair fibres. The model is importance sampled and also has various parameters to change physical properties in the hair like refractive index and colour absorption and distribution. This project will fix one of the main deficiencies of the appleseed renderer and help the renderer challenge other production renderers for the mantle of the best.</p>

Snowflake is a pluggable transport that helps users bypass censorship and access the Tor network. It uses webRTC technology to create a peer-to-peer connection between the user's browser and a volunteer proxy server. The Tor project aims to create a new and improved website for Snowflake that provides a better user experience for both new and existing users. As the Snowflake has gained a lot of popularity recently, it has seen a significant increase in the number of visitors with various doubts and queries The existing website does not effectively address these concerns, so our goal is to create a user-friendly static & secured website that is easy to navigate and provides clear information about Snowflake and its proxies. At the End of this summer: 1. A new static website with a modern and intuitive layout for desktop and mobile devices integrated with other Tor Web products & follows tor's brand guidelines. 2. Improved Snowflake proxy guide for new and existing user 3. Ensuring the website is sustainable and easy to maintain by new contributors & developers over the long term.

<p>A formal power series is a (potentially) infinite sequence of coefficients. It turns out to be practical to denote it as an infinite series, although it does no longer represent a function. However, the usual operations on power series, such as addition and multiplication, can be given combinatorial meaning, which makes them an indispensable tool in discrete mathematics. Lazy Formal Power Series are an implementation of the Formal Power Series for a computer where coefficients are only computed on-demand, to deal with the problem that we can store only a finite amount of information. SageMath has an implementation of the Lazy Formal Power Series in the combinatorial species code. The project aims to disentangle the code from the unrequired submodules and create a robust structure. Another aim of the project is to implement Puiseux Series and bring in the implementation of the Laurent Series code into the same module. There are also bugs in the code that computes the coefficients of series which are defined implicitly by a system of functional equations. Fixing these is another milestone. A detailed list of issues and tasks can be found in ticket #31651 on the Sage Trac server.</p>

The Debian LSP Language Server currently provides only basic features — field completion, parse-error diagnostics, and simple quick fixes — leaving Debian maintainers without the rich IDE experience available in other ecosystems. This project significantly expands its capabilities across five areas identified from direct codebase exploration: clickable links and URL navigation in packaging files, richer hover documentation sourced from Debian Policy, improved completion quality with context-aware and deduplicated suggestions, consistent editor integration (with a focus on Helix), and formatting and structural editing support including folding ranges and auto-formatting. Each area will be delivered as an independent, tested pull request. The work integrates with debian-analyzer and the deb822-lossless crate to support multiple Debian control-file formats (debian/control, debian/copyright, debian/changelog, debian/watch ...) and lays the groundwork for real-time validation and go-to-definition across multi-file packaging trees.

<p>This project is aimed at providing linear time implementation for modular decomposition of graphs and digraphs. Modular decomposition is decomposition of graph into modules. A module is a subset of vertices and it is a generalization of connected component in graph. Let us take for example a module X. For any vertex v ∉ X it is either connected or not connected to every vertex of X. Another property of module is that a module can be subset of another module. There are various algorithms which have been published for modular decomposition of graphs. The focus in this project is on linear time complexity algorithms which can be practically implemented. The project further aims to use the modules developed for modular decomposition to implement other functionality like skew partitions. Skew partition is partition of graph into two sets of vertices such that induced graph formed by one set is disconnected and induced graph formed by other set is complement of the first. Modular decomposition is a very important concept in Graph Theory and it has a number of use cases. For instance it has been an important tool for solving optimization and combinatorics problems.</p>

This project is dedicated to streamlining and enhancing the CircuitVerse development experience. Our primary objective is to simplify the setup of the development environment and streamline the coding process, ultimately making it more efficient. Furthermore, we aim to bolster the quality of our test cases and optimize the continuous integration (CI) workflow, which will, in turn, reduce the time required for code reviews by our maintainers. -- Throughout this project, our key objectives include: 1. Integrating the Ruby Debugger 2. Incorporating Solargraph Language Server Protocol (LSP) and Crafting YARD Documentation 3. Integrating Vite Rails for Improved Development Workflow 4. Incorporating RBS in the Project and Implementing Static Type Checking in CI 5. Implementing Undercover CI for Enhanced Code Coverage Analysis 6. Enhancing Unit Testcase Coverage 7. Adding Missing Integration Testcases 8. Enhancing the Remote Development Platform (GitHub Codespaces, Gitpod) 9. Improving the Docker Development Setup 10. Enhancing Setup Documentation for Developers

<p>Business Process Model and Notation (BPMN) is a standard way of representing business processes in graphical representation.The purpose of this project is to implement Web based BPMN editor to construct business processes diagrams, which can be exported as a BPMN-2.0 compatible XML format . This BPMN diagrams can be built using components like tasks, events and gateways etc. Users can implement their BPMN diagrams by dragging, dropping, positioning, resizing, deleting and adding more details to the attributes. Constructed BPMN diagrams can be then exported as png/jpeg or a process definition XML file(BPMN 2.0 standard).BPMN editor also supports the inverted process, which is uploading of a standard BPMN model in XML format to generate a BPMN process diagrams.</p> <p>This piece of software has the capability to build complete Business process diagrams and is also extensible to allow the construction of flow charts, chevron charts and other graph-based diagrams.</p>

Lucene.NET’s current replication system lacks seamless integration with ASP.NET Core and is not modular enough for use across diverse application types like Windows services or cloud-native tools. This proposal focuses on enhancing the `Lucene.Net.Replicator` by introducing full support for ASP.NET Core Dependency Injection (DI), simplifying configuration to a one-liner, and enabling real-time replication using technologies like WebSockets or gRPC. Additionally, it aims to modularize replication components to support non-web environments and build robust unit tests and real-world examples. Deliverables will include: - DI-based configuration system for easier integration in ASP.NET Core and beyond. - Real-time replication architecture replacing polling. - Support for Windows services, CLI tools, and distributed systems. - Comprehensive testing and documentation. These changes will make Lucene.NET replication more developer-friendly, scalable, and production-ready.