Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
The following project involves the GPU acceleration of Linear Algebra Computations in SU2. The approach is two pronged, making use of both NvBLAS and incorporation of CUDA Kernels to replace CPU Functions. The goal of the NvBLAS implementation is to intercept Level 3 BLAS calls made by the FEM Solver. Meanwhile, CUDA subroutines have been written to offload Matrix Vector Product calculations in the FGMRES linear solver onto the GPU. The advantages and drawbacks of each approach has been provided in the enclosed report.
This project involves the integration of AlphaMissense, an innovative tool for predicting the pathogenicity of missense mutations, into two established platforms: Genome Nexus and cBioPortal. My Objectives and Deliverables are: - Integrate AlphaMissense pathogenicity predictions into Genome Nexus API responses, enriching genetic variant analysis with detailed pathogenicity scores. - Display AlphaMissense predictions within the Genome Nexus variant pages and add dedicated data columns in the cBioPortal mutation tables, complete with functionalities for sorting, filtering, and downloading. -Add AlphaMissense pathogenicity prediction and score into Genome Nexus annotation pipeline as two new columns in the annotation result file The project will be executed in phases, starting with initialization and planning, followed by backend and frontend development to integrate and visualize AlphaMissense data. Subsequent phases will focus on testing, deployment, and documentation, concluding with a final review and official launch. Post-launch, the project will enter a maintenance and support phase to address any arising issues and incorporate user feedback. Backend development will utilize Java and Spring Boot for integrating the AlphaMissense plugin into the Genome Nexus API. Frontend components will be developed using React and TypeScript, ensuring a dynamic and user-friendly interface for displaying genetic predictions.Comprehensive testing phases, including unit, integration, and User Acceptance Testing, will ensure the reliability and accuracy of the integration. This integration represents a significant leap forward in personalized medicine. By making pathogenicity predictions more accessible and interpretable, this project aims to support advancements in genetic research and clinical decision-making, ultimately contributing to improved patient outcomes.
This proposal aims to add a variety of scientific utilities to the pvlib python project that will focus on new models and research tools regarding shading and spectral effects. These improvements will contribute to expanding the current capabilities in simulating, analyzing, and researching photovoltaic systems. The proposed improvements are comprised of a shading losses model with an example of row to row trackers shading example; a variety of utilities for researching and estimating spectral mismatch losses; a non-uniform irradiance mismatch losses model, and models for Photosynthetically Active Radiation (PAR). These last models would be used in agrivoltaics, the integration of photovoltaic systems in crops. Further details and references can be found in the Proposal PDF file.
gccrs is a full alternative implementation of the Rust language ontop of GCC with the goal to become fully upstream with the GNU toolchain. One of the steps to reach its implementation counterpart's parity (rustc) is the support of inline assembly. Enabling this feature allows programmers to work on low level situation where some extra performance is always needed. The project focuses on adding implementation for two built-in Rust macros: asm!(), and global_asm!(). The gcc compiler will be able to detect parse the assembly code within asm!, and global_asm! macro, converting them to gcc assembly format to eventually generate code.
Neutralinojs is tested on Windows 10 and 11, but it is not well-tested with older Windows versions. The goal of this idea is to update the Neutralinojs framework source, build scripts, and DevOps workflow to officially support older Windows versions. The underlying cause for this issue is not yet identified and remains to be identified and fixed under this project. The project's idea listed too has the same answer. But it is identified that the project can be categorized under Windows API, DevOps, and Configuration areas.
EDM4hep offers a powerful set of objects to describe event data from simulation to analysis. At any step of this chain, one can inspect the event data containing various collections of the objects, e.g. calorimeter clusters, tracker hits, reconstructed particles, etc. At the moment dmX offers only a limited possibility to visualize a tree of MonteCarlo particles. In this project, dmX is extended to visualize other types of collections and relationships between them as a graph to gain more insights about the collisions useful for further development in the Accelerators world.
The project aims to create a Command-line utility tool to manage and manipulate FreeCAD preferences from outside the FreeCAD application. This tool is intended to be used for installing and configuring the FreeCAD all through the scripts.
The Freifunk project collects a snapshot of data from community groups every hour. This has been going on since 2014, and so far the project has amassed a large historical archive of data, available in compressed JSON files. This project will take that historical data, provide some time-series visualisations, and make it available to query through a GraphQL interface.
In the past, I played an active role in the development of a lightweight basic viewer for CGAL, utilizing the GLFW framework. The primary aim of this project is to complete this endeavor and initiate a pull request for CGAL. The process will involve fixing known bugs, refactoring the codebase, and adding missing functionalities such as control improvement and animation system. The next priority will be to enhance the user experience by adding more complex functionalities like a selection system.
I propose to improve the accessibility of Wagtail websites by enabling editors to add alt text to images. Currently, there's no clear way to do this, leading to inconsistent accessibility practices. My solution involves five main parts that are also my deliverables: (1). StreamField Block for Images: I will create a new block specifically for images that includes an alt text field. This ensures editors don't forget to add alt text. (2). Modifying the Image Model: I will add an "image description" field to the existing image model. This provides more flexibility for alt text. (3). Writing tests. (4). Updating documentation. (5). Exploring the use of AI to generate alt text suggestions (as a stretch goal, along with some other stretch goals in the PDF I attached). I plan to achieve the first two goals by building upon the pertinent Pull Requests I have already drafted at the time of writing this. Goals 3 and 4 will follow each of the first two goals closely, and I have commenced research on integrating AI models with inspiration from the Wagtail-AI GitHub repository. For goal 5, I plan on working hand in hand with the A11y team. This project will make Wagtail sites more accessible for visually impaired users and improve overall accessibility compliance.
This integration aims to connect OpenELIS, a laboratory information system, with a FHIR-Based Open Client Registry which will allow users to search for patients within their local OpenELIS system, If the patient isn't found locally, search the client registry then Import patient information from the client registry to OpenELIS. In simpler terms, this lets users find patients within their local system and if not found, search for them in a central database and bring their information back into the local system.
Objectives: 1. Develop toolsets to help unify the development experience using dubbo's IDL mode and Non-IDL mode 2. Develop a set of translation tools to translate in-code interface definition to Protobuf IDL, so that the interface defined in-code can be easily migrated to other programming languages. Plan: 1. Community bonding 2. Basic and extended type mapping between portobuf and non-IDL protocol types 3. Add support to protocol specification in protobuf IDL 4. Add support to reverse translation from in-code interface definition to protobuf IDL 5. Wrap the toolsets into a easy-to-use CLI Deliveries: 1. A CLI that unifies the development using dubbo's IDL and Non-IDL mode 2. Protobuf extensions to help acturalize the features mentioned above
Programming Protocol-independent Packet Processors (P4) is a domain-specific language for network devices, specifying how data plane devices (switches, NICs, routers, filters, etc.) process packets. BMv2 is a P4 software switch. Currently the BMv2 simulator supports v1model and Portable Switch Architecture (PSA). As the P4 use cases on the NIC side increases, so does the need for a P4 simulator that supports Portable NIC Architecture (PNA). In this project, I will focus on adding PNA support to BMv2. This proposal includes adding core subset of PNA to the BMv2 simulator; extending p4c BMv2 backend to target the updated BMv2 simulator; Identifying and Implementing various functionalities required by PNA as externs.
What I aim for the “5G NR module benchmark analysis for distinct channel models” project is to complete it in the available time (175 hours) and successfully, achieve all goals. Moreover, I intend to provide a simple interface, using the NR Helper class, to make setting the channel model easy for users. Afterward, I will create an example of an outdoor scenario to evaluate, assess, and benchmark the channel models that are being implemented. Also, to provide a test case code that uses these three channel models.
This project aims to enhance the bioframe library developed by Open2C, an organization that creates software for analyzing genomic data. A key focus will be expanding the bioframe API to access genome assembly metadata from additional providers like Ensembl and NCBI, enabling more comprehensive data integration. The API will also be extended with efficient query methods similar to the existing UCSC class. Furthermore, the project will explore using the Rust-based polars package as a potential replacement for pandas in bioframe, with the goal of improving memory efficiency and runtime performance for dataframe operations. Bioframe's core modules will be rebuilt using polars, and benchmarking will be conducted to evaluate performance gains. If successful, the polars implementation will be extended to the entire bioframe package and related functions in other Open2C tools that currently utilize pandas and bioframe methods.
The GNU Anastasis is a key recovery system that allows the user to securely deposit shares of a core secret with an open set of escrow providers, to recover it if the secret is lost. The core secret itself is protected from the escrow providers by giving each provider only part of the information, and additionally by encrypting it with an identity-based key unknown to the providers. It prioritizes user privacy by implementing strong cryptographic protocols and privacy-enhancing features. Anastasis comes with an Android app. The GNU Taler Wallet is a software developed within the GNU Taler project. It serves as a user interface for managing digital payments and transactions securely. The app enables users to store digital currency, make payments, and monitor transaction history. Taler Wallet also comes with an Android app. The goals of the project are to design and implement: 1. A mechanism to allow any app to save its secret keys via Anastasis app. 2. A mechanism to allow any app to make its users pay for its services via Taler Wallet app. 3. A feature in Anastasis app that allows its users to pay the backup providers for their service via Taler Wallet app.
The project's core objective is to develop an open-source foundational model for EEG data analysis, using deep learning techniques and extensive pre-training on a broad spectrum of EEG datasets. This foundational model will enable more effective processing, feature extraction, and interpretation of EEG signals, catering to both large-scale datasets and specific, smaller datasets.
We have to adapt a copy of the rustc testsuite to make use of the error code framework implemented in gccrs as part of GSoC 2023. We need to develop a test case runner similar to rustc's one, in order to match error codes and line numbers to the output of gccrs. Specifically, we need to ensure that gccrs is emitting the correct error code consistent with rustc-1.49. This project requires investigating the current test framework of gcc/gccrs (dejagnu) and also the official rustc one. The main exact goal of this project is to have access to a tool which enables us to run gccrs on the rustc test cases and assert that we emit the correct error codes/messages w.r.t to their line numbers. Furthermore, the extended deliverable of this project is to integrate this tool in gccrs CI/CD pipeline.
The main goal of this project is to improve the user experience of Zulip Terminal, a TUI that caters to Zulip's terminal users. My areas of focus are enhancing hotkeys, centralizing configuration and event handling improvements.
This project aims to migrate the existing Scala documentation website from Jekyll to Scaladoc. This migration will provide a more streamlined, modern, and easily maintainable documentation experience that is tightly integrated within the Scala ecosystem. I will focus on replicating key Jekyll features, such as the "include" mechanism and custom tabs, using the "liqp" library within the Scaladoc framework. Existing content (Markdown, HTML, CSS) will be carefully adapted, and styling will be applied to match the look and feel of the current website. If time permits, I will explore additional customizations to Scaladoc's default output for greater layout flexibility. The key deliverables of this project include a functional MVP website, replicated Jekyll functionality, and comprehensive documentation of all implemented features.
The enviroCar Android app provides capabilities for visualizing user related tracks within a map. For this feature, the app makes use of several libraries of the Mapbox mapping framework. However, recent changes in the terms-of-use of Mapbox as well as their switch to a non open-source license makes it problematic to continue relying on Mapbox. MapLibre Native library for Android is an open-source alternative to Mapbox mapping framework. Migrating to MapLibre will ensure the project's adherence to open-source principles & long-term sustainability. Mapbox's current issues are preventing many developers in the open-source community from participating in the further development of the enviroCar app. Thus, this project aims to add support for multiple map providers (primarily MapLibre) into the enviroCar Android application. This will be done by introducing a new extensible and independent map module into the project's source-code. This map module will allow the users to select the preferred map provider/library based on their requirements, both during compile-time and run-time of the application.
In this project, I will be building Knowledge Graph of codes and text modalities from documentation using noe4j, LLms, and langchain. The Knowledge Graph will used for efficient retrieval and explanation. It will help in overcoming the problem of hallucination and the accuracy of the task, all these will be wrapped inside streamlit UI and Flask API.
The proposed project aims to further investigate the potential of neural networks in accelerating the process of ray tracing for 3D rendering. Building upon the foundational work presented by Fujieda et al. at the 2023 High Performance Graphics conference and subsequent research conducted by Texas A\&M students at BRL-CAD, the primary objective is to explore the feasibility of utilizing neural networks for arbitrary shot line queries in ray tracing.
The UNO API allows developers to write code that works with LibreOffice, allowing programmatic control over the entire suite. This provides a robust platform for creating extensions, automations, and integrations with other software systems, whether the task at hand is manipulating documents, spreadsheets, presentations, databases, or drawing files. This proposal aims to upgrade the UNO API support for .NET languages to the latest versions, and bring the bindings to all platforms which support .NET 8. The end goal is to add a .NET 8 compatible binding, complete with a NuGet package for end users, tests and examples for demonstration and documentation to help new users familiarise themselves with the new bindings.