Explore Projects

<p>Scala-offheap is an experimental project which provides type-safe off-heap memory management for Scala language. The goal of this project is to expose the full potential of Scala off-heap collections by expanding the existing functionality of Array combinator methods and providing an efficient implementation of the off-heap Set and Map classes.</p>

My project aims to address the challenge of navigating and accessing artifacts within Scala projects on Scaladex. Currently, users face difficulty in efficiently exploring and accessing all artifacts associated with a project due to the lack of a dedicated Artifacts page. To solve this problem, I propose to introduce an intermediate Artifacts page, enhancing project visibility and artifact discoverability. The project will deliver a fully functional Artifacts page integrated into Scaladex, providing users with a seamless and intuitive interface to explore and access artifacts associated with Scala projects. Documentation detailing the implementation process and testing outcomes will also be provided for future reference.

<p>VirGL provides an OpenGL path well supported on Linux guests. On the host, QEMU offers several console back-ends, from EGL to SDL. Adding a Vulkan path will require to change the current VirGL API, write new guest drivers, and also offer a way to display the output. This is a huge task, which can be split in several sub-projects. Expending the current VirGL API to support Vulkan is the first step.</p>

<p>This project's main goal is to make it easy for potential contributors to use <a href="https://index.scala-lang.org/" target="_blank">Scaladex</a> to find Scala projects they can work on. This will involve researching common difficulties potential contributors face when trying to find an open-source project to contribute to, designing potential solutions to those problems and implementing those solutions. Reaching out to the Scala community to learn about problems they've faced and their thoughts about potential solutions will be an integral part of this project.</p>

<p>The project aims to improve the integration between <code>ScalaPy</code> and <code>Ammonite</code>/<code>Almond</code> by providing a frictionless installation experience plus a number of quality of life features such as code completion and displaying rich presentations of Python objects. The project also involves developing a Scala - Python integrated environment in which users can switch between a Scala and Python shell and exchange variables between them. The project could benefit Scala programmers seeking access to Python libraries, typically data science and deep learning frameworks, by providing them with a smoother user experience. In addition, it could also help Scala attract Python programmers, who are looking for a type safe language with better concurrency and parallelism support.</p>

<p>During the GSoC I'm going to complete the following tasks:</p> <ol> <li>Enhance the suggestions sorting algorithm using the ML-way inspired by <a href="https://open.afterthedeadline.com/about/technology-overview" target="_blank">after the deadline</a>'s (section "The Spelling Corrector")</li> <li>Migrate the server-side of the LanguageTool to the modern lightweight framework</li> <li>Migrate the LanguageTool from Maven to Gradle</li> </ol>

Knative enables serverless on Kubernetes (scale-to-zero, traffic splitting). This project finishes and polishes a Headlamp plugin so operators can **view, inspect, and manage Knative Services, Revisions, Configurations, and Routes** from Headlamp, complementing the `kn` CLI. Builds on an existing plugin. Expected Outcome: - Fully functional Knative plugin: in the Headlamp repo with a "Knative" sidebar. List KServices across namespaces with key columns (name, URL, traffic %, latest revision status) matching existing tools. - Service detail pages: showing URL, traffic split, concurrency/scaling, conditions; UI actions to adjust traffic, edit config/env/concurrency, and trigger redeploys via forms/modals with feedback and RBAC checks. - Related resources: list/link Revisions, Configurations, HTTPRoute/Knative Route; optional read-only revision/config views. - Headlamp-consistent UX: Map/metrics integration, bug fixes, basic tests, packaged metadata, ArtifactHub releases, README, and a kubernetes blog post with a short demo.

Open source projects often only have a few contributors. They try to incorporate all new ideas and improvements. However, this leaves little time for testing, which means that the quality of the software suffers. Unfortunately, this also applies to Eclipse 4diac. Last year, the foundation for automated testing 4diac IDE was laid with Eclipse SWTBot. However, these tests only cover the most important basic functions such as creating a new project, drag&drop of Function Blocks (FBs) and creating connections between them. The extended functions are still tested manually, such as the SubApps, error markers or loading and testing larger test projects. It has also become apparent that the automated tests need to be more stable, as the 4diac IDE is constantly being extended and improved and some tests that ran last year are no longer running due to these changes. Therefore, these tests need to be more stable and also easily adaptable. An important step in this regard will be that the tests will no longer rely on hard-coded coordinates, but will be able to search for elements by ID. The ability to access the property sheet of 4diac IDE also promises improvements, as it will be important for advanced testing. Nearly every 4diac element has one or more property sheets.

This project aims to add brain imaging data structure (BIDS) provenance to a workflow engine written in Python called ‘Pydra’. The brain imaging data structure format is a widely-adopted framework for disseminating clean datasets for use in the reproducibility of neuroimaging data analyses (https://bids.neuroimaging.io/). This project would aid in this pursuit by establishing built-in support for the BIDS format within the Pydra software package. Pydra is a library that allows complete control of the command line through Python (e.g., within a Jupyter Notebook). The majority of brain imaging data is analyzed using many commands that operate in a serial manner for cleaning, aligning, and applying statistical models to the data often in batches. Rather than relying on shell scripting and manual documentation of software versions, commands used, and outputs that are generated, Pydra can do so automatically. Pydra not only allows commands to be run through Python that would normally be run within the command line, but also unlocks the ability to interface with any CLI binaries a user might have installed as third party tools. Beyond this, Pydra allows the development of ‘workflows’ or stepwise processing pipelines with traceable software and command provenance, allowing an individual to essentially run an exact analysis in a “frozen” environment that the original publisher/researcher/scientist used themselves.

<p>Kubescape evaluates compliance controls using OPA/Rego today, while Kubernetes has shipped native `ValidatingAdmissionPolicy` / `MutatingAdmissionPolicy` resources that use CEL expressions. The [`kubescape/cel-admission-library`](<a href="https://github.com/kubescape/cel-admission-library" rel="noopener noreferrer" target="_blank">https://github.com/kubescape/cel-admission-library</a>) project already ships a growing set of Kubescape controls as VAP resources, but Kubescape cannot evaluate them locally — so a resource passing `kubescape scan` may still fail the cluster's admission controller. This project adds a native CEL evaluation engine to Kubescape (running alongside Rego), using the same `ValidatingAdmissionPolicy` YAML format and `google/cel-go` library that Kubernetes uses internally. With the same rule expression evaluated in both places, Kubescape becomes directly comparable to — and competitive with — Kyverno for teams wanting a single policy language across CI, runtime scanning, and admission enforcement. A sample of existing Rego controls are then converted to CEL as proof-of-concept, validating the conversion pattern end-to-end.</p><p><br></p><p>Expected Outcome:</p><p><br></p><ul><li>New `CELLanguage` rule type dispatched from the existing `runOPAOnSingleRule()` extension point in `core/pkg/opaprocessor/processorhandler.go`.</li><li>runCELOnK8s()` implementation: loads `ValidatingAdmissionPolicy` YAML from `cel-admission-library`, evaluates with `google/cel-go` in a VAP-compatible environment (`object`, `params`, stubbed `request`), maps violations to `reporthandling.RuleResponse`.</li><li>Equivalence guarantee documented: for `object`-scoped rules, `kubescape scan` and the cluster admission controller produce identical results. Known gap (`authorizer`, `request.userInfo`) documented.</li><li>10–20 existing regolibrary (Rego) controls converted to CEL and contributed to `cel-admission-library` as `ValidatingAdmissionPolicy` resources, with a conversion guide for future contributors.</li><li>Unit and integration tests; end-to-end verification showing a converted control evaluated identically by Kubescape and a live VAP on a real cluster.</li></ul>

<p>A engine to simplify Dynamic Partial Order Reduction in JPF as well as a tool to efficiently prove or disprove data race freedom in structured parallel programs that generalizes over input.</p>

<p>We design a simple pipeline for using state-of-the-art speech-to-text, text-to-text, and text-to-speech to create a speech-to-speech translation system as well as text-to-text. Users can then create and share audio or video files that will be translated for them to the language of the other user they want to message.</p>

AOSSIE, as a non-profit educational organization, serves as a hub for impactful open-source projects. However, many of these projects lack modern, user-focused landing pages that effectively communicate their value. This project aims to design and implement high-quality, scalable landing pages that enhance visibility, usability, and adoption across AOSSIE projects. I will go beyond visual design by incorporating robust engineering practices, including internationalization (i18n), localization (l10n), WCAG 2.2 accessibility compliance, and optimizations for performance, SEO, and security. Using a reusable, component-based approach, I will ensure consistency and maintainability across all implementations. The goal is to create interfaces that are not only visually appealing but also intuitive, accessible, and aligned with real user needs. Ultimately, this project focuses on elevating AOSSIE’s overall product experience, transforming landing pages into powerful tools for communication, engagement, and growth, while establishing a scalable design and development standard for future contributors.

Investigate and implement alternative font renderers in FreeType, including: • font-rs • font-go • fontdue • Pathfinder Thus the project is about implementing an alternative FT_Renderer module in C that can take priority over the native FreeType rasterizer after carefully analysing the available work. If required, any Rust code will be ported to C to ensure maximum portability of the code.

<p>This project started in last GSoC but is still missing core functionality</p>

<p>During the project the current model construction will be analysed in regard to performance(i.e. reachability of multiple initial states, scalability and comprehensiveness(adding support for other types of models, i.e. PTAs). Depending on the analysis, it is decided which changes in the current approach enhance the functionality/ performance/ scalability and together with the supervisor a feature list can be defined. Then the implementation of the features is conducted and additionally efficient transformation to a sparse model and full import/export of the explicit model is implemented.</p>

<p>Optimise files plugin tree store and implement non-consecutive commit diff features</p>

<p>Track of a charged particle in a non-uniform electromagnetic field can be described by the first-order initial value problem (IVP). Robustness and efficiency of the integration process is important for overall performance of the simulation code. Geant4 and GeantV use explicit Runge-Kutta (RK) methods with the adaptive stepsize control. I propose to implement several methods which may have a better performance for the problem of interest.</p> <ul> <li>New stepsize control algorithm </li> <li>Integration methods with stable equilibrium states</li> <li>Methods especially designed for periodic problems</li> </ul>

Create real-time WebSocket node telemetry tools for Gazebo robot simulations in modern web browsers.

<p>The ontologies dashboard was developed last year to show the statistics of the data in an interactive manner for helping community members to get a quick overview from different SPARQL endpoints and Databus collections. This year, the focus is more on user engagement for performing data analysis without leaving DBpedia’s Ecosystem. The project is about including more user-customized activities. This includes enabling user login and creating multiple dashboard instances by specifying the Databus collections. The users can write queries and get the results for visualizing the data, here itself. The system will allow users to publish their own dashboards of their linked data by plotting the graphs they like. With this, there are benefits like: User retention rate, and Flexibility for deriving insights.</p> <p>The system design of this project uses the state-of-the-art approach for developing the user specific dashboards by querying the data on specified sources in a modularized manner. This could be the addition of new sub-system in existing DBpedia's Ecosystem.</p>

Guided by theories of expected returns by Ilmanen (2011), we will test models to understand how various factors drive returns on stocks and commodities portfolios. Through a series of replication projects, we will build vignettes to analyze the effects of factors such as inflation, liquidity and economic cycles on portfolio performances. The project pertains to the quantitative analysis of active portfolio management and the three broad areas under which implementations fall are: (i) approaches to dynamic asset weighting, (ii) return factors and their risk premia and (iii) time-varying expected returns. The ultimate goal of the project is to provide an accessible framework for factor and portfolio analysis that adds to existing literature on portfolio management, contributes to open source research and replications, and identifies areas for future research.

Provide financial institutions with real-time insights into loan risk, helping them make better lending decisions. A reactive backend ensures the system can handle a growing number of requests as Mifos deployments expand. Improved risk assessment can lead to more responsible lending practices, ultimately benefiting underserved communities. Create a dedicated microservice in Java that handles loan risk assessment asynchronously. Utilize reactive programming paradigms to ensure scalability and high throughput. Design and implement a configurable risk scoring model that can incorporate multiple factors such as client financial history, repayment behavior, and external credit ratings. Allow for model tuning via configuration, so institutions can adapt the scoring criteria to local requirements.

SageMath's LazyCombinatorialSpecies framework (sage/rings/lazy_species.py) represents combinatorial species as lazy sequences of symmetric-group actions and supports molecular decompositions, generating series, and structure enumeration. Recent work in PR #41655 adds the Hadamard product, functorial composition, and arithmetic product at the level of molecular data, but these operations lack structure generation. The derivative operation is also missing entirely. This project will: (a) implement the derivative and multisort partial derivatives, with cycle index, generating series, and pointing methods (b) extend the Hadamard product and functorial composition to multisort species (c) systematically verify that weights propagate correctly across all operations (d) implement structures() and isotypes() methods for the derivative, Hadamard product, functorial composition, and (time permitting) the arithmetic product. Every new method will be verified against the existing _test_structures consistency checks. The project concludes with full documentation and a pull request.