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 KDE Mentorship website plays a important role in onboarding new contributors to the KDE community. However, the current site lacks a modern, user-friendly UI, and doesn’t fully support KDE’s future goals of recruitment and engagement. This project aims to redesign the website into a contributor onboarding and recruitment platform. It will organize the site into clear sections: Mentorship Programs, Communication Channels, Resources, Community Engagement and Recruitment Services. The project will be built using HuGo for static site generation, Go for the backend logic such as personalized resource recommendations and contributor assessment. Deliverables include a fully responsive website which shows all the mentorship program details, resource recommendations, contributor testimonials, and a recruitment pathfinder system. This project directly aligns with KDE’s goal: "KDE Needs You" , which aims to bring more contributors into the community for next two years.
This project addresses the issue of fragmented tools within the Kubeflow ecosystem, specifically Elyra, Kale, and Jupyter Scheduler, which complicates workflows for data scientists. The proposal aims to solve this by developing a unified JupyterLab plugin for Kubeflow. This plugin will consolidate and modernize the functionalities of the existing tools, providing a cohesive environment for developing, testing, and deploying machine learning workflows directly from JupyterLab. The plugin will achieve this by implementing seamless integration with Kubeflow Pipelines. Users will be able to convert notebook cells to pipeline steps, define and visualize pipeline workflows, submit pipeline runs, and monitor their execution status, all within JupyterLab. The plugin will be built with a modular architecture, including Python backend components for interacting with Kubeflow Pipelines and parsing notebooks, and TypeScript/React frontend components for the user interface. The key deliverables of this project are: • A unified JupyterLab plugin architecture consolidating Elyra, Kale, and Jupyter Scheduler functionalities. • Seamless integration with Kubeflow Pipelines, enabling notebook-to-pipeline conversion, workflow definition and visualization, pipeline submission, and monitoring within JupyterLab. • A user-friendly UI for pipeline development and management using modern React components. • Initial integration with Kubeflow Notebooks for easier notebook provisioning. • Comprehensive documentation and usage examples. • A robust testing framework to ensure plugin reliability, including unit tests, integration tests, user acceptance testing, continuous integration, and compatibility testing. This unified plugin is expected to significantly improve workflow efficiency for data scientists and ML engineers by bridging the gap between interactive development and production-grade ML infrastructure.
The project aims to improve scanning accuracy by computing summary and license clarity scores for each package and its files, rather than for the entire scan. This involves enhancing package models, storing license detection references, and ensuring proper attribute collection for all package ecosystems.
After taking time to discuss the Submitty system with a professor that uses it daily as a grading tool for their classes, a place for improvement that I have found lies in the design and depth of accessible statistics and reports on how students are doing in their class. The Submitty system currently does not have a user-friendly way of viewing student grades for the instructor or TA. This creates an issue for the instructor in being able to clearly see how their students are doing in the class, trends in which problem sets might cause issues. Having a clearer user designed portion for instructors and graders to easily access understandable graphs, stats, and updates on student progress would benefit the Submitty system greatly by having a better user experience on the instructor and graders end.
Erddap is a data server used by many organizations as a way to download scientific data in various formats. However, adding these datasets to Erddap is by no means a simple task and this project aims to improve that experience for all Erddap administrators who wish to serve their datasets on their Erddap servers. The primary focus of this project would be to improve the existing XML parser that Erddap uses to incorporate new features done by either exisiting libraries or by enhancing the parser source code. Other features that will be worked on are a better way to generate xml for a large number of datasets instead of just the current GenerateDatasetsXML script along with a notification system which tracks for problems while loading the datasets and mails them directly to the administrators.
Professional-grade cameras capture photos in a raw format before being processed into actual pixel data by a photo editing application. The Rust ecosystem lacks a library for decoding and processing raw files that meet's Graphite's requirements for being modular, pure Rust, and permissively licensed. This project aims to develop a crate that will enable Graphite to begin its growing focus on the envisioned photo editing feature set.
This project aims to enhance the capabilities of neural-fortran, a parallel Fortran framework for deep learning, by implementing additional optimization algorithms. While the framework currently supports training and inference of dense and convolutional neural networks using stochastic and mini-batch gradient descent optimizers, more versatile learning and training from a broader range of problems and datasets require the use of other optimization algorithms such as RMSprop, Adam, and others commonly used in popular deep learning frameworks like Keras. The project will also require work on implementing, documenting, and testing these optimizers, which will broaden the applicability of neural-fortran and allow it to be used for a wider range of deep learning tasks. The successful implementation of these optimization algorithms will provide users with more flexibility and choice when training their models, ultimately improving the performance and capabilities of neural-fortran.
jpf-core is essentially a JVM that currently fully supports only Java 8. The goal of this project is to make it up-to-date with new features of Java 11. The key feature of Java 11 that is currently not fully supported are bootstrap methods that are generated at load time. They are used for things as common as string concatenation ("Hello, " + name). As of now, many cases are supported, but there are still many programs (and unit tests) that fail with Java 11. The priority of this project is to attain 100% compatibility with Java 11 by fixing the 15 tests failing currently.
TTree is the ROOT’s legacy columnar storage that has been used to store more than 1 exabyte of high-energy physics data during the last 25 years. RNTuple classes provide ROOT’s new, experimental I/O subsystem for HEP data. This project will consist of the implementation of an automatic conversion tool that migrates both the schema (i.e. fields and their types) and the user data. This project consists of four milestones 1) parse the schema of a TTree; 2) convert TTree with simple variables; 3) convert TTree with STL container; 4) convert TTree with user-defined class. There are three deliverables 1) a parser that automatically parses the schema of an input TTree; 2) a TTree-to-RNTuple converter; 3) proper documentation and tests.
<p>Gaussian processes (GPs) are flexible probabilistic models with a wide a variety of applications. However, in their simplest form they scale notoriously poorly with large datasets. There has been much work in recent years to develop approximate methods which enable GPs to be used with much larger datasets.</p> <p>This project will focus on implementing such approximate methods for Gaussian processes within the JuliaGaussianProcesses ecosystem with the goal of achieving performance which is competitive with similar established Python packages (specifically GPFlow and GPyTorch).</p>
<p>I am proposing to be part of the Robotics Middleware Framework running scenarios project. I am interested in multi-robot management because it is closely related to what I am working on now and I believe that my knowledge would be useful in the project.</p>
<p>Python 2.7 has already retired and it will no longer be maintained therefore it will better to drop the support of Python 2. It will also include removal of test suite for scancode-toolkit and this project is an extension of my previous year GSoC 2019 porting project. Also to add the support for python 3.7 and python 3.8 and to improve the third party package provision. Currently, we maintain a third party repository which locks all dependencies of scancode.But we face the following problems. a)We supported Python 2 & Python 3.6. Each version of python may need a pre-built wheel if there is native code. And to add support for python 3.7, 3.8 we have to add wheels in the third party repo of 4 variants(oses) for each dependency.<br> b)We support Windows, Linux, macOS and possibly FreeBSD each with some possible architecture variants. For each of these we are storing a variant for each of the Python versions above. This creates way too many wheels that end up making ScanCode checkouts very long and tarballs too big. Therefore i decided to improve the provision of third party dependencies to minimise the problem we facing till now.</p>
<p>OSEM( Open Source Event Manager ) has the functionality to allow submissions for Booths and Tracks and evaluate them to either accept/reject the submission. This proposal proposes to further improve the process by adding more functionality by adding new features and implementing appropriate enhancements to the existing features. Some of them include customizing individual submissions to include additional details, ability to comment and rate submissions and making it possible to link different submissions.</p>
<p>Scala Native provides bindings for several C and POSIX APIs out of the box. To help complete and maintain the list of supported APIs as well as seamlessly use 3rd party native libraries support for automatically generating bindings is needed. The goal is to create a tool that parses C header files using LibTooling and generates a Scala Native API as well as an sbt plugin to use the binding generator in a project.</p>
<p>This project’s purpose is to replace or rather migrate the existing persistence schema of LibreHealth toolkit which uses hibernate mappings to a more modular spring data persistence mechanism.<br> LibreHealth toolkit currently uses xml style mapping provided by hibernate which is harder to maintain and provides very little modularity in terms of switching to a different data source.<br> Using spring data instead will make the system easier to maintain i.e lesser components to change in case a single entity needs to be modified, whereas in the current scenario to modify a single entity we might need to change the model class, the mapping file, the dao, the service, etc. This makes for a more resilient system.</p>
<p>InterMine has an Android application and is looking to make it available on iOS as well. Native iOS application will allow researchers to have access to InterMine data using fast, reliable and intuitive interface.</p>
<p>I propose to create a USB Flash Drive with the possibility to conceal the fact that the flash drive contains hidden information. I mean that hidden folders will not be displayed if the USB drive is connected to a computer. The microcontroller of the USB drive will carry the process of encryption and concealment of files. That is why the only solution to break protection will be to physically read memory from the memory component and break the encryption algorithm to get the plain data.</p>
<ol> <li><p>Programs and settings are a inseparably bound with each other. Every professional application gives users the freedom to change default values to their needs and preferences. Toga should realize this need and provide a strong and compelling solution to create beautiful and platform native settings. The creation of the Settings API is the main part of this proposal.</p> </li> <li><p>As a supporting project I also propose the first steps to build up a testing suite for the Toga project. The Toga project is completely untested at the moment. To change this, I will start to tackle the not trivial problem of cross platform testing, by build an inward facing testing system to test toga core and its interface.</p> </li> </ol>
OpenMRS has historically operated as a single-instance application, creating a "hard ceiling" for scaling and a single point of failure. As global healthcare networks grow, there is an urgent need for High Availability (HA). While foundational work on distributed caching and storage was introduced in version 2.8.x, several critical gaps remain: lack of distributed session management, race conditions during cluster startup, duplicate execution of scheduled tasks, and inconsistent search indexes across nodes. This project aims to complete the "Cluster-Ready" roadmap for OpenMRS 3.x. Drawing inspiration from proven architectures like Confluence Data Center, I will implement a Zero-Footprint, Multi-Replica framework. I hope to do this by Implementing a formal "Local Home vs. Shared Home" split to manage node-specific vs. cluster-wide data. I want to make use of distributed State Introducing Redis and MySQL-backed session management so users remain logged in even if routed to different replicas. Leveraging Infinispan to implement distributed task locking (preventing duplicate background jobs) and a "Cluster Safety" mechanism to detect and mitigate split-brain scenarios. Transitioning Hibernate Search to a shared OpenSearch/Elasticsearch backend to ensure search consistency across the entire cluster. Project Deliverables: A safe startup sequence for containerized environments (Kubernetes/Helm). Configuration-driven support for Redis (Redisson) and JDBC session persistence. A wrapper for the OpenMRS SchedulerService to ensure tasks run on exactly one node. Audit and migration of O3 modules (FHIR2, Webservices.rest) to the distributed cache manager. Application-level wiring for shared full-text search indexes. A robust integration testing framework using Testcontainers to validate cluster behavior in CI/CD.
The project aims to improve longitudinal normative modelling in PCNtoolkit by validating, debugging, and extending velocity-based models to support multiple timepoints per subject. The work will include integrating the updated models into the toolkit’s modular architecture, adding tests and documentation, and developing functionality for predicting individual brain changes over time from multiple past observations.
Zplit is a decentralized, privacy-first group expense tracking application designed to give users full control over their financial data without relying on centralized servers. Unlike traditional apps, Zplit operates using peer-to-peer technologies such as Wi-Fi Direct, Bluetooth, NFC, and QR codes, enabling seamless offline-first collaboration.I will implement Deep Link integration for seamless group invitations, integrate USDC/DAI stablepay settlement for expense splitting, and build interactive data visualizations . All user data will be synced peer-to-peer via Wi-Fi Direct, Bluetooth, NFC, and QR codes, ensuring zero cloud dependency. The final deliverables will include a fully functional Flutter app with Deep Link support, stablepay payment flow, expense visualization dashboard
This project will build and integrate a Python-based client for the buildingSMART Data Dictionary (bSDD) directly into FreeCAD's BIM Workbench. This integration will allow users to dynamically search and apply international classification standards from the cloud, providing context-aware suggestions based on the underlying IFC entity. To ensure a stable and non-disruptive integration, the project will implement a "dual-layer" data model. This approach will securely store the rich, web-fetched bSDD metadata while automatically populating the existing legacy string properties, guaranteeing 100% backward compatibility with FreeCAD's current stable workflows.
The goal of this project is to improve the compositor's sampling situation. This includes exposing the interpolation option to all nodes reliant on it. The interpolation options are already partially implemented, as seen in this issue: https://projects.blender.org/blender/blender/issues/119592. Furthermore, sampling requires boundary conditions, such as zero, extend, or wrap. Currently, these conditions are not exposed to the user, but use the wrap condition across different sampling methods. The conditions should also be selectable in the node giving more freedom to the users. Lastly, there is one sampling method that requires some special attention – BLI_ewa_filter. Currently, the EWA sampling uses different implementations across CPU and GPU, leading to different results on different devices/OSs. Blender uses EWA sampling primarily for anisotropic texture sampling. The goal is to write an implementation of the EWA filter for the CPU, which is transferable to the GPU, aiming for similar/equal results for CPU and GPU versions, allowing it to be used in the compositor to enable anisotropic compositing.
Cmm is the intermediate representation and code generation layer used by the Glasgow Haskell Compiler (GHC). It is written in Haskell and sits between GHC's high-level STG output and low-level native or LLVM code generation. Cmm enables multiple backends: a fast native code generator and a more sophisticated LLVM backend. In principle, this design allows users to choose between faster compilation or better runtime performance. However, like other parts of GHC, the documentation for Cmm is sparse, fragmented, and in many places outdated. For example, references to Static Single Assignment (SSA) form often describe it as "future work," even though there has been a prior attempt at implementing it. There is no cohesive documentation to explain what was done, how the backend currently works, or how one might extend it. This is an obstacle to contributors, researchers, and users alike. In practice, the LLVM backend suffers from long compile times and a fragile implementation. It depends on a custom LLVM AST that is hard to maintain, and requires users to install a specific, outdated version of LLVM. Meanwhile, the native backend is fast but unable to fully optimize performance-critical code. This project proposes to address these issues in stages: 1. Document the Cmm pipeline, the backend interfaces, and existing SSA infrastructure. 2. Then, depending on the mentor's and community's feedback, pursue one of two improvement paths: